feat(static-config): support defineConfig(fn) and skip NAPI when no config file

Two improvements to static config extraction:

1. When no vite.config.* file exists in a workspace package, return
   immediately instead of falling through to the NAPI/JS callback.
   This eliminates ~165ms cold Node.js init + ~3ms/pkg warm overhead
   for monorepo packages without config files.

2. Support defineConfig(fn) where fn is an arrow function or function
   expression. The extractor now locates the return expression inside
   the function body and extracts fields from it. This handles configs
   like `defineConfig(({ mode }) => { return { run: {...} }; })`.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: branchseer

crates/vite_static_config/src/lib.rs

@@ -49,6 +49,12 @@ const CONFIG_FILE_NAMES: &[&str] = &[
     "vite.config.cts",
 ];
 
+/// Check whether any vite config file exists in the given directory.
+#[must_use]
+pub fn has_config_file(dir: &AbsolutePath) -> bool {
+    resolve_config_path(dir).is_some()
+}
+
 /// Resolve the vite config file path in the given directory.
 ///
 /// Tries each config file name in priority order and returns the first one that exists.
@@ -139,6 +145,9 @@ fn extract_config_fields(program: &Program<'_>) -> StaticConfig {
 
 /// Extract the config object from an expression that is either:
 /// - `defineConfig({ ... })` → extract the object argument
+/// - `defineConfig(() => ({ ... }))` → extract from arrow function expression body
+/// - `defineConfig(() => { return { ... }; })` → extract from return statement
+/// - `defineConfig(function() { return { ... }; })` → extract from return statement
 /// - `{ ... }` → extract directly
 /// - anything else → not analyzable
 fn extract_config_from_expr(expr: &Expression<'_>) -> StaticConfig {
@@ -148,18 +157,54 @@ fn extract_config_from_expr(expr: &Expression<'_>) -> StaticConfig {
             if !call.callee.is_specific_id("defineConfig") {
                 return None;
             }
-            if let Some(first_arg) = call.arguments.first()
-                && let Some(Expression::ObjectExpression(obj)) = first_arg.as_expression()
-            {
-                return Some(extract_object_fields(obj));
+            let first_arg = call.arguments.first()?;
+            let first_arg_expr = first_arg.as_expression()?;
+            match first_arg_expr {
+                Expression::ObjectExpression(obj) => Some(extract_object_fields(obj)),
+                Expression::ArrowFunctionExpression(arrow) => {
+                    extract_config_from_function_body(&arrow.body)
+                }
+                Expression::FunctionExpression(func) => {
+                    extract_config_from_function_body(func.body.as_ref()?)
+                }
+                _ => None,
             }
-            None
         }
         Expression::ObjectExpression(obj) => Some(extract_object_fields(obj)),
         _ => None,
     }
 }
 
+/// Extract the config object from the body of a function passed to `defineConfig`.
+///
+/// Handles two patterns:
+/// - Concise arrow body: `() => ({ ... })` — body has a single `ExpressionStatement`
+/// - Block body: `() => { ... return { ... }; }` — find top-level `ReturnStatement`
+fn extract_config_from_function_body(body: &oxc_ast::ast::FunctionBody<'_>) -> StaticConfig {
+    for stmt in &body.statements {
+        match stmt {
+            Statement::ReturnStatement(ret) => {
+                if let Some(arg) = &ret.argument {
+                    if let Expression::ObjectExpression(obj) = arg.without_parentheses() {
+                        return Some(extract_object_fields(obj));
+                    }
+                }
+                return None;
+            }
+            Statement::ExpressionStatement(expr_stmt) => {
+                // Concise arrow: `() => ({ ... })` is represented as ExpressionStatement
+                if let Expression::ObjectExpression(obj) =
+                    expr_stmt.expression.without_parentheses()
+                {
+                    return Some(extract_object_fields(obj));
+                }
+            }
+            _ => {}
+        }
+    }
+    None
+}
+
 /// Extract fields from an object expression, converting each value to JSON.
 /// Fields whose values cannot be represented as pure JSON are recorded as
 /// [`FieldValue::NonStatic`]. Spread elements and computed properties
@@ -720,6 +765,78 @@ mod tests {
         assert_json(&result, "b", serde_json::json!(2));
     }
 
+    // ── defineConfig with function argument ────────────────────────────
+
+    #[test]
+    fn define_config_arrow_block_body() {
+        let result = parse(
+            r"
+            export default defineConfig(({ mode }) => {
+                const env = loadEnv(mode, process.cwd(), '');
+                return {
+                    run: { cacheScripts: true },
+                    plugins: [vue()],
+                };
+            });
+            ",
+        );
+        assert_json(&result, "run", serde_json::json!({ "cacheScripts": true }));
+        assert_non_static(&result, "plugins");
+    }
+
+    #[test]
+    fn define_config_arrow_expression_body() {
+        let result = parse(
+            r"
+            export default defineConfig(() => ({
+                run: { cacheScripts: true },
+                build: { outDir: 'dist' },
+            }));
+            ",
+        );
+        assert_json(&result, "run", serde_json::json!({ "cacheScripts": true }));
+        assert_json(&result, "build", serde_json::json!({ "outDir": "dist" }));
+    }
+
+    #[test]
+    fn define_config_function_expression() {
+        let result = parse(
+            r"
+            export default defineConfig(function() {
+                return {
+                    run: { cacheScripts: true },
+                    plugins: [react()],
+                };
+            });
+            ",
+        );
+        assert_json(&result, "run", serde_json::json!({ "cacheScripts": true }));
+        assert_non_static(&result, "plugins");
+    }
+
+    #[test]
+    fn define_config_arrow_no_return_object() {
+        // Arrow function that doesn't return an object literal
+        assert!(parse_js_ts_config(
+            r"
+            export default defineConfig(({ mode }) => {
+                return someFunction();
+            });
+            ",
+            "ts",
+        )
+        .is_none());
+    }
+
+    #[test]
+    fn define_config_arrow_empty_body() {
+        assert!(parse_js_ts_config(
+            "export default defineConfig(() => {});",
+            "ts",
+        )
+        .is_none());
+    }
+
     // ── Not analyzable cases (return None) ──────────────────────────────
 
     #[test]

packages/cli/binding/src/cli.rs

@@ -680,6 +680,11 @@ impl UserConfigLoader for VitePlusConfigLoader {
             }
         }
 
+        // If no config file exists, there's nothing for NAPI to evaluate either
+        if !vite_static_config::has_config_file(package_path) {
+            return Ok(None);
+        }
+
         // Fall back to NAPI-based config resolution
         let package_path_str = package_path
             .as_path()