rwsdk 0.2.0 → 0.3.1

package/dist/vite/manifestPlugin.mjs

@@ -1,57 +1,40 @@
-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;
-export const manifestPlugin = ({ manifestPath, }) => {
+export const manifestPlugin = ({ projectRootDir, }) => {
     let isBuild = false;
-    let root;
     return {
-        name: "rwsdk:manifest",
+        name: "rwsdk:vite:manifest-plugin",
+        enforce: "pre",
         configResolved(config) {
-            log("Config resolved, command=%s", config.command);
             isBuild = config.command === "build";
-            root = config.root;
         },
         resolveId(id) {
+            // Skip during directive scanning to avoid performance issues
+            if (process.env.RWSDK_DIRECTIVE_SCAN_ACTIVE) {
+                return;
+            }
             if (id === virtualModuleId) {
-                process.env.VERBOSE && log("Resolving virtual module id=%s", id);
                 return resolvedVirtualModuleId;
             }
         },
         async load(id) {
+            // Skip during directive scanning to avoid performance issues
+            if (process.env.RWSDK_DIRECTIVE_SCAN_ACTIVE) {
+                return;
+            }
             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;
-                    }
+                if (isBuild) {
+                    // context(justinvdm, 28 Aug 2025): During the build, we don't have
+                    // the manifest yet. We insert a placeholder that the linker plugin
+                    // will replace in the final phase.
+                    log("Returning manifest placeholder for build");
+                    return `export default "__RWSDK_MANIFEST_PLACEHOLDER__"`;
                 }
-                return `export default ${JSON.stringify(normalizedManifest)}`;
+                // In dev, we can return an empty object.
+                log("Not a build, returning empty manifest");
+                return `export default {}`;
             }
         },
         configEnvironment(name, config) {

package/dist/vite/moveStaticAssetsPlugin.mjs

@@ -3,7 +3,8 @@ export const moveStaticAssetsPlugin = ({ rootDir, }) => ({
     name: "rwsdk:move-static-assets",
     apply: "build",
     async closeBundle() {
-        if (this.environment.name === "worker") {
+        if (this.environment.name === "worker" &&
+            process.env.RWSDK_BUILD_PASS === "linker") {
             await $sh({
                 cwd: rootDir,
             }) `mv dist/worker/assets/*.css dist/client/assets/ || true`;

package/dist/vite/prismaPlugin.mjs

@@ -17,7 +17,7 @@ export const prismaPlugin = async ({ projectRootDir, }) => {
     return {
         name: "rwsdk:prisma",
         configEnvironment(name, config) {
-            if (name !== "worker") {
+            if (name !== "worker" || !process.env.VITE_IS_DEV_SERVER) {
                 return;
             }
             const wasmPath = resolve(projectRootDir, "node_modules/.prisma/client/wasm.js");

package/dist/vite/reactConditionsResolverPlugin.mjs

@@ -79,10 +79,12 @@ function resolveEnvImportMappings(env, projectRootDir) {
         const resolved = resolveReactImport(importRequest, env, projectRootDir, true);
         if (resolved) {
             mappings.set(importRequest, resolved);
-            log("Added mapping for %s -> %s in env=%s", importRequest, resolved, env);
+            process.env.VERBOSE &&
+                log("Added mapping for %s -> %s in env=%s", importRequest, resolved, env);
         }
     }
-    log("Environment import mappings complete for env=%s: %d mappings", env, mappings.size);
+    process.env.VERBOSE &&
+        log("Environment import mappings complete for env=%s: %d mappings", env, mappings.size);
     return mappings;
 }
 export const reactConditionsResolverPlugin = ({ projectRootDir, }) => {
@@ -92,6 +94,9 @@ export const reactConditionsResolverPlugin = ({ projectRootDir, }) => {
         env,
         resolveEnvImportMappings(env, projectRootDir),
     ]));
+    // Log a clean summary instead of all the individual mappings
+    const totalMappings = Object.values(ENV_IMPORT_MAPPINGS).reduce((sum, mappings) => sum + mappings.size, 0);
+    log("React conditions resolver configured with %d total mappings across %d environments", totalMappings, Object.keys(ENV_IMPORT_MAPPINGS).length);
     function createEsbuildResolverPlugin(envName, mappings) {
         if (!mappings) {
             return null;
@@ -100,15 +105,11 @@ export const reactConditionsResolverPlugin = ({ projectRootDir, }) => {
             name: `rwsdk:react-conditions-resolver-esbuild-${envName}`,
             setup(build) {
                 build.onResolve({ filter: /.*/ }, (args) => {
-                    process.env.VERBOSE &&
-                        log("ESBuild resolving %s for env=%s, args=%O", args.path, envName, args);
                     let resolved = mappings.get(args.path);
                     if (!resolved) {
                         resolved = resolveReactImport(args.path, envName, projectRootDir);
                     }
                     if (resolved && args.importer !== "") {
-                        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;
                         }
@@ -116,10 +117,6 @@ export const reactConditionsResolverPlugin = ({ projectRootDir, }) => {
                             path: resolved,
                         };
                     }
-                    else {
-                        process.env.VERBOSE &&
-                            log("ESBuild no resolution found for %s for env=%s", args.path, envName);
-                    }
                 });
             },
         };
@@ -161,7 +158,8 @@ export const reactConditionsResolverPlugin = ({ projectRootDir, }) => {
                     for (const [find, replacement] of mappings) {
                         const findRegex = new RegExp(`^${find.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&")}$`);
                         aliases.push({ find: findRegex, replacement });
-                        log("Added alias for env=%s: %s -> %s", envName, find, replacement);
+                        process.env.VERBOSE &&
+                            log("Added alias for env=%s: %s -> %s", envName, find, replacement);
                     }
                     log("Environment %s configured with %d aliases and %d optimizeDeps includes", envName, mappings.size, reactImports.length);
                 }
@@ -171,6 +169,10 @@ export const reactConditionsResolverPlugin = ({ projectRootDir, }) => {
             name: "rwsdk:react-conditions-resolver:resolveId",
             enforce: "pre",
             async resolveId(id, importer) {
+                // Skip during directive scanning to avoid performance issues
+                if (process.env.RWSDK_DIRECTIVE_SCAN_ACTIVE) {
+                    return;
+                }
                 if (!isBuild) {
                     return;
                 }
@@ -178,8 +180,6 @@ export const reactConditionsResolverPlugin = ({ projectRootDir, }) => {
                 if (!envName) {
                     return;
                 }
-                process.env.VERBOSE &&
-                    log("Resolving id=%s, environment=%s, importer=%s", id, envName, importer);
                 const mappings = ENV_IMPORT_MAPPINGS[envName];
                 if (!mappings) {
                     process.env.VERBOSE &&
@@ -191,11 +191,10 @@ export const reactConditionsResolverPlugin = ({ projectRootDir, }) => {
                     resolved = resolveReactImport(id, envName, projectRootDir);
                 }
                 if (resolved) {
-                    log("Resolved %s -> %s for env=%s", id, resolved, envName);
+                    process.env.VERBOSE &&
+                        log("Resolved %s -> %s for env=%s", id, resolved, envName);
                     return resolved;
                 }
-                process.env.VERBOSE &&
-                    log("No resolution found for id=%s in env=%s", id, envName);
             },
         },
     ];

package/dist/vite/redwoodPlugin.d.mts

@@ -6,7 +6,6 @@ export type RedwoodPluginOptions = {
     includeReactPlugin?: boolean;
     configPath?: string;
     entry?: {
-        client?: string | string[];
         worker?: string;
     };
 };

package/dist/vite/redwoodPlugin.mjs

@@ -24,6 +24,9 @@ import { ssrBridgePlugin } from "./ssrBridgePlugin.mjs";
 import { hasPkgScript } from "../lib/hasPkgScript.mjs";
 import { devServerTimingPlugin } from "./devServerTimingPlugin.mjs";
 import { manifestPlugin } from "./manifestPlugin.mjs";
+import { linkerPlugin } from "./linkerPlugin.mjs";
+import { directiveModulesDevPlugin } from "./directiveModulesDevPlugin.mjs";
+import { directivesFilteringPlugin } from "./directivesFilteringPlugin.mjs";
 const determineWorkerEntryPathname = async (projectRootDir, workerConfigPath, options) => {
     if (options.entry?.worker) {
         return resolve(projectRootDir, options.entry.worker);
@@ -31,6 +34,9 @@ const determineWorkerEntryPathname = async (projectRootDir, workerConfigPath, op
     const workerConfig = unstable_readConfig({ config: workerConfigPath });
     return resolve(projectRootDir, workerConfig.main ?? "src/worker.tsx");
 };
+const clientFiles = new Set();
+const serverFiles = new Set();
+const clientEntryPoints = new Set();
 export const redwoodPlugin = async (options = {}) => {
     const projectRootDir = process.cwd();
     const workerConfigPath = options.configPath ??
@@ -38,11 +44,6 @@ export const redwoodPlugin = async (options = {}) => {
             ? resolve(projectRootDir, process.env.RWSDK_WRANGLER_CONFIG)
             : await findWranglerConfig(projectRootDir));
     const workerEntryPathname = await determineWorkerEntryPathname(projectRootDir, workerConfigPath, options);
-    const clientEntryPathnames = (Array.isArray(options.entry?.client)
-        ? options.entry.client
-        : [options.entry?.client ?? "src/client.tsx"]).map((entry) => resolve(projectRootDir, entry));
-    const clientFiles = new Set();
-    const serverFiles = new Set();
     const shouldIncludeCloudflarePlugin = options.includeCloudflarePlugin ??
         !(await hasOwnCloudflareVitePlugin({ rootProjectDir: projectRootDir }));
     const shouldIncludeReactPlugin = options.includeReactPlugin ??
@@ -63,11 +64,18 @@ export const redwoodPlugin = async (options = {}) => {
     return [
         devServerTimingPlugin(),
         devServerConstantPlugin(),
+        directiveModulesDevPlugin({
+            clientFiles,
+            serverFiles,
+            projectRootDir,
+        }),
         configPlugin({
             silent: options.silent ?? false,
             projectRootDir,
-            clientEntryPathnames,
             workerEntryPathname,
+            clientFiles,
+            serverFiles,
+            clientEntryPoints,
         }),
         ssrBridgePlugin({
             clientFiles,
@@ -96,7 +104,10 @@ export const redwoodPlugin = async (options = {}) => {
             serverFiles,
         }),
         vitePreamblePlugin(),
-        injectVitePreamble({ clientEntryPathnames }),
+        injectVitePreamble({
+            clientEntryPoints,
+            projectRootDir,
+        }),
         useClientLookupPlugin({
             projectRootDir,
             clientFiles,
@@ -106,12 +117,19 @@ export const redwoodPlugin = async (options = {}) => {
             serverFiles,
         }),
         transformJsxScriptTagsPlugin({
-            manifestPath: resolve(projectRootDir, "dist", "client", ".vite", "manifest.json"),
+            clientEntryPoints,
+            projectRootDir,
         }),
         manifestPlugin({
-            manifestPath: resolve(projectRootDir, "dist", "client", ".vite", "manifest.json"),
+            projectRootDir,
         }),
         moveStaticAssetsPlugin({ rootDir: projectRootDir }),
         prismaPlugin({ projectRootDir }),
+        linkerPlugin({ projectRootDir }),
+        directivesFilteringPlugin({
+            clientFiles,
+            serverFiles,
+            projectRootDir,
+        }),
     ];
 };

package/dist/vite/runDirectivesScan.d.mts

@@ -0,0 +1,7 @@
+import { Environment, ResolvedConfig } from "vite";
+export declare const runDirectivesScan: ({ rootConfig, environment, clientFiles, serverFiles, }: {
+    rootConfig: ResolvedConfig;
+    environment: Environment;
+    clientFiles: Set<string>;
+    serverFiles: Set<string>;
+}) => Promise<void>;

package/dist/vite/runDirectivesScan.mjs

@@ -0,0 +1,156 @@
+import fsp from "node:fs/promises";
+import { hasDirective } from "./hasDirective.mjs";
+import path from "node:path";
+import debug from "debug";
+import { getViteEsbuild } from "./getViteEsbuild.mjs";
+import { normalizeModulePath } from "../lib/normalizeModulePath.mjs";
+import { externalModules } from "./constants.mjs";
+import { createViteAwareResolver } from "./createViteAwareResolver.mjs";
+const log = debug("rwsdk:vite:run-directives-scan");
+// Copied from Vite's source code.
+// https://github.com/vitejs/vite/blob/main/packages/vite/src/shared/utils.ts
+const isObject = (value) => Object.prototype.toString.call(value) === "[object Object]";
+// Copied from Vite's source code.
+// https://github.com/vitejs/vite/blob/main/packages/vite/src/node/utils.ts
+const externalRE = /^(https?:)?\/\//;
+const isExternalUrl = (url) => externalRE.test(url);
+export const runDirectivesScan = async ({ rootConfig, environment, clientFiles, serverFiles, }) => {
+    console.log("\n🔍 Scanning for 'use client' and 'use server' directives...");
+    // Set environment variable to indicate scanning is in progress
+    process.env.RWSDK_DIRECTIVE_SCAN_ACTIVE = "true";
+    try {
+        const esbuild = await getViteEsbuild(rootConfig.root);
+        const input = environment.config.build.rollupOptions?.input;
+        let entries;
+        if (Array.isArray(input)) {
+            entries = input;
+        }
+        else if (typeof input === "string") {
+            entries = [input];
+        }
+        else if (isObject(input)) {
+            entries = Object.values(input);
+        }
+        else {
+            entries = [];
+        }
+        if (entries.length === 0) {
+            log("No entries found for directives scan in environment '%s', skipping.", environment.name);
+            return;
+        }
+        const absoluteEntries = entries.map((entry) => path.resolve(rootConfig.root, entry));
+        log("Starting directives scan for environment '%s' with entries:", environment.name, absoluteEntries);
+        // Use enhanced-resolve with Vite plugin integration for full compatibility
+        const resolver = createViteAwareResolver(rootConfig, environment.name, environment);
+        const resolveId = async (id, importer) => {
+            return new Promise((resolve) => {
+                resolver({}, importer || rootConfig.root, id, {}, (err, result) => {
+                    if (!err && result) {
+                        resolve({ id: result });
+                    }
+                    else {
+                        if (err) {
+                            // Handle specific enhanced-resolve errors gracefully
+                            const errorMessage = err.message || String(err);
+                            if (errorMessage.includes("Package path . is not exported")) {
+                                log("Package exports error for %s, marking as external", id);
+                            }
+                            else {
+                                log("Resolution failed for %s: %s", id, errorMessage);
+                            }
+                        }
+                        resolve(null);
+                    }
+                });
+            });
+        };
+        const esbuildScanPlugin = {
+            name: "rwsdk:esbuild-scan-plugin",
+            setup(build) {
+                // Match Vite's behavior by externalizing assets and special queries.
+                // This prevents esbuild from trying to bundle them, which would fail.
+                const scriptFilter = /\.(c|m)?[jt]sx?$/;
+                const specialQueryFilter = /[?&](?:url|raw|worker|sharedworker|inline)\b/;
+                // This regex is used to identify if a path has any file extension.
+                const hasExtensionRegex = /\.[^/]+$/;
+                build.onResolve({ filter: specialQueryFilter }, (args) => {
+                    log("Externalizing special query:", args.path);
+                    return { external: true };
+                });
+                build.onResolve({ filter: /.*/, namespace: "file" }, (args) => {
+                    // Externalize if the path has an extension AND that extension is not a
+                    // script extension. Extensionless paths are assumed to be scripts and
+                    // are allowed to pass through for resolution.
+                    if (hasExtensionRegex.test(args.path) &&
+                        !scriptFilter.test(args.path)) {
+                        log("Externalizing non-script import:", args.path);
+                        return { external: true };
+                    }
+                });
+                build.onResolve({ filter: /.*/ }, async (args) => {
+                    if (externalModules.includes(args.path)) {
+                        return { external: true };
+                    }
+                    log("onResolve called for:", args.path, "from:", args.importer);
+                    const resolved = await resolveId(args.path, args.importer);
+                    log("Resolution result:", resolved);
+                    const resolvedPath = resolved?.id;
+                    if (resolvedPath && path.isAbsolute(resolvedPath)) {
+                        // Normalize the path for esbuild compatibility
+                        const normalizedPath = normalizeModulePath(resolvedPath, rootConfig.root, { absolute: true });
+                        log("Normalized path:", normalizedPath);
+                        return { path: normalizedPath };
+                    }
+                    log("Marking as external:", args.path, "resolved to:", resolvedPath);
+                    return { external: true };
+                });
+                build.onLoad({ filter: /\.(m|c)?[jt]sx?$/ }, async (args) => {
+                    log("onLoad called for:", args.path);
+                    if (!args.path.startsWith("/") ||
+                        args.path.includes("virtual:") ||
+                        isExternalUrl(args.path)) {
+                        log("Skipping file due to filter:", args.path, {
+                            startsWithSlash: args.path.startsWith("/"),
+                            hasVirtual: args.path.includes("virtual:"),
+                            isExternal: isExternalUrl(args.path),
+                        });
+                        return null;
+                    }
+                    try {
+                        const contents = await fsp.readFile(args.path, "utf-8");
+                        if (hasDirective(contents, "use client")) {
+                            log("Discovered 'use client' in:", args.path);
+                            clientFiles.add(normalizeModulePath(args.path, rootConfig.root));
+                        }
+                        if (hasDirective(contents, "use server")) {
+                            log("Discovered 'use server' in:", args.path);
+                            serverFiles.add(normalizeModulePath(args.path, rootConfig.root));
+                        }
+                        return { contents, loader: "default" };
+                    }
+                    catch (e) {
+                        log("Could not read file during scan, skipping:", args.path, e);
+                        return null;
+                    }
+                });
+            },
+        };
+        await esbuild.build({
+            entryPoints: absoluteEntries,
+            bundle: true,
+            write: false,
+            platform: "node",
+            format: "esm",
+            logLevel: "silent",
+            plugins: [esbuildScanPlugin],
+        });
+    }
+    catch (e) {
+        throw new Error(`RWSDK directive scan failed:\n${e.stack}`);
+    }
+    finally {
+        // Always clear the scanning flag when done
+        delete process.env.RWSDK_DIRECTIVE_SCAN_ACTIVE;
+        console.log("✅ Scan complete.");
+    }
+};

package/dist/vite/ssrBridgePlugin.mjs

@@ -1,11 +1,10 @@
 import debug from "debug";
-import { SSR_BRIDGE_PATH } from "../lib/constants.mjs";
 import { findSsrImportCallSites } from "./findSsrSpecifiers.mjs";
+import { INTERMEDIATE_SSR_BRIDGE_PATH } from "../lib/constants.mjs";
 import MagicString from "magic-string";
 const log = debug("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);
     let devServer;
     let isDev = false;
     const ssrBridgePlugin = {
@@ -49,8 +48,10 @@ export const ssrBridgePlugin = ({ clientFiles, serverFiles, }) => {
             }
         },
         async resolveId(id) {
-            process.env.VERBOSE &&
-                log("Resolving id=%s, environment=%s, isDev=%s", id, this.environment?.name, isDev);
+            // Skip during directive scanning to avoid performance issues
+            if (process.env.RWSDK_DIRECTIVE_SCAN_ACTIVE) {
+                return;
+            }
             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
@@ -75,20 +76,27 @@ export const ssrBridgePlugin = ({ clientFiles, serverFiles, }) => {
                 }
             }
             else {
-                // context(justinvdm, 27 May 2025): In builds, since all SSR import chains
-                // originate at SSR bridge module, we return the path to the already built
-                // SSR bridge bundle - SSR env builds it, worker build tries to resolve it
-                // here and uses it
+                // In build mode, the behavior depends on the build pass
                 if (id === "rwsdk/__ssr_bridge" && this.environment.name === "worker") {
-                    log("Bridge module case (build): id=%s matches rwsdk/__ssr_bridge in worker environment, returning SSR_BRIDGE_PATH=%s", id, SSR_BRIDGE_PATH);
-                    return SSR_BRIDGE_PATH;
+                    if (process.env.RWSDK_BUILD_PASS === "worker") {
+                        // First pass: resolve to a temporary, external path
+                        log("Bridge module case (build-worker pass): resolving to external path");
+                        return { id: INTERMEDIATE_SSR_BRIDGE_PATH, external: true };
+                    }
+                    else if (process.env.RWSDK_BUILD_PASS === "linker") {
+                        // Second pass (linker): resolve to the real intermediate build
+                        // artifact so it can be bundled in.
+                        log("Bridge module case (build-linker pass): resolving to bundleable path");
+                        return { id: INTERMEDIATE_SSR_BRIDGE_PATH, external: false };
+                    }
                 }
             }
-            process.env.VERBOSE && log("No resolution for id=%s", id);
         },
         async load(id) {
-            process.env.VERBOSE &&
-                log("Loading id=%s, isDev=%s, environment=%s", id, isDev, this.environment.name);
+            // Skip during directive scanning to avoid performance issues
+            if (process.env.RWSDK_DIRECTIVE_SCAN_ACTIVE) {
+                return;
+            }
             if (id.startsWith(VIRTUAL_SSR_PREFIX) &&
                 this.environment.name === "worker") {
                 const realId = id.slice(VIRTUAL_SSR_PREFIX.length);
@@ -132,7 +140,6 @@ export const ssrBridgePlugin = ({ clientFiles, serverFiles, }) => {
                     return out;
                 }
             }
-            process.env.VERBOSE && log("No load handling for id=%s", id);
         },
     };
     return ssrBridgePlugin;

package/dist/vite/transformClientComponents.d.mts

@@ -2,7 +2,6 @@ interface TransformContext {
     environmentName: string;
     clientFiles?: Set<string>;
     isEsbuild?: boolean;
-    addClientModule?: (environment: string, id: string) => void;
 }
 interface TransformResult {
     code: string;

package/dist/vite/transformClientComponents.mjs

@@ -5,16 +5,10 @@ import { findExports } from "./findSpecifiers.mjs";
 const logVite = debug("rwsdk:vite:transform-client-components:vite");
 const logEsbuild = debug("rwsdk:vite:transform-client-components:esbuild");
 export async function transformClientComponents(code, normalizedId, ctx) {
-    const log = ctx.isEsbuild ? logEsbuild : logVite;
-    log("Called transformClientComponents for id: id=%s", normalizedId);
     if (!hasDirective(code, "use client")) {
-        log("Skipping: no 'use client' directive in id=%s", normalizedId);
-        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);
+    const log = ctx.isEsbuild ? logEsbuild : logVite;
     // Parse exports using the findExports helper
     const exportInfos = findExports(normalizedId, code, log);
     const processedExports = [];
@@ -85,7 +79,6 @@ export async function transformClientComponents(code, normalizedId, ctx) {
     const computedLocalNames = new Map(processedExports.map((info) => [getComputedLocalName(info), info]));
     // Add registerClientReference assignments for unique names
     for (const [computedLocalName, correspondingInfo] of computedLocalNames) {
-        log(":isEsbuild=%s: Registering client reference for named export: %s as %s", !!ctx.isEsbuild, correspondingInfo.local, correspondingInfo.exported);
         s.append(`const ${computedLocalName} = registerClientReference("${normalizedId}", "${correspondingInfo.exported}");\n`);
     }
     // Add grouped export statement for named exports (preserving order and alias)
@@ -93,7 +86,6 @@ export async function transformClientComponents(code, normalizedId, ctx) {
         const exportNames = Array.from(computedLocalNames.entries()).map(([computedLocalName, correspondingInfo]) => correspondingInfo.local === correspondingInfo.exported
             ? computedLocalName
             : `${computedLocalName} as ${correspondingInfo.exported}`);
-        log(":isEsbuild=%s: Exporting named exports: %O", !!ctx.isEsbuild, exportNames);
         s.append(`export { ${exportNames.join(", ")} };\n`);
     }
     // Add default export if present

package/dist/vite/transformJsxScriptTagsPlugin.d.mts

@@ -1,8 +1,9 @@
 import { type Plugin } from "vite";
-export declare function transformJsxScriptTagsCode(code: string, manifest?: Record<string, any>): Promise<{
+export declare function transformJsxScriptTagsCode(code: string, clientEntryPoints: Set<string>, manifest: Record<string, any> | undefined, projectRootDir: string): Promise<{
     code: string;
     map: null;
 } | undefined>;
-export declare const transformJsxScriptTagsPlugin: ({ manifestPath, }: {
-    manifestPath: string;
+export declare const transformJsxScriptTagsPlugin: ({ clientEntryPoints, projectRootDir, }: {
+    clientEntryPoints: Set<string>;
+    projectRootDir: string;
 }) => Plugin;