vite-plugin-server-actions 1.0.1 → 1.2.0

package/src/index.js

@@ -3,10 +3,126 @@ import path from "path";
 import express from "express";
 import { rollup } from "rollup";
 import { minimatch } from "minimatch";
+import esbuild from "esbuild";
+import { createRequire } from "module";
+import { fileURLToPath } from "url";
+import os from "os";
 import { middleware } from "./middleware.js";
 import { defaultSchemaDiscovery, createValidationMiddleware } from "./validation.js";
 import { OpenAPIGenerator, setupOpenAPIEndpoints } from "./openapi.js";
 import { generateValidationCode } from "./build-utils.js";
+import { extractExportedFunctions, isValidFunctionName } from "./ast-parser.js";
+import { generateTypeDefinitions, generateEnhancedClientProxy } from "./type-generator.js";
+import { sanitizePath, isValidModuleName, createSecureModuleName, createErrorResponse } from "./security.js";
+import {
+	enhanceFunctionNotFoundError,
+	enhanceParsingError,
+	enhanceValidationError,
+	enhanceModuleLoadError,
+	createDevelopmentWarning,
+} from "./error-enhancer.js";
+import {
+	validateFunctionSignature,
+	validateFileStructure,
+	createDevelopmentFeedback,
+	validateSchemaAttachment,
+} from "./dev-validator.js";
+
+// Module cache moved to plugin instance to avoid cross-instance pollution
+
+/**
+ * Import a module, handling TypeScript files in development
+ * @param {string} id - Module path
+ * @param {any} viteServer - Vite dev server instance
+ * @param {Map} cache - Module cache for this plugin instance
+ * @returns {Promise<any>} - Imported module
+ */
+async function importModule(id, viteServer = null, cache = new Map()) {
+	// In production or for JS files, use regular import
+	if (process.env.NODE_ENV === "production" || !id.endsWith(".ts")) {
+		return import(id);
+	}
+
+	// Use Vite's SSR module loader if available (preferred method)
+	if (viteServer && viteServer.ssrLoadModule) {
+		try {
+			// Clear from cache if it exists to ensure fresh load
+			if (cache.has(id)) {
+				cache.delete(id);
+			}
+
+			const module = await viteServer.ssrLoadModule(id);
+			cache.set(id, module);
+			return module;
+		} catch (error) {
+			console.error(`Failed to load module ${id} via Vite SSR:`, error);
+			// Fall through to manual compilation
+		}
+	}
+
+	// Check cache first
+	if (cache.has(id)) {
+		return cache.get(id);
+	}
+
+	// Fallback: Manual TypeScript compilation (when Vite server is not available)
+	// Retry logic for TypeScript compilation failures
+	let retryCount = 0;
+	const maxRetries = 3;
+
+	while (retryCount < maxRetries) {
+		try {
+			// Read and transform TypeScript file
+			const tsCode = await fs.readFile(id, "utf-8");
+
+			// Transform imports to be relative to the original file location
+			const result = await esbuild.transform(tsCode, {
+				loader: "ts",
+				target: "node16",
+				format: "esm",
+				sourcefile: id,
+				sourcemap: "inline",
+			});
+
+			// Create a temporary file in the same directory as the original
+			// This ensures relative imports work correctly
+			const dir = path.dirname(id);
+			const basename = path.basename(id, ".ts");
+			const tmpFile = path.join(dir, `.${basename}.tmp.mjs`);
+
+			// Write compiled JavaScript
+			await fs.writeFile(tmpFile, result.code, "utf-8");
+
+			try {
+				// Add a small delay to ensure file is written
+				await new Promise((resolve) => setTimeout(resolve, 50));
+
+				// Import the compiled module with cache busting
+				const module = await import(`${tmpFile}?t=${Date.now()}`);
+
+				// Cache the module
+				cache.set(id, module);
+
+				// Clean up temp file immediately
+				await fs.unlink(tmpFile).catch(() => {});
+
+				return module;
+			} catch (importError) {
+				// Clean up on error
+				await fs.unlink(tmpFile).catch(() => {});
+				throw importError;
+			}
+		} catch (error) {
+			retryCount++;
+			if (retryCount >= maxRetries) {
+				console.error(`Failed to import TypeScript module ${id} after ${maxRetries} attempts:`, error);
+				throw error;
+			}
+			// Wait before retry
+			await new Promise((resolve) => setTimeout(resolve, 100 * retryCount));
+		}
+	}
+}
 
 // Utility functions for path transformation
 export const pathUtils = {
@@ -19,7 +135,7 @@ export const pathUtils = {
 		return filePath
 			.replace(/\//g, "_") // Replace slashes with underscores
 			.replace(/\./g, "_") // Replace dots with underscores
-			.replace(/_server_js$/, ""); // Remove .server.js extension
+			.replace(/_server_(js|ts)$/, ""); // Remove .server.js or .server.ts extension
 	},
 
 	/**
@@ -31,7 +147,7 @@ export const pathUtils = {
 	createCleanRoute: (filePath, functionName) => {
 		const cleanPath = filePath
 			.replace(/^src\//, "") // Remove src/ prefix
-			.replace(/\.server\.js$/, ""); // Remove .server.js suffix
+			.replace(/\.server\.(js|ts)$/, ""); // Remove .server.js or .server.ts suffix
 		return `${cleanPath}/${functionName}`;
 	},
 
@@ -44,7 +160,7 @@ export const pathUtils = {
 	createLegacyRoute: (filePath, functionName) => {
 		const legacyPath = filePath
 			.replace(/\//g, "_") // Replace slashes with underscores
-			.replace(/\.server\.js$/, ""); // Remove .server.js extension
+			.replace(/\.server\.(js|ts)$/, ""); // Remove .server.js or .server.ts extension
 		return `${legacyPath}/${functionName}`;
 	},
 
@@ -55,14 +171,14 @@ export const pathUtils = {
 	 * @returns {string} - Minimal route (e.g., "actions/todo.server/create")
 	 */
 	createMinimalRoute: (filePath, functionName) => {
-		const minimalPath = filePath.replace(/\.js$/, ""); // Just remove .js
+		const minimalPath = filePath.replace(/\.(js|ts)$/, ""); // Just remove .js or .ts
 		return `${minimalPath}/${functionName}`;
 	},
 };
 
 const DEFAULT_OPTIONS = {
 	apiPrefix: "/api",
-	include: ["**/*.server.js"],
+	include: ["**/*.server.js", "**/*.server.ts"],
 	exclude: [],
 	middleware: [],
 	moduleNameTransform: pathUtils.createModuleName,
@@ -70,7 +186,7 @@ const DEFAULT_OPTIONS = {
 		// Default to clean hierarchical paths: /api/actions/todo/create
 		const cleanPath = filePath
 			.replace(/^src\//, "") // Remove src/ prefix
-			.replace(/\.server\.js$/, ""); // Remove .server.js suffix
+			.replace(/\.server\.(js|ts)$/, ""); // Remove .server.js or .server.ts suffix
 		return `${cleanPath}/${functionName}`;
 	},
 	validation: {
@@ -114,10 +230,12 @@ export default function serverActions(userOptions = {}) {
 
 	const serverFunctions = new Map();
 	const schemaDiscovery = defaultSchemaDiscovery;
+	const tsModuleCache = new Map(); // Per-instance cache for TypeScript modules
 	let app;
 	let openAPIGenerator;
 	let validationMiddleware = null;
 	let viteConfig = null;
+	let viteDevServer = null;
 
 	// Initialize OpenAPI generator if enabled
 	if (options.openAPI.enabled) {
@@ -142,16 +260,41 @@ export default function serverActions(userOptions = {}) {
 		},
 
 		configureServer(server) {
+			viteDevServer = server;
 			app = express();
 			app.use(express.json());
 
+			// Clean up on HMR
+			if (server.watcher) {
+				server.watcher.on("change", (file) => {
+					// If a server file changed, remove it from the map
+					if (shouldProcessFile(file, options)) {
+						// Clear TypeScript cache for this file
+						if (file.endsWith(".ts")) {
+							tsModuleCache.delete(file);
+						}
+
+						for (const [moduleName, moduleInfo] of serverFunctions.entries()) {
+							if (moduleInfo.id === file) {
+								serverFunctions.delete(moduleName);
+								schemaDiscovery.clear(); // Clear associated schemas
+								console.log(`[HMR] Cleaned up server module: ${moduleName}`);
+							}
+						}
+					}
+				});
+			}
+
 			// Setup dynamic OpenAPI endpoints in development
 			if (process.env.NODE_ENV !== "production" && options.openAPI.enabled && openAPIGenerator) {
 				// OpenAPI spec endpoint - generates spec dynamically from current serverFunctions
 				app.get(options.openAPI.specPath, (req, res) => {
+					// Get the actual port from the request
+					const port = req.get("host")?.split(":")[1] || viteConfig.server?.port || 5173;
 					const openAPISpec = openAPIGenerator.generateSpec(serverFunctions, schemaDiscovery, {
 						apiPrefix: options.apiPrefix,
 						routeTransform: options.routeTransform,
+						port,
 					});
 
 					// Add a note if no functions are found
@@ -185,7 +328,7 @@ export default function serverActions(userOptions = {}) {
 								// Wait for server to start and get the actual port, then log URLs
 								server.httpServer?.on("listening", () => {
 									const address = server.httpServer.address();
-									const port = address?.port || 5173;
+									const port = address?.port || viteConfig.server?.port || 5173;
 									// Always use localhost for consistent display
 									const host = "localhost";
 
@@ -211,52 +354,140 @@ export default function serverActions(userOptions = {}) {
 			}
 
 			server.middlewares.use(app);
+
+			// Show development feedback after server is ready
+			if (process.env.NODE_ENV === "development") {
+				server.httpServer?.on("listening", () => {
+					// Delay to appear after Vite's startup messages
+					global.setTimeout(() => {
+						if (serverFunctions.size > 0) {
+							console.log(createDevelopmentFeedback(serverFunctions));
+						}
+					}, 100);
+				});
+			}
 		},
 
-		async resolveId(source, importer) {
+		async resolveId(source, importer, resolveOptions) {
+			// Skip SSR resolution
+			if (resolveOptions?.ssr) {
+				return null;
+			}
+
+			// Handle server file imports from client code
 			if (importer && shouldProcessFile(source, options)) {
 				const resolvedPath = path.resolve(path.dirname(importer), source);
 				return resolvedPath;
 			}
+
+			// Handle TypeScript imports from server files
+			if (importer && shouldProcessFile(importer, options)) {
+				// Check if this is a relative import
+				if (source.startsWith(".") || source.startsWith("/")) {
+					// Try to resolve TypeScript file
+					const basePath = path.resolve(path.dirname(importer), source);
+					const possiblePaths = [
+						basePath,
+						`${basePath}.ts`,
+						`${basePath}.tsx`,
+						path.join(basePath, "index.ts"),
+						path.join(basePath, "index.tsx"),
+					];
+
+					for (const possiblePath of possiblePaths) {
+						try {
+							const stats = await fs.stat(possiblePath);
+							// Only return if it's a file, not a directory
+							if (stats.isFile()) {
+								return possiblePath;
+							}
+						} catch {
+							// File doesn't exist, try next
+						}
+					}
+				}
+			}
+
+			return null;
 		},
 
-		async load(id) {
+		async load(id, loadOptions) {
 			if (shouldProcessFile(id, options)) {
+				// Check if this is an SSR request - if so, let Vite handle the actual module
+				if (loadOptions?.ssr) {
+					return null; // Let Vite handle SSR loading of the actual module
+				}
 				try {
 					const code = await fs.readFile(id, "utf-8");
 
-					let relativePath = path.relative(process.cwd(), id);
-
-					// If the file is outside the project root, use the absolute path
-					if (relativePath.startsWith("..")) {
-						relativePath = id;
+					// Sanitize the file path for security
+					const sanitizedPath = sanitizePath(id, process.cwd());
+					if (!sanitizedPath) {
+						throw new Error(`Invalid file path detected: ${id}`);
 					}
 
+					let relativePath = path.relative(process.cwd(), sanitizedPath);
+
 					// Normalize path separators
 					relativePath = relativePath.replace(/\\/g, "/").replace(/^\//, "");
 
 					// Generate module name for internal use (must be valid identifier)
-					const moduleName = options.moduleNameTransform(relativePath);
+					const moduleName = createSecureModuleName(options.moduleNameTransform(relativePath));
 
 					// Validate module name
-					if (!moduleName || moduleName.includes("..")) {
+					if (!isValidModuleName(moduleName)) {
 						throw new Error(`Invalid server module name: ${moduleName}`);
 					}
 
-					const exportRegex = /export\s+(async\s+)?function\s+(\w+)/g;
+					// Use AST parser to extract exported functions with detailed information
+					const exportedFunctions = extractExportedFunctions(code, id);
 					const functions = [];
-					let match;
-
-					while ((match = exportRegex.exec(code)) !== null) {
-						const functionName = match[2];
+					const functionDetails = [];
+
+					for (const fn of exportedFunctions) {
+						// Skip default exports for now (could be supported in future)
+						if (fn.isDefault) {
+							console.warn(
+								createDevelopmentWarning("Default Export Skipped", `Default exports are not currently supported`, {
+									filePath: relativePath,
+									suggestion: "Use named exports instead: export async function myFunction() {}",
+								}),
+							);
+							continue;
+						}
 
 						// Validate function name
-						if (!functionName || !/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(functionName)) {
-							console.warn(`Skipping invalid function name: ${functionName} in ${id}`);
+						if (!isValidFunctionName(fn.name)) {
+							console.warn(
+								createDevelopmentWarning(
+									"Invalid Function Name",
+									`Function name '${fn.name}' is not a valid JavaScript identifier`,
+									{
+										filePath: relativePath,
+										suggestion:
+											"Function names must start with a letter, $, or _ and contain only letters, numbers, $, and _",
+									},
+								),
+							);
 							continue;
 						}
 
-						functions.push(functionName);
+						// Warn about non-async functions
+						if (!fn.isAsync) {
+							console.warn(
+								createDevelopmentWarning(
+									"Non-Async Function",
+									`Function '${fn.name}' is not async. Server actions should typically be async`,
+									{
+										filePath: relativePath,
+										suggestion: "Consider changing to: export async function " + fn.name + "() {}",
+									},
+								),
+							);
+						}
+
+						functions.push(fn.name);
+						functionDetails.push(fn);
 					}
 
 					// Check for duplicate function names within the same module
@@ -265,16 +496,52 @@ export default function serverActions(userOptions = {}) {
 						console.warn(`Duplicate function names detected in ${id}`);
 					}
 
-					serverFunctions.set(moduleName, { functions: uniqueFunctions, id, filePath: relativePath });
+					// Store both simple function names and detailed information
+					serverFunctions.set(moduleName, {
+						functions: uniqueFunctions,
+						functionDetails,
+						id,
+						filePath: relativePath,
+					});
+
+					// Development-time validation and feedback
+					if (process.env.NODE_ENV === "development") {
+						// Validate file structure
+						const fileWarnings = validateFileStructure(functionDetails, relativePath);
+						fileWarnings.forEach((warning) => console.warn(warning));
+
+						// Validate individual function signatures
+						functionDetails.forEach((func) => {
+							const funcWarnings = validateFunctionSignature(func, relativePath);
+							funcWarnings.forEach((warning) => console.warn(warning));
+						});
+					}
 
 					// Discover schemas from module if validation is enabled (development only)
-					if (options.validation.enabled && process.env.NODE_ENV !== "production") {
+					// Skip TypeScript files to avoid SSR loading issues
+					if (options.validation.enabled && process.env.NODE_ENV !== "production" && !id.endsWith(".ts")) {
 						try {
-							const module = await import(id);
+							const module = await importModule(id, viteDevServer, tsModuleCache);
 							schemaDiscovery.discoverFromModule(module, moduleName);
+
+							// Validate schema attachment in development
+							if (process.env.NODE_ENV === "development") {
+								const schemaWarnings = validateSchemaAttachment(module, uniqueFunctions, relativePath);
+								schemaWarnings.forEach((warning) => console.warn(warning));
+							}
 						} catch (error) {
-							console.warn(`Failed to discover schemas from ${id}: ${error.message}`);
+							const enhancedError = enhanceModuleLoadError(id, error);
+							console.warn(enhancedError.message);
+
+							if (process.env.NODE_ENV === "development" && enhancedError.suggestions) {
+								enhancedError.suggestions.forEach((suggestion) => {
+									console.info(`  💡 ${suggestion}`);
+								});
+							}
 						}
+					} else if (options.validation.enabled && id.endsWith(".ts")) {
+						// For TypeScript files, defer schema discovery to request time
+						console.log(`[Vite Server Actions] Deferring schema discovery for TypeScript file: ${relativePath}`);
 					}
 
 					// Setup routes in development mode only
@@ -318,11 +585,29 @@ export default function serverActions(userOptions = {}) {
 							// Apply middleware before the handler
 							app.post(endpoint, ...contextMiddlewares, async (req, res) => {
 								try {
-									const module = await import(id);
+									const module = await importModule(id, viteDevServer, tsModuleCache);
+
+									// Lazy schema discovery for TypeScript files
+									if (
+										options.validation.enabled &&
+										id.endsWith(".ts") &&
+										!schemaDiscovery.hasSchema(moduleName, functionName)
+									) {
+										try {
+											schemaDiscovery.discoverFromModule(module, moduleName);
+										} catch (err) {
+											console.warn(`Failed to discover schemas for ${moduleName}:`, err.message);
+										}
+									}
 
 									// Check if function exists in module
 									if (typeof module[functionName] !== "function") {
-										throw new Error(`Function ${functionName} not found or not a function`);
+										// Get available functions for better error message
+										const availableFunctions = Object.keys(module).filter((key) => typeof module[key] === "function");
+
+										const enhancedError = enhanceFunctionNotFoundError(functionName, moduleName, availableFunctions);
+
+										throw new Error(enhancedError.message);
 									}
 
 									// Validate request body is array for function arguments
@@ -331,25 +616,48 @@ export default function serverActions(userOptions = {}) {
 									}
 
 									const result = await module[functionName](...req.body);
-									res.json(result || "* No response *");
+									if (result === undefined) {
+										res.status(204).end();
+									} else {
+										res.json(result);
+									}
 								} catch (error) {
 									console.error(`Error in ${functionName}: ${error.message}`);
 
 									if (error.message.includes("not found") || error.message.includes("not a function")) {
-										res.status(404).json({
-											error: "Function not found",
-											details: error.message,
-										});
+										// Extract available functions from the error context if available
+										const availableFunctionsMatch = error.message.match(/Available functions: ([^]+)/);
+										const availableFunctions = availableFunctionsMatch ? availableFunctionsMatch[1].split(", ") : [];
+
+										res.status(404).json(
+											createErrorResponse(404, "Function not found", "FUNCTION_NOT_FOUND", {
+												functionName,
+												moduleName,
+												availableFunctions: availableFunctions.length > 0 ? availableFunctions : undefined,
+												suggestion: `Try one of: ${availableFunctions.join(", ") || "none available"}`,
+											}),
+										);
 									} else if (error.message.includes("Request body")) {
-										res.status(400).json({
-											error: "Bad request",
-											details: error.message,
-										});
+										res.status(400).json(
+											createErrorResponse(400, error.message, "INVALID_REQUEST_BODY", {
+												suggestion: "Send an array of arguments: [arg1, arg2, ...]",
+											}),
+										);
 									} else {
-										res.status(500).json({
-											error: "Internal server error",
-											details: error.message,
-										});
+										res.status(500).json(
+											createErrorResponse(
+												500,
+												"Internal server error",
+												"INTERNAL_ERROR",
+												process.env.NODE_ENV !== "production"
+													? {
+															message: error.message,
+															stack: error.stack,
+															suggestion: "Check server logs for more details",
+														}
+													: { suggestion: "Contact support if this persists" },
+											),
+										);
 									}
 								}
 							});
@@ -357,11 +665,29 @@ export default function serverActions(userOptions = {}) {
 					}
 					// OpenAPI endpoints will be set up during configureServer after all modules are loaded
 
-					return generateClientProxy(moduleName, uniqueFunctions, options, relativePath);
+					// Use enhanced client proxy generator if we have detailed function information
+					if (functionDetails.length > 0) {
+						return generateEnhancedClientProxy(moduleName, functionDetails, options, relativePath);
+					} else {
+						// Fallback to basic proxy for backwards compatibility
+						return generateClientProxy(moduleName, uniqueFunctions, options, relativePath);
+					}
 				} catch (error) {
-					console.error(`Failed to process server file ${id}: ${error.message}`);
-					// Return empty proxy instead of failing the build
-					return `// Failed to load server actions from ${id}: ${error.message}`;
+					const enhancedError = enhanceParsingError(id, error);
+					console.error(enhancedError.message);
+
+					// Provide helpful suggestions in development
+					if (process.env.NODE_ENV === "development" && enhancedError.suggestions.length > 0) {
+						console.info("[Vite Server Actions] 💡 Suggestions:");
+						enhancedError.suggestions.forEach((suggestion) => {
+							console.info(`  • ${suggestion}`);
+						});
+					}
+
+					// Return error comment with context instead of failing the build
+					return `// Failed to load server actions from ${id}
+// Error: ${error.message}
+// ${enhancedError.suggestions.length > 0 ? "Suggestions: " + enhancedError.suggestions.join(", ") : ""}`;
 				}
 			}
 		},
@@ -398,6 +724,22 @@ export default function serverActions(userOptions = {}) {
 							}
 						},
 					},
+					{
+						name: "typescript-transform",
+						async load(id) {
+							// Handle TypeScript files
+							if (id.endsWith(".ts")) {
+								const code = await fs.readFile(id, "utf-8");
+								const result = await esbuild.transform(code, {
+									loader: "ts",
+									target: "node16",
+									format: "esm",
+								});
+								return result.code;
+							}
+							return null;
+						},
+					},
 					{
 						name: "external-modules",
 						resolveId(source) {
@@ -424,12 +766,23 @@ export default function serverActions(userOptions = {}) {
 				source: bundledCode,
 			});
 
+			// Generate and emit TypeScript definitions
+			const typeDefinitions = generateTypeDefinitions(serverFunctions, options);
+			this.emitFile({
+				type: "asset",
+				fileName: "actions.d.ts",
+				source: typeDefinitions,
+			});
+
 			// Generate OpenAPI spec if enabled
 			let openAPISpec = null;
 			if (options.openAPI.enabled) {
+				// Use PORT env var for production builds, defaulting to 3000
+				const port = process.env.PORT || 3000;
 				openAPISpec = openAPIGenerator.generateSpec(serverFunctions, schemaDiscovery, {
 					apiPrefix: options.apiPrefix,
 					routeTransform: options.routeTransform,
+					port,
 				});
 
 				// Emit OpenAPI spec as a separate file
@@ -441,7 +794,7 @@ export default function serverActions(userOptions = {}) {
 			}
 
 			// Generate validation code if enabled
-			const validationCode = generateValidationCode(options, serverFunctions);
+			const validationCode = await generateValidationCode(options, serverFunctions);
 
 			// Generate server.js
 			const serverCode = `
@@ -450,6 +803,7 @@ export default function serverActions(userOptions = {}) {
         ${options.openAPI.enabled && options.openAPI.swaggerUI ? "import swaggerUi from 'swagger-ui-express';" : ""}
         ${options.openAPI.enabled ? "import { readFileSync } from 'fs';\nimport { fileURLToPath } from 'url';\nimport { dirname, join } from 'path';\n\nconst __filename = fileURLToPath(import.meta.url);\nconst __dirname = dirname(__filename);\nconst openAPISpec = JSON.parse(readFileSync(join(__dirname, 'openapi.json'), 'utf-8'));" : ""}
         ${validationCode.imports}
+        ${validationCode.validationRuntime}
 
         const app = express();
         ${validationCode.setup}
@@ -474,10 +828,22 @@ export default function serverActions(userOptions = {}) {
             app.post('${options.apiPrefix}/${routePath}', ${middlewareCall}async (req, res) => {
               try {
                 const result = await serverActions.${moduleName}.${functionName}(...req.body);
-                res.json(result || "* No response *");
+                if (result === undefined) {
+                  res.status(204).end();
+                } else {
+                  res.json(result);
+                }
               } catch (error) {
                 console.error(\`Error in ${functionName}: \${error.message}\`);
-                res.status(500).json({ error: error.message });
+                const status = error.status || 500;
+                res.status(status).json({
+                  error: true,
+                  status,
+                  message: status === 500 ? 'Internal server error' : error.message,
+                  code: error.code || 'SERVER_ACTION_ERROR',
+                  timestamp: new Date().toISOString(),
+                  ...(process.env.NODE_ENV !== 'production' ? { details: { message: error.message, stack: error.stack } } : {})
+                });
               }
             });
           `;
@@ -543,24 +909,13 @@ function generateClientProxy(moduleName, functions, options, filePath) {
 
 	let clientProxy = `\n// vite-server-actions: ${moduleName}\n`;
 
-	// Add a guard to prevent direct imports of server code
+	// Mark this as a legitimate client proxy module
 	if (isDev) {
 		clientProxy += `
-// Development-only safety check
+// Development-only marker for client proxy module
 if (typeof window !== 'undefined') {
-  // This code is running in the browser
-  const serverFileError = new Error(
-    '[Vite Server Actions] SECURITY WARNING: Server file "${moduleName}" is being imported in client code! ' +
-    'This could expose server-side code to the browser. Only import server actions through the plugin.'
-  );
-  serverFileError.name = 'ServerCodeInClientError';
-  
-  // Check if we're in a server action proxy context
-  if (!window.__VITE_SERVER_ACTIONS_PROXY__) {
-    console.error(serverFileError);
-    // In development, we'll warn but not throw to avoid breaking HMR
-    console.error('Stack trace:', serverFileError.stack);
-  }
+  window.__VITE_SERVER_ACTIONS_PROXY__ = window.__VITE_SERVER_ACTIONS_PROXY__ || {};
+  window.__VITE_SERVER_ACTIONS_PROXY__['${moduleName}'] = true;
 }
 `;
 	}
@@ -575,11 +930,6 @@ if (typeof window !== 'undefined') {
         ${
 					isDev
 						? `
-        // Development-only: Mark that we're in a valid proxy context
-        if (typeof window !== 'undefined') {
-          window.__VITE_SERVER_ACTIONS_PROXY__ = true;
-        }
-        
         // Validate arguments in development
         if (args.some(arg => typeof arg === 'function')) {
           console.warn(
@@ -615,16 +965,18 @@ if (typeof window !== 'undefined') {
           }
 
           console.log("[Vite Server Actions] ✅ - ${functionName} executed successfully");
+          
+          // Handle 204 No Content responses (function returned undefined)
+          if (response.status === 204) {
+            return undefined;
+          }
+          
           const result = await response.json();
           
           ${
 						isDev
 							? `
-          // Development-only: Clear the proxy context
-          if (typeof window !== 'undefined') {
-            window.__VITE_SERVER_ACTIONS_PROXY__ = false;
-          }
-          `
+`
 							: ""
 					}
           
@@ -636,11 +988,7 @@ if (typeof window !== 'undefined') {
           ${
 						isDev
 							? `
-          // Development-only: Clear the proxy context on error
-          if (typeof window !== 'undefined') {
-            window.__VITE_SERVER_ACTIONS_PROXY__ = false;
-          }
-          `
+`
 							: ""
 					}