rwsdk 0.1.0-alpha.8 → 0.1.0

package/dist/vite/miniflareHMRPlugin.mjs

@@ -0,0 +1,133 @@
+import { resolve } from "node:path";
+import colors from "picocolors";
+import { readFile } from "node:fs/promises";
+import { getShortName } from "../lib/getShortName.mjs";
+import { pathExists } from "fs-extra";
+const hasEntryAsAncestor = (module, entryFile, seen = new Set()) => {
+    // Prevent infinite recursion
+    if (seen.has(module))
+        return false;
+    seen.add(module);
+    // Check direct importers
+    for (const importer of module.importers) {
+        if (importer.file === entryFile)
+            return true;
+        // Recursively check importers
+        if (hasEntryAsAncestor(importer, entryFile, seen))
+            return true;
+    }
+    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) {
+            const environment = givenOptions.viteEnvironment.name;
+            const entry = givenOptions.workerEntryPathname;
+            if (!["client", environment].includes(this.environment.name)) {
+                return;
+            }
+            // 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());
+                        }
+                    }
+                }
+                invalidateUseClientCache(ctx.file);
+                return (await isUseClientModule(ctx, ctx.file))
+                    ? [...ctx.modules, ...cssModules]
+                    : cssModules;
+            }
+            // 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
+            if (isWorkerUpdate && this.environment.name === environment) {
+                const shortName = getShortName(ctx.file, ctx.server.config.root);
+                this.environment.logger.info(`${colors.green(`worker update`)} ${colors.dim(shortName)}`, {
+                    clear: true,
+                    timestamp: true,
+                });
+                const m = ctx.server.environments.client.moduleGraph
+                    .getModulesByFile(resolve(givenOptions.rootDir, "src", "app", "style.css"))
+                    ?.values()
+                    .next().value;
+                if (m) {
+                    ctx.server.environments.client.moduleGraph.invalidateModule(m, new Set(), ctx.timestamp, true);
+                }
+                ctx.server.environments.client.hot.send({
+                    type: "custom",
+                    event: "rsc:update",
+                    data: {
+                        file: ctx.file,
+                    },
+                });
+                return [];
+            }
+        },
+    },
+];

package/dist/vite/normalizeModulePath.mjs

@@ -1,2 +1,13 @@
 import path from "node:path";
-export const normalizeModulePath = (projectRootDir, modulePath) => "/" + path.relative(projectRootDir, modulePath);
+export const normalizeModulePath = (projectRootDir, modulePath) => {
+    // /Users/path/to/project/src/foo/bar.ts -> /src/foo/bar.ts
+    if (modulePath.startsWith(projectRootDir)) {
+        return "/" + path.relative(projectRootDir, modulePath);
+    }
+    // /src/foo/bar.ts -> /src/foo/bar.ts
+    if (modulePath.startsWith("/")) {
+        return modulePath;
+    }
+    // src/foo/bar.ts -> /src/foo/bar.ts
+    return "/" + modulePath;
+};

package/dist/vite/redwoodPlugin.d.mts

@@ -3,6 +3,7 @@ export type RedwoodPluginOptions = {
     silent?: boolean;
     rootDir?: string;
     mode?: "development" | "production";
+    includeCloudflarePlugin?: boolean;
     configPath?: string;
     entry?: {
         client?: string;

package/dist/vite/redwoodPlugin.mjs

@@ -1,11 +1,13 @@
 import { resolve } from "node:path";
+import { cloudflare } from "@cloudflare/vite-plugin";
+import { hasOwnCloudflareVitePlugin } from "./hasOwnCloudflareVitePlugin.mjs";
 import reactPlugin from "@vitejs/plugin-react";
 import tsconfigPaths from "vite-tsconfig-paths";
 import { transformJsxScriptTagsPlugin } from "./transformJsxScriptTagsPlugin.mjs";
 import { directivesPlugin } from "./directivesPlugin.mjs";
 import { useClientLookupPlugin } from "./useClientLookupPlugin.mjs";
 import { useServerLookupPlugin } from "./useServerLookupPlugin.mjs";
-import { miniflarePlugin } from "./miniflarePlugin.mjs";
+import { miniflareHMRPlugin } from "./miniflareHMRPlugin.mjs";
 import { moveStaticAssetsPlugin } from "./moveStaticAssetsPlugin.mjs";
 import { configPlugin } from "./configPlugin.mjs";
 import { $ } from "../lib/$.mjs";
@@ -17,6 +19,7 @@ import { vitePreamblePlugin } from "./vitePreamblePlugin.mjs";
 import { prismaPlugin } from "./prismaPlugin.mjs";
 import { ssrBridgePlugin } from "./ssrBridgePlugin.mjs";
 import { hasPkgScript } from "../lib/hasPkgScript.mjs";
+import { devServerTimingPlugin } from "./devServerTimingPlugin.mjs";
 export const redwoodPlugin = async (options = {}) => {
     const projectRootDir = process.cwd();
     const mode = options.mode ??
@@ -25,6 +28,8 @@ export const redwoodPlugin = async (options = {}) => {
     const workerEntryPathname = resolve(projectRootDir, options?.entry?.worker ?? "src/worker.tsx");
     const clientFiles = new Set();
     const serverFiles = new Set();
+    const shouldIncludeCloudflarePlugin = options.includeCloudflarePlugin ??
+        !(await hasOwnCloudflareVitePlugin({ rootProjectDir: projectRootDir }));
     // context(justinvdm, 31 Mar 2025): We assume that if there is no .wrangler directory,
     // then this is fresh install, and we run `npm run dev:init` here.
     if (process.env.RWSDK_WORKER_RUN !== "1" &&
@@ -39,6 +44,7 @@ export const redwoodPlugin = async (options = {}) => {
         }) `npm run dev:init`;
     }
     return [
+        devServerTimingPlugin(),
         configPlugin({
             mode,
             silent: options.silent ?? false,
@@ -46,14 +52,23 @@ export const redwoodPlugin = async (options = {}) => {
             clientEntryPathname,
             workerEntryPathname,
         }),
-        ssrBridgePlugin(),
+        ssrBridgePlugin({
+            clientFiles,
+            serverFiles,
+            projectRootDir,
+        }),
         reactConditionsResolverPlugin(),
         tsconfigPaths({ root: projectRootDir }),
-        miniflarePlugin({
+        shouldIncludeCloudflarePlugin
+            ? cloudflare({
+                viteEnvironment: { name: "worker" },
+                configPath: options.configPath ?? (await findWranglerConfig(projectRootDir)),
+            })
+            : [],
+        miniflareHMRPlugin({
             rootDir: projectRootDir,
             viteEnvironment: { name: "worker" },
             workerEntryPathname,
-            configPath: options.configPath ?? (await findWranglerConfig(projectRootDir)),
         }),
         reactPlugin(),
         directivesPlugin({

package/dist/vite/resolveModuleId.d.mts

@@ -0,0 +1,6 @@
+/**
+ * Resolves a module ID consistently across client and server transformations.
+ * For node modules, uses the /rwsdk:kind/relativePath format.
+ * For regular files, uses the raw ID.
+ */
+export declare function resolveModuleId(id: string, kind: "client" | "server", projectRootDir: string): string;

package/dist/vite/resolveModuleId.mjs

@@ -0,0 +1,14 @@
+import { normalizeModulePath } from "./normalizeModulePath.mjs";
+/**
+ * Resolves a module ID consistently across client and server transformations.
+ * For node modules, uses the /rwsdk:kind/relativePath format.
+ * For regular files, uses the raw ID.
+ */
+export function resolveModuleId(id, kind, projectRootDir) {
+    const modulePath = normalizeModulePath(projectRootDir, id);
+    return modulePath.includes("node_modules")
+        ? modulePath.includes("__rwsdk_kind")
+            ? modulePath
+            : `${modulePath}?__rwsdk_kind=${kind}`
+        : modulePath;
+}

package/dist/vite/ssrBridgePlugin.d.mts

@@ -1,3 +1,7 @@
 import type { Plugin } from "vite";
 export declare const VIRTUAL_SSR_PREFIX = "virtual:rwsdk:ssr:";
-export declare const ssrBridgePlugin: () => Plugin;
+export declare const ssrBridgePlugin: ({ clientFiles, serverFiles, }: {
+    clientFiles: Set<string>;
+    serverFiles: Set<string>;
+    projectRootDir: string;
+}) => Plugin;

package/dist/vite/ssrBridgePlugin.mjs

@@ -1,40 +1,13 @@
 import debug from "debug";
 import { SSR_BRIDGE_PATH } from "../lib/constants.mjs";
+import { invalidateModule } from "./invalidateModule.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 = () => {
+export const ssrBridgePlugin = ({ clientFiles, serverFiles, }) => {
     log("Initializing SSR bridge plugin with SSR_BRIDGE_PATH=%s", SSR_BRIDGE_PATH);
     let devServer;
     let isDev = false;
-    let promisedSSRWarmup;
-    const ensureWarmupSSRModules = async () => {
-        if (promisedSSRWarmup) {
-            log("SSR warmup already in progress");
-            return promisedSSRWarmup;
-        }
-        promisedSSRWarmup = doWarmupSSRModules();
-        return promisedSSRWarmup;
-    };
-    const doWarmupSSRModules = async () => {
-        log("Warming up SSR modules");
-        const files = [
-            "virtual:use-server-lookup",
-            "virtual:use-client-lookup",
-            "rwsdk/__ssr",
-            "rwsdk/__ssr_bridge",
-        ];
-        for (const file of files) {
-            log("Warming up SSR file: %s", file);
-            await devServer.environments.ssr.warmupRequest(file);
-            log("Waiting for SSR requests to idle");
-            await devServer.environments.ssr.waitForRequestsIdle();
-            log("Deps optimizer scan processing");
-            await devServer.environments.ssr.depsOptimizer?.scanProcessing;
-            log("Deps optimizer scan processing complete");
-        }
-        log("SSR warmup complete");
-    };
     const ssrBridgePlugin = {
         name: "rwsdk:ssr-bridge",
         enforce: "pre",
@@ -112,11 +85,10 @@ export const ssrBridgePlugin = () => {
             verboseLog("Loading id=%s, isDev=%s, environment=%s", id, isDev, this.environment.name);
             if (id.startsWith(VIRTUAL_SSR_PREFIX) &&
                 this.environment.name === "worker") {
-                await ensureWarmupSSRModules();
                 const realId = id.slice(VIRTUAL_SSR_PREFIX.length);
                 log("Virtual SSR module load: id=%s, realId=%s", id, realId);
                 if (isDev) {
-                    log("Dev mode: warming up and fetching SSR module for realPath=%s", realId);
+                    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);
                     if (!result) {
@@ -129,7 +101,7 @@ export const ssrBridgePlugin = () => {
 await (async function(__vite_ssr_import__, __vite_ssr_dynamic_import__) {${code}})((id) => __vite_ssr_import__('/@id/${VIRTUAL_SSR_PREFIX}'+id), (id) => __vite_ssr_dynamic_import__('/@id/${VIRTUAL_SSR_PREFIX}'+id));
 `;
                     log("Transformed SSR module code length: %d", transformedCode.length);
-                    log("Transformed SSR module code: %s", transformedCode);
+                    verboseLog("Transformed SSR module code for realId=%s: %s", realId, transformedCode);
                     return transformedCode;
                 }
             }
@@ -138,14 +110,3 @@ await (async function(__vite_ssr_import__, __vite_ssr_dynamic_import__) {${code}
     };
     return ssrBridgePlugin;
 };
-const invalidateModule = (devServer, environment, id) => {
-    const [rawId, _query] = id.split("?");
-    log("Invalidating module: id=%s, environment=%s", id, environment);
-    const moduleNode = devServer?.environments[environment]?.moduleGraph.idToModuleMap.get(rawId);
-    if (moduleNode) {
-        devServer?.environments[environment]?.moduleGraph.invalidateModule(moduleNode);
-    }
-    else {
-        verboseLog("Module not found: id=%s, environment=%s", id, environment);
-    }
-};

package/dist/vite/transformClientComponents.d.mts

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

package/dist/vite/transformClientComponents.mjs

@@ -1,5 +1,7 @@
-import { Project, SyntaxKind, Node } from "ts-morph";
+import MagicString from "magic-string";
 import debug from "debug";
+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");
@@ -7,170 +9,104 @@ const verboseLogEsbuild = debug("verbose:rwsdk:vite:transform-client-components:
 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, ctx: %O", normalizedId, ctx);
-    function extractSourceMapFromEmit(sourceFile) {
-        const emitOutput = sourceFile.getEmitOutput();
-        let sourceMap;
-        const outputFiles = emitOutput.getOutputFiles();
-        log(":isEsbuild=%s: EmitOutput files for %s (%s) - %d files:", !!ctx.isEsbuild, normalizedId, ctx.environmentName, outputFiles.length);
-        for (const outputFile of outputFiles) {
-            log(":isEsbuild=%s: - %s (%s)", !!ctx.isEsbuild, outputFile.getFilePath(), ctx.environmentName);
-            if (outputFile.getFilePath().endsWith(".js.map")) {
-                sourceMap = JSON.parse(outputFile.getText());
-            }
-        }
-        return sourceMap;
-    }
-    // 2. Only transform files that start with 'use client'
-    const cleanCode = code.trimStart();
-    const hasUseClient = cleanCode.startsWith('"use client"') ||
-        cleanCode.startsWith("'use client'");
-    if (!hasUseClient) {
+    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);
         return;
     }
     log("Processing 'use client' module: id=%s", normalizedId);
-    ctx.clientFiles?.add(normalizedId);
-    // Use ts-morph to collect all export info and perform transformations
-    const project = new Project({
-        useInMemoryFileSystem: true,
-        compilerOptions: {
-            sourceMap: true,
-            inlineSourceMap: false,
-            allowJs: true,
-            checkJs: true,
-            target: 2, // ES6
-            module: 1, // CommonJS
-            jsx: 2, // React
-        },
-    });
-    const sourceFile = project.createSourceFile(normalizedId + ".ts", code);
-    const exportInfos = [];
+    ctx.addClientModule?.(ctx.environmentName, normalizedId);
+    // Parse exports using the findExports helper
+    const exportInfos = findExports(normalizedId, code, verboseLog);
+    const processedExports = [];
     let defaultExportInfo;
     // Helper to get the computed local name (with alias suffix if present)
     function getComputedLocalName(info) {
         return `${info.local}${info.alias ? `_${info.alias}` : ""}`;
     }
-    // Helper to add export info
-    function addExport(local, exported, isDefault, statementIdx, alias) {
-        if (isDefault) {
-            defaultExportInfo = { local, exported, isDefault, statementIdx };
+    // Convert ExportInfo to ProcessedExportInfo
+    exportInfos.forEach((exportInfo, idx) => {
+        if (exportInfo.isDefault) {
+            defaultExportInfo = {
+                local: exportInfo.alias || "default",
+                exported: "default",
+                isDefault: true,
+                statementIdx: idx,
+            };
         }
         else {
-            exportInfos.push({ local, exported, isDefault, statementIdx, alias });
-        }
-    }
-    // Walk through statements in order to collect export information
-    const statements = sourceFile.getStatements();
-    statements.forEach((stmt, idx) => {
-        // export default function ...
-        if (Node.isFunctionDeclaration(stmt) &&
-            stmt.hasModifier(SyntaxKind.ExportKeyword) &&
-            stmt.hasModifier(SyntaxKind.DefaultKeyword)) {
-            addExport("default", "default", true, idx);
-            return;
-        }
-        // export default ... (assignment)
-        if (Node.isExportAssignment(stmt)) {
-            const expr = stmt.getExpression();
-            if (Node.isIdentifier(expr)) {
-                addExport(expr.getText(), "default", true, idx);
-            }
-            else {
-                addExport("default", "default", true, idx);
-            }
-            return;
-        }
-        // export const foo = ...
-        if (Node.isVariableStatement(stmt) &&
-            stmt.hasModifier(SyntaxKind.ExportKeyword)) {
-            stmt
-                .getDeclarationList()
-                .getDeclarations()
-                .forEach((decl) => {
-                const name = decl.getName();
-                addExport(name, name, false, idx);
+            // For aliases like "export { MyComponent as CustomName }", we need:
+            // - local: "MyComponent" (the original name)
+            // - exported: "CustomName" (the alias name)
+            // - alias: "CustomName" (to generate MyComponent_CustomName)
+            const hasAlias = exportInfo.alias && exportInfo.originalName;
+            processedExports.push({
+                local: exportInfo.originalName || exportInfo.name, // Use originalName if available
+                exported: exportInfo.name, // The exported name (alias if present)
+                isDefault: false,
+                statementIdx: idx,
+                alias: hasAlias ? exportInfo.alias : undefined,
             });
-            return;
-        }
-        // export function foo() ...
-        if (Node.isFunctionDeclaration(stmt) &&
-            stmt.hasModifier(SyntaxKind.ExportKeyword)) {
-            if (!stmt.hasModifier(SyntaxKind.DefaultKeyword)) {
-                const name = stmt.getName();
-                if (name) {
-                    addExport(name, name, false, idx);
-                }
-            }
-            return;
-        }
-        // export { ... } or export { ... } from ...
-        if (Node.isExportDeclaration(stmt)) {
-            const namedExports = stmt.getNamedExports();
-            if (namedExports.length > 0) {
-                namedExports.forEach((exp) => {
-                    const alias = exp.getAliasNode()?.getText();
-                    const local = alias ? exp.getNameNode().getText() : exp.getName();
-                    const exported = alias ? alias : exp.getName();
-                    addExport(local, exported, exported === "default", idx, alias);
-                });
-            }
-            return;
         }
     });
     // 3. Client/SSR files: just remove the directive
     if (ctx.environmentName === "ssr" || ctx.environmentName === "client") {
         log(":isEsbuild=%s: Handling SSR virtual module: %s", !!ctx.isEsbuild, normalizedId);
-        // Remove 'use client' directive using ts-morph
-        sourceFile
-            .getDescendantsOfKind(SyntaxKind.StringLiteral)
-            .forEach((node) => {
-            if (node.getText() === "'use client'" ||
-                node.getText() === '"use client"') {
-                const parentExpr = node.getFirstAncestorByKind(SyntaxKind.ExpressionStatement);
-                if (parentExpr) {
-                    parentExpr.remove();
-                }
-            }
+        // Remove 'use client' directive using magic-string
+        const s = new MagicString(code);
+        // Find and remove "use client" directives
+        const directiveRegex = /^(\s*)(['"]use client['"])\s*;?\s*\n?/gm;
+        let match;
+        while ((match = directiveRegex.exec(code)) !== null) {
+            const start = match.index;
+            const end = match.index + match[0].length;
+            s.remove(start, end);
+            verboseLog("Removed 'use client' directive from normalizedId=%s", normalizedId);
+            break; // Only remove the first one
+        }
+        const sourceMap = s.generateMap({
+            source: normalizedId,
+            includeContent: true,
+            hires: true,
         });
-        const sourceMap = extractSourceMapFromEmit(sourceFile);
-        verboseLog(":VERBOSE: SSR transformed code for %s:\n%s", normalizedId, sourceFile.getFullText());
+        verboseLog(":VERBOSE: SSR transformed code for %s:\n%s", normalizedId, s.toString());
         return {
-            code: sourceFile.getFullText(),
+            code: s.toString(),
             map: sourceMap,
         };
     }
     // 4. Non-SSR files: replace all implementation with registerClientReference logic
-    // Clear the source file and rebuild it
-    sourceFile.removeText();
+    // Generate completely new code for worker/client environments
+    const s = new MagicString("");
     // Add import declaration
-    sourceFile.addImportDeclaration({
-        moduleSpecifier: "rwsdk/worker",
-        namedImports: [{ name: "registerClientReference" }],
-    });
+    s.append('import { registerClientReference } from "rwsdk/worker";\n');
     // Compute unique computed local names first
-    const computedLocalNames = new Map(exportInfos.map((info) => [getComputedLocalName(info), info]));
+    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);
-        sourceFile.addStatements(`const ${computedLocalName} = registerClientReference("${normalizedId}", "${correspondingInfo.exported}");`);
+        s.append(`const ${computedLocalName} = registerClientReference("${normalizedId}", "${correspondingInfo.exported}");\n`);
     }
     // Add grouped export statement for named exports (preserving order and alias)
-    if (exportInfos.length > 0) {
+    if (processedExports.length > 0) {
         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);
-        sourceFile.addStatements(`export { ${exportNames.join(", ")} };`);
+        s.append(`export { ${exportNames.join(", ")} };\n`);
     }
     // Add default export if present
     if (defaultExportInfo) {
         log(":isEsbuild=%s: Registering client reference for default export: %s", !!ctx.isEsbuild, defaultExportInfo.exported);
-        sourceFile.addStatements(`export default registerClientReference("${normalizedId}", "${defaultExportInfo.exported}");`);
+        s.append(`export default registerClientReference("${normalizedId}", "${defaultExportInfo.exported}");\n`);
     }
-    const sourceMap = extractSourceMapFromEmit(sourceFile);
-    const finalResult = sourceFile.getFullText();
+    const sourceMap = s.generateMap({
+        source: normalizedId,
+        includeContent: true,
+        hires: true,
+    });
+    const finalResult = s.toString();
     verboseLog(":VERBOSE: Transformed code (env=%s, normalizedId=%s):\n%s", normalizedId, ctx.environmentName, finalResult);
     return {
         code: finalResult,

package/dist/vite/transformJsxScriptTagsPlugin.mjs

@@ -12,9 +12,19 @@ const readManifest = async (manifestPath) => {
     }
     return manifestCache;
 };
-// Check if a string includes any jsx function calls
 function hasJsxFunctions(text) {
-    return (text.includes("jsx(") || text.includes("jsxs(") || text.includes("jsxDEV("));
+    return (text.includes('jsx("script"') ||
+        text.includes("jsx('script'") ||
+        text.includes('jsx("link"') ||
+        text.includes("jsx('link'") ||
+        text.includes('jsxs("script"') ||
+        text.includes("jsxs('script'") ||
+        text.includes('jsxs("link"') ||
+        text.includes("jsxs('link'") ||
+        text.includes('jsxDEV("script"') ||
+        text.includes("jsxDEV('script'") ||
+        text.includes('jsxDEV("link"') ||
+        text.includes("jsxDEV('link'"));
 }
 // Transform import statements in script content using ts-morph
 function transformScriptImports(scriptContent, manifest) {
@@ -68,7 +78,8 @@ function transformScriptImports(scriptContent, manifest) {
     }
 }
 export async function transformJsxScriptTagsCode(code, manifest = {}) {
-    // Quick heuristic check if there's JSX in the code
+    // context(justinvdm, 15 Jun 2025): Optimization to exit early
+    // to avoidunnecessary ts-morph parsing
     if (!hasJsxFunctions(code)) {
         return;
     }

package/dist/vite/transformServerFunctions.d.mts

@@ -1,8 +1,16 @@
-import { SourceFile } from "ts-morph";
 interface TransformResult {
     code: string;
     map?: any;
 }
-export declare const findExportedFunctions: (sourceFile: SourceFile) => Set<string>;
-export declare const transformServerFunctions: (code: string, normalizedId: string, environment: "client" | "worker" | "ssr", serverFiles?: Set<string>) => TransformResult | undefined;
+type ExportInfoCompat = {
+    localFunctions: Set<string>;
+    reExports: Array<{
+        localName: string;
+        originalName: string;
+        moduleSpecifier: string;
+    }>;
+};
+export declare const findExportedFunctions: (code: string, normalizedId?: string) => Set<string>;
+export declare const findExportInfo: (code: string, normalizedId?: string) => ExportInfoCompat;
+export declare const transformServerFunctions: (code: string, normalizedId: string, environment: "client" | "worker" | "ssr", serverFiles?: Set<string>, addServerModule?: (environment: string, id: string) => void) => TransformResult | undefined;
 export type { TransformResult };