refactor(static-config): use specific oxc_* crates and add README

Replace umbrella `oxc` dependency with `oxc_ast`, `oxc_parser`, and
`oxc_span` for more precise dependency tracking. Add README documenting
supported patterns, config resolution order, return type semantics, and
limitations.

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

Author: branchseer

Cargo.lock

@@ -211,7 +211,10 @@ oxc = { version = "0.115.0", features = [
   "cfg",
 ] }
 oxc_allocator = { version = "0.115.0", features = ["pool"] }
+oxc_ast = "0.115.0"
 oxc_ecmascript = "0.115.0"
+oxc_parser = "0.115.0"
+oxc_span = "0.115.0"
 oxc_napi = "0.115.0"
 oxc_minify_napi = "0.115.0"
 oxc_parser_napi = "0.115.0"

Cargo.toml

@@ -8,8 +8,10 @@ license.workspace = true
 repository.workspace = true
 
 [dependencies]
-oxc = { workspace = true }
 oxc_allocator = { workspace = true }
+oxc_ast = { workspace = true }
+oxc_parser = { workspace = true }
+oxc_span = { workspace = true }
 rustc-hash = { workspace = true }
 serde_json = { workspace = true }
 vite_path = { workspace = true }

crates/vite_static_config/Cargo.toml

@@ -0,0 +1,56 @@
+# vite_static_config
+
+Statically extracts configuration from `vite.config.*` files without executing JavaScript.
+
+## What it does
+
+Parses vite config files using [oxc_parser](https://crates.io/crates/oxc_parser) and extracts
+top-level fields whose values are pure JSON literals. This allows reading config like `run`
+without needing a Node.js runtime (NAPI).
+
+## Supported patterns
+
+**ESM:**
+```js
+export default { run: { tasks: { build: { command: "echo build" } } } }
+export default defineConfig({ run: { cacheScripts: true } })
+```
+
+**CJS:**
+```js
+module.exports = { run: { tasks: { build: { command: "echo build" } } } }
+module.exports = defineConfig({ run: { cacheScripts: true } })
+```
+
+## Config file resolution
+
+Searches for config files in the same order as Vite's
+[`DEFAULT_CONFIG_FILES`](https://github.com/vitejs/vite/blob/25227bbdc7de0ed07cf7bdc9a1a733e3a9a132bc/packages/vite/src/node/constants.ts#L98-L105):
+
+1. `vite.config.js`
+2. `vite.config.mjs`
+3. `vite.config.ts`
+4. `vite.config.cjs`
+5. `vite.config.mts`
+6. `vite.config.cts`
+
+## Return type
+
+`resolve_static_config` returns `Option<FxHashMap<Box<str>, StaticFieldValue>>`:
+
+- **`None`** — config is not statically analyzable (no config file, parse error, no
+  `export default`/`module.exports`, or the exported value is not an object literal).
+  Caller should fall back to runtime evaluation (e.g. NAPI).
+- **`Some(map)`** — config object was successfully located:
+  - `StaticFieldValue::Json(value)` — field value extracted as pure JSON
+  - `StaticFieldValue::NonStatic` — field exists but contains non-JSON expressions
+    (function calls, variables, template literals with interpolation, etc.)
+  - Key absent — field does not exist in the config object
+
+## Limitations
+
+- Only extracts values that are pure JSON literals (strings, numbers, booleans, null,
+  arrays, and objects composed of these)
+- Fields with dynamic values (function calls, variable references, spread operators,
+  computed properties, template literals with expressions) are reported as `NonStatic`
+- Does not follow imports or evaluate expressions

crates/vite_static_config/README.md

@@ -4,12 +4,10 @@
 //! top-level fields whose values are pure JSON literals. This allows reading
 //! config like `run` without needing a Node.js runtime.
 
-use oxc::{
-    ast::ast::{Expression, ObjectPropertyKind, Program, Statement},
-    parser::Parser,
-    span::SourceType,
-};
 use oxc_allocator::Allocator;
+use oxc_ast::ast::{Expression, ObjectPropertyKind, Program, Statement};
+use oxc_parser::Parser;
+use oxc_span::SourceType;
 use rustc_hash::FxHashMap;
 use vite_path::AbsolutePath;
 
@@ -171,7 +169,7 @@ fn extract_config_from_expr(expr: &Expression<'_>) -> StaticConfig {
 /// [`StaticFieldValue::NonStatic`]. Spread elements and computed properties
 /// are not representable so they are silently skipped (their keys are unknown).
 fn extract_object_fields(
-    obj: &oxc::ast::ast::ObjectExpression<'_>,
+    obj: &oxc_ast::ast::ObjectExpression<'_>,
 ) -> FxHashMap<Box<str>, StaticFieldValue> {
     let mut map = FxHashMap::default();
 
@@ -236,7 +234,7 @@ fn expr_to_json(expr: &Expression<'_>) -> Option<serde_json::Value> {
 
         Expression::UnaryExpression(unary) => {
             // Handle negative numbers: -42
-            if unary.operator == oxc::ast::ast::UnaryOperator::UnaryNegation
+            if unary.operator == oxc_ast::ast::UnaryOperator::UnaryNegation
                 && let Expression::NumericLiteral(lit) = &unary.argument
             {
                 return Some(f64_to_json_number(-lit.value));