rwsdk 0.1.13 → 0.1.15-test.20250714213423

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/vite/configPlugin.d.mts

@@ -1,8 +1,7 @@
 import { Plugin } from "vite";
 export declare const cloudflareBuiltInModules: string[];
 export declare const externalModules: string[];
-export declare const configPlugin: ({ mode, silent, projectRootDir, clientEntryPathnames, workerEntryPathname, }: {
-    mode: "development" | "production";
+export declare const configPlugin: ({ silent, projectRootDir, clientEntryPathnames, workerEntryPathname, }: {
     silent: boolean;
     projectRootDir: string;
     clientEntryPathnames: string[];

package/dist/vite/configPlugin.mjs

@@ -1,7 +1,7 @@
 import path, { resolve } from "node:path";
+import { builtinModules } from "node:module";
 import enhancedResolve from "enhanced-resolve";
 import { SSR_BRIDGE_PATH } from "../lib/constants.mjs";
-import { builtinModules } from "node:module";
 // port(justinvdm, 09 Jun 2025):
 // https://github.com/cloudflare/workers-sdk/blob/d533f5ee7da69c205d8d5e2a5f264d2370fc612b/packages/vite-plugin-cloudflare/src/cloudflare-environment.ts#L123-L128
 export const cloudflareBuiltInModules = [
@@ -15,9 +15,10 @@ export const externalModules = [
     ...builtinModules,
     ...builtinModules.map((m) => `node:${m}`),
 ];
-export const configPlugin = ({ mode, silent, projectRootDir, clientEntryPathnames, workerEntryPathname, }) => ({
+export const configPlugin = ({ silent, projectRootDir, clientEntryPathnames, workerEntryPathname, }) => ({
     name: "rwsdk:config",
-    config: (_, { command }) => {
+    config: async (_) => {
+        const mode = process.env.NODE_ENV;
         const baseConfig = {
             appType: "custom",
             mode,
@@ -78,6 +79,9 @@ export const configPlugin = ({ mode, silent, projectRootDir, clientEntryPathname
                             jsx: "automatic",
                             jsxImportSource: "react",
                             plugins: [],
+                            define: {
+                                "process.env.NODE_ENV": JSON.stringify(mode),
+                            },
                         },
                     },
                     build: {
@@ -121,6 +125,9 @@ export const configPlugin = ({ mode, silent, projectRootDir, clientEntryPathname
                         esbuildOptions: {
                             jsx: "automatic",
                             jsxImportSource: "react",
+                            define: {
+                                "process.env.NODE_ENV": JSON.stringify(mode),
+                            },
                         },
                     },
                     build: {

package/dist/vite/createDirectiveLookupPlugin.mjs

@@ -9,7 +9,6 @@ import { getSrcPaths } from "../lib/getSrcPaths.js";
 import { hasDirective } from "./hasDirective.mjs";
 export const findFilesContainingDirective = async ({ projectRootDir, files, directive, debugNamespace, }) => {
     const log = debug(debugNamespace);
-    const verboseLog = debug(`verbose:${debugNamespace}`);
     log("Starting search for '%s' files in projectRootDir=%s", directive, projectRootDir);
     const filesToScan = await getSrcPaths(projectRootDir);
     log("Found %d files to scan for '%s' directive", filesToScan.length, directive);
@@ -17,10 +16,10 @@ export const findFilesContainingDirective = async ({ projectRootDir, files, dire
         try {
             const stats = await stat(file);
             if (!stats.isFile()) {
-                verboseLog("Skipping %s (not a file)", file);
+                process.env.VERBOSE && log("Skipping %s (not a file)", file);
                 continue;
             }
-            verboseLog("Scanning file: %s", file);
+            process.env.VERBOSE && log("Scanning file: %s", file);
             const content = await readFile(file, "utf-8");
             if (hasDirective(content, directive)) {
                 const normalizedPath = normalizeModulePath(projectRootDir, file);
@@ -33,11 +32,11 @@ export const findFilesContainingDirective = async ({ projectRootDir, files, dire
         }
     }
     log("Completed scan. Found %d %s files total", files.size, directive);
-    verboseLog("Found files for %s: %j", directive, Array.from(files));
+    process.env.VERBOSE &&
+        log("Found files for %s: %j", directive, Array.from(files));
 };
 const resolveOptimizedDep = async (projectRootDir, id, environment, debugNamespace) => {
     const log = debug(debugNamespace);
-    const verboseLog = debug(`verbose:${debugNamespace}`);
     try {
         const depsDir = environment === "client" ? "deps" : `deps_${environment}`;
         const nodeModulesDepsDirPath = path.join("node_modules", ".vite", depsDir);
@@ -57,25 +56,26 @@ const resolveOptimizedDep = async (projectRootDir, id, environment, debugNamespa
             log("Found optimized dependency: filePath=%s, optimizedPath=%s", id, optimizedPath);
             return optimizedPath;
         }
-        verboseLog("File not found in optimized dependencies: id=%s", id);
+        process.env.VERBOSE &&
+            log("File not found in optimized dependencies: id=%s", id);
         return undefined;
     }
     catch (error) {
-        verboseLog("Error resolving optimized dependency for id=%s: %s", id, error);
+        process.env.VERBOSE &&
+            log("Error resolving optimized dependency for id=%s: %s", id, error);
         return undefined;
     }
 };
 const addOptimizedDepsEntries = async ({ projectRootDir, directive, environment, debugNamespace, files, }) => {
     const log = debug(debugNamespace);
-    const verboseLog = debug(`verbose:${debugNamespace}`);
     try {
         const depsDir = environment === "client" ? "deps" : `deps_${environment}`;
         const depsDirPath = path.join(projectRootDir, "node_modules", ".vite", depsDir);
         const manifestPath = path.join(depsDirPath, "_metadata.json");
-        verboseLog("Checking for manifest at: %s", manifestPath);
+        process.env.VERBOSE && log("Checking for manifest at: %s", manifestPath);
         const manifestExists = await pathExists(manifestPath);
         if (!manifestExists) {
-            verboseLog("Manifest not found at %s", manifestPath);
+            process.env.VERBOSE && log("Manifest not found at %s", manifestPath);
             return;
         }
         const manifestContent = await readFile(manifestPath, "utf-8");
@@ -89,7 +89,8 @@ const addOptimizedDepsEntries = async ({ projectRootDir, directive, environment,
                     contents = await readFile(resolvedSrcPath, "utf-8");
                 }
                 catch (error) {
-                    verboseLog("Error reading file %s: %s", resolvedSrcPath, error);
+                    process.env.VERBOSE &&
+                        log("Error reading file %s: %s", resolvedSrcPath, error);
                     continue;
                 }
                 if (hasDirective(contents, directive)) {
@@ -103,13 +104,13 @@ const addOptimizedDepsEntries = async ({ projectRootDir, directive, environment,
         }
     }
     catch (error) {
-        verboseLog("Error adding optimized deps entries: %s", error);
+        process.env.VERBOSE &&
+            log("Error adding optimized deps entries: %s", error);
     }
 };
 export const createDirectiveLookupPlugin = async ({ projectRootDir, files, config, }) => {
     const debugNamespace = `rwsdk:vite:${config.pluginName}`;
     const log = debug(debugNamespace);
-    const verboseLog = debug(`verbose:${debugNamespace}`);
     let isDev = false;
     log("Initializing %s plugin with projectRootDir=%s", config.pluginName, projectRootDir);
     await findFilesContainingDirective({
@@ -149,11 +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$`),
                     }, () => {
-                        verboseLog("Esbuild onResolve: marking %s as external", config.virtualModuleName);
+                        process.env.VERBOSE &&
+                            log("Esbuild onResolve: marking %s as external", config.virtualModuleName);
                         return {
-                            path: config.virtualModuleName,
+                            path: `${config.virtualModuleName}.js`,
                             external: true,
                         };
                     });
@@ -166,7 +168,8 @@ export const createDirectiveLookupPlugin = async ({ projectRootDir, files, confi
                 viteConfig.optimizeDeps.include ??= [];
                 for (const file of files) {
                     const actualFilePath = path.join(projectRootDir, file);
-                    verboseLog("Adding to optimizeDeps.entries: %s", actualFilePath);
+                    process.env.VERBOSE &&
+                        log("Adding to optimizeDeps.entries: %s", actualFilePath);
                     const entries = Array.isArray(viteConfig.optimizeDeps.entries)
                         ? viteConfig.optimizeDeps.entries
                         : [].concat(viteConfig.optimizeDeps.entries ?? []);
@@ -180,19 +183,17 @@ export const createDirectiveLookupPlugin = async ({ projectRootDir, files, confi
             }
         },
         resolveId(source) {
-            verboseLog("Resolving id=%s", source);
-            if (source === config.virtualModuleName ||
-                source === `/@id/${config.virtualModuleName}` ||
-                source === `/@id/${config.virtualModuleName}.js`) {
+            process.env.VERBOSE && log("Resolving id=%s", source);
+            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;
             }
-            verboseLog("No resolution for id=%s", source);
+            process.env.VERBOSE && log("No resolution for id=%s", source);
         },
         async load(id) {
-            verboseLog("Loading id=%s", id);
+            process.env.VERBOSE && log("Loading id=%s", id);
             if (id === config.virtualModuleName + ".js") {
                 log("Loading %s module with %d files", config.virtualModuleName, files.size);
                 const environment = this.environment?.name || "client";
@@ -218,13 +219,13 @@ export const ${config.exportName} = {
                 const code = s.toString();
                 const map = s.generateMap();
                 log("Generated virtual module code length: %d", code.length);
-                verboseLog("Generated virtual module code: %s", code);
+                process.env.VERBOSE && log("Generated virtual module code: %s", code);
                 return {
                     code,
                     map,
                 };
             }
-            verboseLog("No load handling for id=%s", id);
+            process.env.VERBOSE && log("No load handling for id=%s", id);
         },
     };
 };

package/dist/vite/directivesPlugin.mjs

@@ -5,7 +5,6 @@ import { transformClientComponents } from "./transformClientComponents.mjs";
 import { transformServerFunctions } from "./transformServerFunctions.mjs";
 import { normalizeModulePath } from "./normalizeModulePath.mjs";
 const log = debug("rwsdk:vite:rsc-directives-plugin");
-const verboseLog = debug("verbose:rwsdk:vite:rsc-directives-plugin");
 const getLoader = (filePath) => {
     const ext = path.extname(filePath).slice(1);
     switch (ext) {
@@ -76,7 +75,8 @@ export const directivesPlugin = ({ projectRootDir, clientFiles, serverFiles, })
             });
         },
         async transform(code, id) {
-            verboseLog("Transform called for id=%s, environment=%s", id, this.environment.name);
+            process.env.VERBOSE &&
+                log("Transform called for id=%s, environment=%s", id, this.environment.name);
             const normalizedId = normalizeModulePath(projectRootDir, id);
             const clientResult = await transformClientComponents(code, normalizedId, {
                 environmentName: this.environment.name,
@@ -98,7 +98,7 @@ export const directivesPlugin = ({ projectRootDir, clientFiles, serverFiles, })
                     map: serverResult.map,
                 };
             }
-            verboseLog("No transformation applied for id=%s", id);
+            process.env.VERBOSE && log("No transformation applied for id=%s", id);
         },
         configEnvironment(env, config) {
             log("Configuring environment: env=%s", env);
@@ -110,7 +110,8 @@ export const directivesPlugin = ({ projectRootDir, clientFiles, serverFiles, })
                 setup(build) {
                     log("Setting up esbuild plugin for environment: %s", env);
                     build.onLoad({ filter: /\.(js|ts|jsx|tsx|mts|mjs|cjs)$/ }, async (args) => {
-                        verboseLog("Esbuild onLoad called for environment=%s, path=%s", env, args.path);
+                        process.env.VERBOSE &&
+                            log("Esbuild onLoad called for environment=%s, path=%s", env, args.path);
                         const normalizedPath = normalizeModulePath(projectRootDir, args.path);
                         // context(justinvdm,2025-06-15): If we're in app code,
                         // we will be doing the transform work in the vite plugin hooks,
@@ -161,7 +162,8 @@ export const directivesPlugin = ({ projectRootDir, clientFiles, serverFiles, })
                             code = await fs.readFile(args.path, "utf-8");
                         }
                         catch {
-                            verboseLog("Failed to read file: %s, environment=%s", args.path, env);
+                            process.env.VERBOSE &&
+                                log("Failed to read file: %s, environment=%s", args.path, env);
                             return undefined;
                         }
                         const clientResult = await transformClientComponents(code, normalizedPath, {
@@ -172,7 +174,8 @@ export const directivesPlugin = ({ projectRootDir, clientFiles, serverFiles, })
                         });
                         if (clientResult) {
                             log("Esbuild client component transformation successful for environment=%s, path=%s", env, args.path);
-                            verboseLog("Esbuild client component transformation for environment=%s, path=%s, code: %j", env, args.path, clientResult.code);
+                            process.env.VERBOSE &&
+                                log("Esbuild client component transformation for environment=%s, path=%s, code: %j", env, args.path, clientResult.code);
                             return {
                                 contents: clientResult.code,
                                 loader: getLoader(args.path),
@@ -186,7 +189,8 @@ export const directivesPlugin = ({ projectRootDir, clientFiles, serverFiles, })
                                 loader: getLoader(args.path),
                             };
                         }
-                        verboseLog("Esbuild no transformation applied for environment=%s, path=%s", env, args.path);
+                        process.env.VERBOSE &&
+                            log("Esbuild no transformation applied for environment=%s, path=%s", env, args.path);
                     });
                 },
             });

package/dist/vite/findSpecifiers.mjs

@@ -52,7 +52,7 @@ export const EXPORT_PATTERNS = [
 export function findImportSpecifiers(id, code, ignoredImportPatterns, log) {
     const ext = path.extname(id).toLowerCase();
     const lang = ext === ".tsx" || ext === ".jsx" ? Lang.Tsx : SgLang.TypeScript;
-    const logger = log ?? (() => { });
+    const logger = process.env.VERBOSE ? (log ?? (() => { })) : () => { };
     const results = [];
     try {
         // sgParse and lang must be provided by the consumer
@@ -101,7 +101,7 @@ export function findImportSpecifiers(id, code, ignoredImportPatterns, log) {
 export function findExports(id, code, log) {
     const ext = path.extname(id).toLowerCase();
     const lang = ext === ".tsx" || ext === ".jsx" ? Lang.Tsx : SgLang.TypeScript;
-    const logger = log ?? (() => { });
+    const logger = process.env.VERBOSE ? (log ?? (() => { })) : () => { };
     const results = [];
     const seen = new Set(); // Track seen exports to avoid duplicates
     try {

package/dist/vite/findSsrSpecifiers.mjs

@@ -10,7 +10,7 @@ import path from "path";
 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 logger = process.env.VERBOSE ? (log ?? (() => { })) : () => { };
     const imports = [];
     const dynamicImports = [];
     try {
@@ -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/injectVitePreamblePlugin.d.mts

@@ -1,5 +1,4 @@
 import { type Plugin } from "vite";
-export declare const injectVitePreamble: ({ clientEntryPathnames, mode, }: {
+export declare const injectVitePreamble: ({ clientEntryPathnames, }: {
     clientEntryPathnames: string[];
-    mode: "development" | "production";
 }) => Plugin;

package/dist/vite/injectVitePreamblePlugin.mjs

@@ -1,5 +1,5 @@
 import MagicString from "magic-string";
-export const injectVitePreamble = ({ clientEntryPathnames, mode, }) => ({
+export const injectVitePreamble = ({ clientEntryPathnames, }) => ({
     name: "rwsdk:inject-vite-preamble",
     apply: "serve",
     transform(code, id) {
@@ -10,7 +10,7 @@ export const injectVitePreamble = ({ clientEntryPathnames, mode, }) => ({
             return;
         }
         // Only inject preamble in development mode
-        if (mode !== "development") {
+        if (process.env.NODE_ENV !== "development") {
             return;
         }
         const s = new MagicString(code);

package/dist/vite/invalidateModule.d.mts

@@ -1,2 +1,6 @@
-import type { ViteDevServer } from "vite";
-export declare const invalidateModule: (devServer: ViteDevServer, environment: string, id: string) => void;
+import type { EnvironmentModuleNode, ViteDevServer } from "vite";
+interface InvalidatableModuleOptions {
+    invalidateImportersRecursively?: boolean;
+}
+export declare const invalidateModule: (devServer: ViteDevServer, environment: string, target: string | EnvironmentModuleNode, options?: InvalidatableModuleOptions, seen?: Set<EnvironmentModuleNode>) => void;
+export {};

package/dist/vite/invalidateModule.mjs

@@ -1,14 +1,30 @@
 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);
+export const invalidateModule = (devServer, environment, target, options = {}, seen = new Set()) => {
+    let moduleNode;
+    if (typeof target === "string") {
+        const id = target;
+        const [rawId, _query] = id.split("?");
+        moduleNode =
+            devServer?.environments[environment]?.moduleGraph.idToModuleMap.get(rawId);
+    }
+    else {
+        moduleNode = target;
+    }
     if (moduleNode) {
-        devServer?.environments[environment]?.moduleGraph.invalidateModule(moduleNode);
+        if (seen.has(moduleNode)) {
+            return;
+        }
+        seen.add(moduleNode);
+        devServer.environments[environment]?.moduleGraph.invalidateModule(moduleNode, seen);
+        log("Invalidating module: id=%s, environment=%s", moduleNode.id, environment);
+        if (options.invalidateImportersRecursively) {
+            for (const importer of moduleNode.importers) {
+                invalidateModule(devServer, environment, importer, options, seen);
+            }
+        }
     }
     else {
-        verboseLog("Module not found: id=%s, environment=%s", id, environment);
+        log("Module not found: id=%s, environment=%s", typeof target === "string" ? target : target.id, environment);
     }
 };

package/dist/vite/isJsFile.d.mts

@@ -0,0 +1 @@
+export declare function isJsFile(filepath: string): boolean;

package/dist/vite/isJsFile.d.ts

@@ -0,0 +1 @@
+export declare function isJsFile(filepath: string): boolean;

package/dist/vite/isJsFile.js

@@ -0,0 +1,3 @@
+export function isJsFile(filepath) {
+    return /\.(m|c)?(j|t)s(x)?$/.test(filepath);
+}

package/dist/vite/isJsFile.mjs

@@ -0,0 +1,3 @@
+export function isJsFile(filepath) {
+    return /\.(m|c)?(j|t)s(x)?$/.test(filepath);
+}

package/dist/vite/miniflareHMRPlugin.d.mts

@@ -1,5 +1,7 @@
 import { Plugin } from "vite";
 export declare const miniflareHMRPlugin: (givenOptions: {
+    clientFiles: Set<string>;
+    serverFiles: Set<string>;
     rootDir: string;
     viteEnvironment: {
         name: string;

package/dist/vite/miniflareHMRPlugin.mjs

@@ -4,13 +4,23 @@ import { readFile } from "node:fs/promises";
 import debug from "debug";
 import { VIRTUAL_SSR_PREFIX } from "./ssrBridgePlugin.mjs";
 import { normalizeModulePath } from "./normalizeModulePath.mjs";
+import { hasDirective as sourceHasDirective } from "./hasDirective.mjs";
+import { isJsFile } from "./isJsFile.mjs";
+import { invalidateModule } from "./invalidateModule.mjs";
 import { getShortName } from "../lib/getShortName.mjs";
-import { pathExists } from "fs-extra";
-const verboseLog = debug("verbose:rwsdk:vite:hmr-plugin");
+const log = debug("rwsdk:vite:hmr-plugin");
+const hasDirective = async (filepath, directive) => {
+    if (!isJsFile(filepath)) {
+        return false;
+    }
+    const content = await readFile(filepath, "utf-8");
+    return sourceHasDirective(content, directive);
+};
 const hasEntryAsAncestor = (module, entryFile, seen = new Set()) => {
     // Prevent infinite recursion
-    if (seen.has(module))
+    if (seen.has(module)) {
         return false;
+    }
     seen.add(module);
     // Check direct importers
     for (const importer of module.importers) {
@@ -22,92 +32,81 @@ const hasEntryAsAncestor = (module, entryFile, seen = new Set()) => {
     }
     return false;
 };
-// Cache for "use client" status results
-const useClientCache = new Map();
-// Function to invalidate cache for a file
-const invalidateUseClientCache = (file) => {
-    useClientCache.delete(file);
-};
-const isUseClientModule = async (ctx, file, seen = new Set()) => {
-    // Prevent infinite recursion
-    if (seen.has(file))
-        return false;
-    seen.add(file);
-    try {
-        // Check cache first
-        if (useClientCache.has(file)) {
-            return useClientCache.get(file);
-        }
-        // Read and check the file
-        const content = (await pathExists(file))
-            ? await readFile(file, "utf-8")
-            : "";
-        const hasUseClient = content.includes("'use client'") || content.includes('"use client"');
-        if (hasUseClient) {
-            useClientCache.set(file, true);
-            return true;
-        }
-        // Get the module from the module graph to find importers
-        const module = ctx.server.moduleGraph.getModuleById(file);
-        if (!module) {
-            useClientCache.set(file, false);
-            return false;
-        }
-        // Check all importers recursively
-        for (const importer of module.importers) {
-            if (await isUseClientModule(ctx, importer.url, seen)) {
-                useClientCache.set(file, true);
-                return true;
-            }
-        }
-        useClientCache.set(file, false);
-        return false;
-    }
-    catch (error) {
-        useClientCache.set(file, false);
-        return false;
-    }
-};
 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;
+            const { clientFiles, serverFiles, viteEnvironment: { name: environment }, workerEntryPathname: entry, } = givenOptions;
+            if (process.env.VERBOSE) {
+                log(`Hot update: (env=${this.environment.name}) ${ctx.file}\nModule graph:\n\n${dumpFullModuleGraph(ctx.server, this.environment.name)}`);
+            }
+            if (this.environment.name === "ssr") {
+                log("SSR update, invalidating recursively", ctx.file);
+                invalidateModule(ctx.server, "ssr", ctx.file, {
+                    invalidateImportersRecursively: true,
+                });
+                invalidateModule(ctx.server, environment, VIRTUAL_SSR_PREFIX +
+                    normalizeModulePath(givenOptions.rootDir, ctx.file), { invalidateImportersRecursively: true });
+                return [];
+            }
             if (!["client", environment].includes(this.environment.name)) {
                 return [];
             }
+            const hasClientDirective = await hasDirective(ctx.file, "use client");
+            const hasServerDirective = !hasClientDirective && (await hasDirective(ctx.file, "use server"));
+            let clientDirectiveChanged = false;
+            let serverDirectiveChanged = false;
+            if (!clientFiles.has(ctx.file) && hasClientDirective) {
+                clientFiles.add(ctx.file);
+                clientDirectiveChanged = true;
+            }
+            else if (clientFiles.has(ctx.file) && !hasClientDirective) {
+                clientFiles.delete(ctx.file);
+                clientDirectiveChanged = true;
+            }
+            if (!serverFiles.has(ctx.file) && hasServerDirective) {
+                serverFiles.add(ctx.file);
+                serverDirectiveChanged = true;
+            }
+            else if (serverFiles.has(ctx.file) && !hasServerDirective) {
+                serverFiles.delete(ctx.file);
+                serverDirectiveChanged = true;
+            }
+            if (clientDirectiveChanged) {
+                ["client", "ssr", environment].forEach((environment) => {
+                    invalidateModule(ctx.server, environment, "virtual:use-client-lookup.js");
+                });
+                invalidateModule(ctx.server, environment, VIRTUAL_SSR_PREFIX + "/@id/virtual:use-client-lookup.js");
+            }
+            if (serverDirectiveChanged) {
+                ["client", "ssr", environment].forEach((environment) => {
+                    invalidateModule(ctx.server, environment, "virtual:use-server-lookup.js");
+                });
+                invalidateModule(ctx.server, environment, VIRTUAL_SSR_PREFIX + "/@id/virtual:use-server-lookup.js");
+            }
             // 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 [];
-            }
             // 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") {
-                const cssModules = [];
-                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);
-                        if (clientModules) {
-                            cssModules.push(...clientModules.values());
+                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);
+                            }
                         }
                     }
                 }
-                invalidateUseClientCache(ctx.file);
-                return (await isUseClientModule(ctx, ctx.file))
-                    ? [...ctx.modules, ...cssModules]
-                    : cssModules;
+                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
@@ -122,12 +121,12 @@ export const miniflareHMRPlugin = (givenOptions) => [
                     ?.values()
                     .next().value;
                 if (m) {
-                    ctx.server.environments.client.moduleGraph.invalidateModule(m, new Set(), ctx.timestamp, true);
+                    invalidateModule(ctx.server, environment, m);
                 }
                 const virtualSSRModule = ctx.server.environments[environment].moduleGraph.idToModuleMap.get(VIRTUAL_SSR_PREFIX +
                     normalizeModulePath(givenOptions.rootDir, ctx.file));
                 if (virtualSSRModule) {
-                    ctx.server.environments.worker.moduleGraph.invalidateModule(virtualSSRModule, new Set(), ctx.timestamp, true);
+                    invalidateModule(ctx.server, environment, virtualSSRModule);
                 }
                 ctx.server.environments.client.hot.send({
                     type: "custom",

package/dist/vite/mode.d.mts

@@ -0,0 +1,5 @@
+import { ConfigEnv } from "vite";
+type Mode = "development" | "production";
+export declare const resolveMode: (env: ConfigEnv) => Mode;
+export declare const ensureMode: () => Mode;
+export {};

package/dist/vite/mode.mjs

@@ -0,0 +1,25 @@
+import debug from "debug";
+const log = debug("rwsdk:vite:mode");
+const initialNodeEnv = process.env.NODE_ENV;
+let mode;
+export const resolveMode = (env) => {
+    if (mode) {
+        return mode;
+    }
+    if (initialNodeEnv) {
+        mode = initialNodeEnv === "development" ? "development" : "production";
+        log(`Resolved mode: %s (from initial NODE_ENV=%s)`, mode, initialNodeEnv);
+    }
+    else {
+        mode =
+            env.command === "serve" || env.isPreview ? "development" : "production";
+        log(`Resolved mode: %s (env.command=%s, env.isPreview=%s)`, mode, env.isPreview, env.command);
+    }
+    return mode;
+};
+export const ensureMode = () => {
+    if (mode === undefined) {
+        throw new Error("RedwoodSDK: mode is not resolved yet");
+    }
+    return mode;
+};

package/dist/vite/modePlugin.d.mts

@@ -0,0 +1,2 @@
+import { Plugin } from "vite";
+export declare function modePlugin(): Plugin;

package/dist/vite/modePlugin.mjs

@@ -0,0 +1,10 @@
+import { resolveMode } from "./mode.mjs";
+export function modePlugin() {
+    return {
+        name: "rwsdk:mode",
+        enforce: "pre",
+        config(_, env) {
+            resolveMode(env);
+        },
+    };
+}

package/dist/vite/reactConditionsResolverPlugin.mjs

@@ -3,7 +3,6 @@ import { ROOT_DIR } from "../lib/constants.mjs";
 import enhancedResolve from "enhanced-resolve";
 import { ensureAliasArray } from "./ensureAliasArray.mjs";
 const log = debug("rwsdk:vite:react-conditions-resolver-plugin");
-const verboseLog = debug("verbose:rwsdk:vite:react-conditions-resolver-plugin");
 export const ENV_REACT_IMPORTS = {
     worker: [
         "react",
@@ -47,18 +46,22 @@ export const ENV_IMPORT_MAPPINGS = Object.fromEntries(Object.keys(ENV_RESOLVERS)
     resolveEnvImportMappings(env),
 ]));
 function resolveEnvImportMappings(env) {
-    verboseLog("Resolving environment import mappings for env=%s", env);
+    process.env.VERBOSE &&
+        log("Resolving environment import mappings for env=%s", env);
     const mappings = new Map();
     const reactImports = ENV_REACT_IMPORTS[env];
     for (const importRequest of reactImports) {
-        verboseLog("Resolving import request=%s for env=%s", importRequest, env);
+        process.env.VERBOSE &&
+            log("Resolving import request=%s for env=%s", importRequest, env);
         let resolved = false;
         try {
             resolved = ENV_RESOLVERS[env](ROOT_DIR, importRequest);
-            verboseLog("Successfully resolved %s to %s for env=%s", importRequest, resolved, env);
+            process.env.VERBOSE &&
+                log("Successfully resolved %s to %s for env=%s", importRequest, resolved, env);
         }
         catch {
-            verboseLog("Failed to resolve %s for env=%s", importRequest, env);
+            process.env.VERBOSE &&
+                log("Failed to resolve %s for env=%s", importRequest, env);
         }
         if (resolved) {
             mappings.set(importRequest, resolved);
@@ -77,10 +80,12 @@ function createEsbuildResolverPlugin(envName) {
         name: `rwsdk:react-conditions-resolver-esbuild-${envName}`,
         setup(build) {
             build.onResolve({ filter: /.*/ }, (args) => {
-                verboseLog("ESBuild resolving %s for env=%s, args=%O", args.path, envName, args);
+                process.env.VERBOSE &&
+                    log("ESBuild resolving %s for env=%s, args=%O", args.path, envName, args);
                 const resolved = mappings.get(args.path);
                 if (resolved && args.importer !== "") {
-                    verboseLog("ESBuild resolving %s -> %s for env=%s", args.path, resolved, envName);
+                    process.env.VERBOSE &&
+                        log("ESBuild resolving %s -> %s for env=%s", args.path, resolved, envName);
                     if (args.path === "react-server-dom-webpack/client.edge") {
                         return;
                     }
@@ -89,7 +94,8 @@ function createEsbuildResolverPlugin(envName) {
                     };
                 }
                 else {
-                    verboseLog("ESBuild no resolution found for %s for env=%s", args.path, envName);
+                    process.env.VERBOSE &&
+                        log("ESBuild no resolution found for %s for env=%s", args.path, envName);
                 }
             });
         },
@@ -124,7 +130,7 @@ export const reactConditionsResolverPlugin = () => {
                         envConfig.optimizeDeps ??= {};
                         envConfig.optimizeDeps.esbuildOptions ??= {};
                         envConfig.optimizeDeps.esbuildOptions.define ??= {};
-                        envConfig.optimizeDeps.esbuildOptions.define["process.env.NODE_ENV"] = JSON.stringify(process.env.NODE_ENV ?? "production");
+                        envConfig.optimizeDeps.esbuildOptions.define["process.env.NODE_ENV"] = JSON.stringify(process.env.NODE_ENV);
                         envConfig.optimizeDeps.esbuildOptions.plugins ??= [];
                         envConfig.optimizeDeps.esbuildOptions.plugins.push(esbuildPlugin);
                         envConfig.optimizeDeps.include ??= [];
@@ -152,10 +158,12 @@ export const reactConditionsResolverPlugin = () => {
                 if (!envName) {
                     return;
                 }
-                verboseLog("Resolving id=%s, environment=%s, importer=%s", id, envName, importer);
+                process.env.VERBOSE &&
+                    log("Resolving id=%s, environment=%s, importer=%s", id, envName, importer);
                 const mappings = ENV_IMPORT_MAPPINGS[envName];
                 if (!mappings) {
-                    verboseLog("No mappings found for environment: %s", envName);
+                    process.env.VERBOSE &&
+                        log("No mappings found for environment: %s", envName);
                     return;
                 }
                 const resolved = mappings.get(id);
@@ -163,7 +171,8 @@ export const reactConditionsResolverPlugin = () => {
                     log("Resolved %s -> %s for env=%s", id, resolved, envName);
                     return resolved;
                 }
-                verboseLog("No resolution found for id=%s in env=%s", id, envName);
+                process.env.VERBOSE &&
+                    log("No resolution found for id=%s in env=%s", id, envName);
             },
         },
     ];

package/dist/vite/redwoodPlugin.d.mts

@@ -2,7 +2,6 @@ import { InlineConfig } from "vite";
 export type RedwoodPluginOptions = {
     silent?: boolean;
     rootDir?: string;
-    mode?: "development" | "production";
     includeCloudflarePlugin?: boolean;
     configPath?: string;
     entry?: {

package/dist/vite/redwoodPlugin.mjs

@@ -30,8 +30,6 @@ const determineWorkerEntryPathname = async (projectRootDir, workerConfigPath, op
 };
 export const redwoodPlugin = async (options = {}) => {
     const projectRootDir = process.cwd();
-    const mode = options.mode ??
-        (process.env.NODE_ENV === "development" ? "development" : "production");
     const workerConfigPath = options.configPath ?? (await findWranglerConfig(projectRootDir));
     const workerEntryPathname = await determineWorkerEntryPathname(projectRootDir, workerConfigPath, options);
     const clientEntryPathnames = (Array.isArray(options.entry?.client)
@@ -57,7 +55,6 @@ export const redwoodPlugin = async (options = {}) => {
     return [
         devServerTimingPlugin(),
         configPlugin({
-            mode,
             silent: options.silent ?? false,
             projectRootDir,
             clientEntryPathnames,
@@ -77,6 +74,8 @@ export const redwoodPlugin = async (options = {}) => {
             })
             : [],
         miniflareHMRPlugin({
+            clientFiles,
+            serverFiles,
             rootDir: projectRootDir,
             viteEnvironment: { name: "worker" },
             workerEntryPathname,
@@ -88,7 +87,7 @@ export const redwoodPlugin = async (options = {}) => {
             serverFiles,
         }),
         vitePreamblePlugin(),
-        injectVitePreamble({ clientEntryPathnames, mode }),
+        injectVitePreamble({ clientEntryPathnames }),
         useClientLookupPlugin({
             projectRootDir,
             clientFiles,

package/dist/vite/ssrBridgePlugin.mjs

@@ -2,7 +2,6 @@ import debug from "debug";
 import { SSR_BRIDGE_PATH } from "../lib/constants.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:";
 export const ssrBridgePlugin = ({ clientFiles, serverFiles, }) => {
     log("Initializing SSR bridge plugin with SSR_BRIDGE_PATH=%s", SSR_BRIDGE_PATH);
@@ -33,7 +32,8 @@ export const ssrBridgePlugin = ({ clientFiles, serverFiles, }) => {
                     setup(build) {
                         log("Setting up esbuild plugin to mark rwsdk/__ssr paths as external for worker");
                         build.onResolve({ filter: /.*$/ }, (args) => {
-                            verboseLog("Esbuild onResolve called for path=%s, args=%O", args.path, args);
+                            process.env.VERBOSE &&
+                                log("Esbuild onResolve called for path=%s, args=%O", args.path, args);
                             if (args.path === "rwsdk/__ssr_bridge") {
                                 log("Marking as external: %s", args.path);
                                 return {
@@ -48,7 +48,8 @@ export const ssrBridgePlugin = ({ clientFiles, serverFiles, }) => {
             }
         },
         async resolveId(id) {
-            verboseLog("Resolving id=%s, environment=%s, isDev=%s", id, this.environment?.name, isDev);
+            process.env.VERBOSE &&
+                log("Resolving id=%s, environment=%s, isDev=%s", id, this.environment?.name, isDev);
             if (isDev) {
                 // context(justinvdm, 27 May 2025): In dev, we need to dynamically load
                 // SSR modules, so we return the virtual id so that the dynamic loading
@@ -77,10 +78,11 @@ export const ssrBridgePlugin = ({ clientFiles, serverFiles, }) => {
                     return SSR_BRIDGE_PATH;
                 }
             }
-            verboseLog("No resolution for id=%s", id);
+            process.env.VERBOSE && log("No resolution for id=%s", id);
         },
         async load(id) {
-            verboseLog("Loading id=%s, isDev=%s, environment=%s", id, isDev, this.environment.name);
+            process.env.VERBOSE &&
+                log("Loading id=%s, isDev=%s, environment=%s", id, isDev, this.environment.name);
             if (id.startsWith(VIRTUAL_SSR_PREFIX) &&
                 this.environment.name === "worker") {
                 const realId = id.slice(VIRTUAL_SSR_PREFIX.length);
@@ -88,32 +90,42 @@ export const ssrBridgePlugin = ({ clientFiles, serverFiles, }) => {
                 if (isDev) {
                     log("Dev mode: fetching SSR module for realPath=%s", realId);
                     const result = await devServer?.environments.ssr.fetchModule(realId);
-                    verboseLog("Fetch module result: id=%s, result=%O", realId, result);
+                    process.env.VERBOSE &&
+                        log("Fetch module result: id=%s, result=%O", realId, result);
                     const code = "code" in result ? result.code : undefined;
                     log("Fetched SSR module code length: %d", code?.length || 0);
-                    const { imports, dynamicImports } = findSsrImportSpecifiers(realId, code || "", verboseLog);
-                    const allSpecifiers = [...new Set([...imports, ...dynamicImports])];
+                    const { imports, dynamicImports } = findSsrImportSpecifiers(realId, code || "", log);
+                    const allSpecifiers = [
+                        ...new Set([...imports, ...dynamicImports]),
+                    ].map((id) => id.startsWith("/@id/") ? id.slice("/@id/".length) : id);
                     const switchCases = allSpecifiers
-                        .map((specifier) => `    case "${specifier}": return import("${VIRTUAL_SSR_PREFIX}${specifier}");`)
+                        .map((specifier) => `    case "${specifier}": import("${VIRTUAL_SSR_PREFIX}${specifier}");`)
                         .join("\n");
                     const transformedCode = `
 await (async function(__vite_ssr_import__, __vite_ssr_dynamic_import__) {${code}})(
-  (id, ...args) => {ssrImport(id); return __vite_ssr_import__('/@id/${VIRTUAL_SSR_PREFIX}' + id, ...args);},
-  (id, ...args) => {ssrImport(id); return __vite_ssr_dynamic_import__('/@id/${VIRTUAL_SSR_PREFIX}' + id, ...args);}
+  __ssrImport.bind(null, false),
+  __ssrImport.bind(null, true)
 );
 
-function ssrImport(id) {
+function __ssrImport(isDynamic, id, ...args) {
+  id = id.startsWith('/@id/') ? id.slice('/@id/'.length) : id;
+
   switch (id) {
 ${switchCases}
   }
+
+  return isDynamic
+    ? __vite_ssr_dynamic_import__("/@id/${VIRTUAL_SSR_PREFIX}" + id, ...args)
+    : __vite_ssr_import__("/@id/${VIRTUAL_SSR_PREFIX}" + id, ...args);
 }
 `;
                     log("Transformed SSR module code length: %d", transformedCode.length);
-                    verboseLog("Transformed SSR module code for realId=%s: %s", realId, transformedCode);
+                    process.env.VERBOSE &&
+                        log("Transformed SSR module code for realId=%s: %s", realId, transformedCode);
                     return transformedCode;
                 }
             }
-            verboseLog("No load handling for id=%s", id);
+            process.env.VERBOSE && log("No load handling for id=%s", id);
         },
     };
     return ssrBridgePlugin;

package/dist/vite/transformClientComponents.mjs

@@ -4,21 +4,19 @@ import { hasDirective } from "./hasDirective.mjs";
 import { findExports } from "./findSpecifiers.mjs";
 const logVite = debug("rwsdk:vite:transform-client-components:vite");
 const logEsbuild = debug("rwsdk:vite:transform-client-components:esbuild");
-const verboseLogVite = debug("verbose:rwsdk:vite:transform-client-components:vite");
-const verboseLogEsbuild = debug("verbose:rwsdk:vite:transform-client-components:esbuild");
 export async function transformClientComponents(code, normalizedId, ctx) {
     const log = ctx.isEsbuild ? logEsbuild : logVite;
-    const verboseLog = ctx.isEsbuild ? verboseLogEsbuild : verboseLogVite;
     log("Called transformClientComponents for id: id=%s", normalizedId);
     if (!hasDirective(code, "use client")) {
         log("Skipping: no 'use client' directive in id=%s", normalizedId);
-        verboseLog(":VERBOSE: Returning code unchanged for id=%s:\n%s", normalizedId, code);
+        process.env.VERBOSE &&
+            log(":VERBOSE: Returning code unchanged for id=%s:\n%s", normalizedId, code);
         return;
     }
     log("Processing 'use client' module: id=%s", normalizedId);
     ctx.addClientModule?.(ctx.environmentName, normalizedId);
     // Parse exports using the findExports helper
-    const exportInfos = findExports(normalizedId, code, verboseLog);
+    const exportInfos = findExports(normalizedId, code, log);
     const processedExports = [];
     let defaultExportInfo;
     // Helper to get the computed local name (with alias suffix if present)
@@ -62,7 +60,8 @@ export async function transformClientComponents(code, normalizedId, ctx) {
             const start = match.index;
             const end = match.index + match[0].length;
             s.remove(start, end);
-            verboseLog("Removed 'use client' directive from normalizedId=%s", normalizedId);
+            process.env.VERBOSE &&
+                log("Removed 'use client' directive from normalizedId=%s", normalizedId);
             break; // Only remove the first one
         }
         const sourceMap = s.generateMap({
@@ -70,7 +69,8 @@ export async function transformClientComponents(code, normalizedId, ctx) {
             includeContent: true,
             hires: true,
         });
-        verboseLog(":VERBOSE: SSR transformed code for %s:\n%s", normalizedId, s.toString());
+        process.env.VERBOSE &&
+            log(":VERBOSE: SSR transformed code for %s:\n%s", normalizedId, s.toString());
         return {
             code: s.toString(),
             map: sourceMap,
@@ -107,7 +107,8 @@ export async function transformClientComponents(code, normalizedId, ctx) {
         hires: true,
     });
     const finalResult = s.toString();
-    verboseLog(":VERBOSE: Transformed code (env=%s, normalizedId=%s):\n%s", normalizedId, ctx.environmentName, finalResult);
+    process.env.VERBOSE &&
+        log(":VERBOSE: Transformed code (env=%s, normalizedId=%s):\n%s", normalizedId, ctx.environmentName, finalResult);
     return {
         code: finalResult,
         map: sourceMap,

package/dist/vite/transformServerFunctions.mjs

@@ -5,15 +5,14 @@ import { findExports } from "./findSpecifiers.mjs";
 import { parse as sgParse, Lang as SgLang, Lang } from "@ast-grep/napi";
 import path from "path";
 const log = debug("rwsdk:vite:transform-server-functions");
-const verboseLog = debug("verbose:rwsdk:vite:transform-server-functions");
 export const findExportedFunctions = (code, normalizedId) => {
     return findExportInfo(code, normalizedId).localFunctions;
 };
 export const findExportInfo = (code, normalizedId) => {
-    verboseLog("Finding exported functions in source file");
+    process.env.VERBOSE && log("Finding exported functions in source file");
     const localFunctions = new Set();
     const reExports = [];
-    const exportInfos = findExports(normalizedId || "file.ts", code, verboseLog);
+    const exportInfos = findExports(normalizedId || "file.ts", code, log);
     for (const exportInfo of exportInfos) {
         if (exportInfo.isReExport && exportInfo.moduleSpecifier) {
             // For re-exports, we need to determine the original name by parsing the code
@@ -29,11 +28,13 @@ export const findExportInfo = (code, normalizedId) => {
                 originalName: originalName,
                 moduleSpecifier: exportInfo.moduleSpecifier,
             });
-            verboseLog("Found re-exported function: %s (original: %s) from %s", exportInfo.name, originalName, exportInfo.moduleSpecifier);
+            process.env.VERBOSE &&
+                log("Found re-exported function: %s (original: %s) from %s", exportInfo.name, originalName, exportInfo.moduleSpecifier);
         }
         else {
             localFunctions.add(exportInfo.name);
-            verboseLog("Found exported function: %s", exportInfo.name);
+            process.env.VERBOSE &&
+                log("Found exported function: %s", exportInfo.name);
         }
     }
     log("Found %d local functions: %O", localFunctions.size, Array.from(localFunctions));
@@ -55,7 +56,7 @@ function findDefaultFunctionName(code, normalizedId) {
         }
     }
     catch (err) {
-        verboseLog("Error finding default function name: %O", err);
+        process.env.VERBOSE && log("Error finding default function name: %O", err);
     }
     return null;
 }
@@ -79,15 +80,17 @@ function hasDefaultExport(code, normalizedId) {
         }
     }
     catch (err) {
-        verboseLog("Error checking for default export: %O", err);
+        process.env.VERBOSE && log("Error checking for default export: %O", err);
     }
     return false;
 }
 export const transformServerFunctions = (code, normalizedId, environment, serverFiles, addServerModule) => {
-    verboseLog("Transform server functions called for normalizedId=%s, environment=%s", normalizedId, environment);
+    process.env.VERBOSE &&
+        log("Transform server functions called for normalizedId=%s, environment=%s", normalizedId, environment);
     if (!hasDirective(code, "use server")) {
         log("Skipping: no 'use server' directive in id=%s", normalizedId);
-        verboseLog(":VERBOSE: Returning code unchanged for id=%s:\n%s", normalizedId, code);
+        process.env.VERBOSE &&
+            log(":VERBOSE: Returning code unchanged for id=%s:\n%s", normalizedId, code);
         return;
     }
     log("Processing 'use server' module: normalizedId=%s, environment=%s", normalizedId, environment);
@@ -144,7 +147,8 @@ export const transformServerFunctions = (code, normalizedId, environment, server
             const start = match.index;
             const end = match.index + match[0].length;
             s.remove(start, end);
-            verboseLog("Removed 'use server' directive from normalizedId=%s", normalizedId);
+            process.env.VERBOSE &&
+                log("Removed 'use server' directive from normalizedId=%s", normalizedId);
             break; // Only remove the first one
         }
         // Add imports at the very beginning
@@ -239,7 +243,8 @@ export const transformServerFunctions = (code, normalizedId, environment, server
                 }
             }
             catch (err) {
-                verboseLog("Error processing default function: %O", err);
+                process.env.VERBOSE &&
+                    log("Error processing default function: %O", err);
             }
         }
         // Add registration calls at the end
@@ -286,5 +291,6 @@ export const transformServerFunctions = (code, normalizedId, environment, server
             }),
         };
     }
-    verboseLog("No transformation applied for environment=%s, normalizedId=%s", environment, normalizedId);
+    process.env.VERBOSE &&
+        log("No transformation applied for environment=%s, normalizedId=%s", environment, normalizedId);
 };

package/package.json

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