fallow_core/plugins/

config_parser.rs

//! AST-based config file parser utilities.
//!
//! Helpers for statically extracting config values from JS/TS files.

use std::path::{Path, PathBuf};

use fallow_extract::{JsText, visitor::extract_import_from_callable};
#[allow(clippy::wildcard_imports, reason = "many AST types used")]
use oxc_ast::ast::*;
use oxc_ast_visit::{Visit, walk};
use oxc_span::SourceType;
use rustc_hash::FxHashSet;

#[path = "config_parser_vite_plugin_call.rs"]
mod vite_plugin_call;
pub(crate) use vite_plugin_call::extract_vite_plugin_call_option_path;
use vite_plugin_call::is_plugin_binding_call;

/// Extract all import source specifiers from JS/TS source code.
#[must_use]
pub(crate) fn extract_imports(source: &str, path: &Path) -> Vec<String> {
    extract_from_source(source, path, |program| {
        let mut sources = Vec::new();
        for stmt in &program.body {
            if let Statement::ImportDeclaration(decl) = stmt {
                sources.push(decl.source.value.text().into_owned());
            }
        }
        Some(sources)
    })
    .unwrap_or_default()
}

/// Extract import sources and top-level `require('...')` statements.
#[must_use]
pub(crate) fn extract_imports_and_requires(source: &str, path: &Path) -> Vec<String> {
    extract_from_source(source, path, |program| {
        let mut sources = Vec::new();
        for stmt in &program.body {
            match stmt {
                Statement::ImportDeclaration(decl) => {
                    sources.push(decl.source.value.text().into_owned());
                }
                Statement::ExpressionStatement(expr) => {
                    if let Expression::CallExpression(call) = &expr.expression
                        && is_require_call(call)
                        && let Some(s) = get_require_source(call)
                    {
                        sources.push(s);
                    }
                }
                _ => {}
            }
        }
        Some(sources)
    })
    .unwrap_or_default()
}

/// Extract string array from a property at a nested path in a config's default export.
#[must_use]
pub(crate) fn extract_config_string_array(
    source: &str,
    path: &Path,
    prop_path: &[&str],
) -> Vec<String> {
    extract_from_source(source, path, |program| {
        let obj = find_config_object(program)?;
        get_nested_string_array_from_object(obj, prop_path)
    })
    .unwrap_or_default()
}

/// Extract a single string from a property at a nested path.
#[must_use]
pub(crate) fn extract_config_string(
    source: &str,
    path: &Path,
    prop_path: &[&str],
) -> Option<String> {
    extract_from_source(source, path, |program| {
        let obj = find_config_object(program)?;
        get_nested_string_from_object(obj, prop_path)
    })
}

/// Extract a shell command string from a property at a nested path.
#[must_use]
pub(crate) fn extract_config_command(
    source: &str,
    path: &Path,
    prop_path: &[&str],
) -> Option<String> {
    extract_from_source(source, path, |program| {
        let obj = find_config_object(program)?;
        get_nested_command_from_object(obj, prop_path)
    })
}

/// Extract string values from top-level properties of the default export or
/// `module.exports` object.
#[must_use]
pub(crate) fn extract_config_property_strings(source: &str, path: &Path, key: &str) -> Vec<String> {
    extract_from_source(source, path, |program| {
        let obj = find_config_object(program)?;
        let mut values = Vec::new();
        if let Some(prop) = find_property(obj, key) {
            collect_all_string_values(&prop.value, &mut values);
        }
        Some(values)
    })
    .unwrap_or_default()
}

/// Extract only top-level string values from a property's array.
#[must_use]
pub(crate) fn extract_config_shallow_strings(source: &str, path: &Path, key: &str) -> Vec<String> {
    extract_from_source(source, path, |program| {
        let obj = find_config_object(program)?;
        let prop = find_property(obj, key)?;
        Some(collect_shallow_string_values(&prop.value))
    })
    .unwrap_or_default()
}

/// Extract top-level string values from a config array, including object entries.
#[must_use]
pub(crate) fn extract_config_shallow_strings_or_object_property(
    source: &str,
    path: &Path,
    key: &str,
    object_property: &str,
) -> Vec<String> {
    extract_from_source(source, path, |program| {
        let obj = find_config_object(program)?;
        let prop = find_property(obj, key)?;
        Some(collect_shallow_string_or_object_property_values(
            &prop.value,
            object_property,
        ))
    })
    .unwrap_or_default()
}

/// Extract shallow strings from an array property inside a nested object path.
#[must_use]
pub(crate) fn extract_config_nested_shallow_strings(
    source: &str,
    path: &Path,
    outer_path: &[&str],
    key: &str,
) -> Vec<String> {
    extract_from_source(source, path, |program| {
        let obj = find_config_object(program)?;
        let nested = get_nested_expression(obj, outer_path)?;
        if let Expression::ObjectExpression(nested_obj) = nested {
            let prop = find_property(nested_obj, key)?;
            Some(collect_shallow_string_values(&prop.value))
        } else {
            None
        }
    })
    .unwrap_or_default()
}

/// Get a top-level property expression from an object.
pub(crate) fn property_expr<'a>(
    obj: &'a ObjectExpression<'a>,
    key: &str,
) -> Option<&'a Expression<'a>> {
    find_property(obj, key).map(|prop| &prop.value)
}

/// Get a top-level property object from an object.
pub(crate) fn property_object<'a>(
    obj: &'a ObjectExpression<'a>,
    key: &str,
) -> Option<&'a ObjectExpression<'a>> {
    property_expr(obj, key).and_then(object_expression)
}

/// Get a string-like top-level property value from an object.
pub(crate) fn property_string(obj: &ObjectExpression<'_>, key: &str) -> Option<String> {
    property_expr(obj, key).and_then(expression_to_string)
}

/// Convert an expression to an object expression when it is statically recoverable.
pub(crate) fn object_expression<'a>(expr: &'a Expression<'a>) -> Option<&'a ObjectExpression<'a>> {
    match expr {
        Expression::ObjectExpression(obj) => Some(obj),
        Expression::ParenthesizedExpression(paren) => object_expression(&paren.expression),
        Expression::TSSatisfiesExpression(ts_sat) => object_expression(&ts_sat.expression),
        Expression::TSAsExpression(ts_as) => object_expression(&ts_as.expression),
        _ => None,
    }
}

/// Convert an expression to an array expression when it is statically recoverable.
pub(crate) fn array_expression<'a>(expr: &'a Expression<'a>) -> Option<&'a ArrayExpression<'a>> {
    match expr {
        Expression::ArrayExpression(arr) => Some(arr),
        Expression::ParenthesizedExpression(paren) => array_expression(&paren.expression),
        Expression::TSSatisfiesExpression(ts_sat) => array_expression(&ts_sat.expression),
        Expression::TSAsExpression(ts_as) => array_expression(&ts_as.expression),
        _ => None,
    }
}

/// Convert a config path string to a `PathBuf` with platform-independent
/// separator handling.
pub(crate) fn path_from_config_string(raw: &str) -> PathBuf {
    PathBuf::from(raw.replace('\\', "/"))
}

/// Convert a config path to the forward-slash string form used in plugin output.
pub(crate) fn path_to_config_string(path: &Path) -> String {
    path.to_string_lossy().replace('\\', "/")
}

/// Convert a path-like expression to a statically recoverable path.
pub(crate) fn expression_to_path(expr: &Expression<'_>) -> Option<PathBuf> {
    expression_to_path_string(expr).map(|path| path_from_config_string(&path))
}

/// Convert a path-like expression to zero or more statically recoverable paths.
pub(crate) fn expression_to_path_values(expr: &Expression<'_>) -> Vec<PathBuf> {
    match expr {
        Expression::ArrayExpression(arr) => arr
            .elements
            .iter()
            .filter_map(|element| element.as_expression().and_then(expression_to_path))
            .collect(),
        _ => expression_to_path(expr).into_iter().collect(),
    }
}

/// True when an expression explicitly disables a config section.
pub(crate) fn is_disabled_expression(expr: &Expression<'_>) -> bool {
    matches!(expr, Expression::BooleanLiteral(boolean) if !boolean.value)
        || matches!(expr, Expression::NullLiteral(_))
}

/// True when a nested config property is a static `true` boolean or object value.
#[must_use]
pub(crate) fn extract_config_truthy_bool_or_object(
    source: &str,
    path: &Path,
    prop_path: &[&str],
) -> bool {
    extract_from_source(source, path, |program| {
        let obj = find_config_object(program)?;
        let expr = get_nested_expression(obj, prop_path)?;
        Some(is_truthy_bool_or_object(expr))
    })
    .unwrap_or(false)
}

fn is_truthy_bool_or_object(expr: &Expression<'_>) -> bool {
    match expr {
        Expression::BooleanLiteral(boolean) => boolean.value,
        Expression::ObjectExpression(_) => true,
        Expression::ParenthesizedExpression(paren) => is_truthy_bool_or_object(&paren.expression),
        Expression::TSSatisfiesExpression(ts_sat) => is_truthy_bool_or_object(&ts_sat.expression),
        Expression::TSAsExpression(ts_as) => is_truthy_bool_or_object(&ts_as.expression),
        _ => false,
    }
}

/// Extract keys of an object property at a nested path.
#[must_use]
pub(crate) fn extract_config_object_keys(
    source: &str,
    path: &Path,
    prop_path: &[&str],
) -> Vec<String> {
    extract_from_source(source, path, |program| {
        let obj = find_config_object(program)?;
        get_nested_object_keys(obj, prop_path)
    })
    .unwrap_or_default()
}

/// Extract a value that may be a single string, string array, or object with
/// string/array values.
#[must_use]
pub(crate) fn extract_config_string_or_array(
    source: &str,
    path: &Path,
    prop_path: &[&str],
) -> Vec<String> {
    extract_from_source(source, path, |program| {
        let obj = find_config_object(program)?;
        get_nested_string_or_array(obj, prop_path, PathScope::Program(program))
    })
    .unwrap_or_default()
}

/// Extract a string, array, or object-map value from each config of a
/// default-exported config array, or from the single config object.
///
/// Supports `export default [...]` and `export default defineConfig([...])`.
/// The function reads `prop_path` from each object element of the array. When
/// the default export is not an array, it reads the config object.
#[must_use]
pub(crate) fn extract_config_array_or_object_string_or_array(
    source: &str,
    path: &Path,
    prop_path: &[&str],
) -> Vec<String> {
    extract_from_source(source, path, |program| {
        let Some(arr) = find_default_export_array(program) else {
            let obj = find_config_object(program)?;
            return get_nested_string_or_array(obj, prop_path, PathScope::Program(program));
        };
        let values = arr
            .elements
            .iter()
            .filter_map(|element| element.as_expression().and_then(object_expression))
            .filter_map(|element_obj| {
                get_nested_string_or_array(element_obj, prop_path, PathScope::Program(program))
            })
            .flatten()
            .collect();
        Some(values)
    })
    .unwrap_or_default()
}

/// Extract a statically recoverable path-like value from a property path.
#[must_use]
pub(crate) fn extract_config_path(
    source: &str,
    path: &Path,
    prop_path: &[&str],
) -> Option<PathBuf> {
    extract_from_source(source, path, |program| {
        let obj = find_config_object(program)?;
        let expr = get_nested_expression(obj, prop_path)?;
        expression_to_path(expr)
    })
}

/// Extract string values from a property path, also searching inside array elements.
#[must_use]
pub(crate) fn extract_config_array_nested_string_or_array(
    source: &str,
    path: &Path,
    array_path: &[&str],
    inner_path: &[&str],
) -> Vec<String> {
    extract_from_source(source, path, |program| {
        let obj = find_config_object(program)?;
        let array_expr = get_nested_expression(obj, array_path)?;
        let Expression::ArrayExpression(arr) = array_expr else {
            return None;
        };
        let mut results = Vec::new();
        for element in &arr.elements {
            if let Some(Expression::ObjectExpression(element_obj)) = element.as_expression()
                && let Some(values) =
                    get_nested_string_or_array(element_obj, inner_path, PathScope::Program(program))
            {
                results.extend(values);
            }
        }
        if results.is_empty() {
            None
        } else {
            Some(results)
        }
    })
    .unwrap_or_default()
}

/// Extract the string values of each key, one entry per object element of an
/// array.
///
/// Each entry holds one value list per key, in the order of `keys`. A missing
/// key gives an empty list. Use this function when values of one element must
/// stay together, for example a `rootDir` and the paths that it anchors.
#[must_use]
pub(crate) fn extract_config_array_object_fields(
    source: &str,
    path: &Path,
    array_path: &[&str],
    keys: &[&str],
) -> Vec<Vec<Vec<String>>> {
    extract_from_source(source, path, |program| {
        let obj = find_config_object(program)?;
        let Expression::ArrayExpression(arr) = get_nested_expression(obj, array_path)? else {
            return None;
        };
        let elements = arr
            .elements
            .iter()
            .filter_map(|element| match element.as_expression() {
                Some(Expression::ObjectExpression(element_obj)) => Some(
                    keys.iter()
                        .map(|key| {
                            get_nested_string_or_array(
                                element_obj,
                                &[key],
                                PathScope::Program(program),
                            )
                            .unwrap_or_default()
                        })
                        .collect(),
                ),
                _ => None,
            })
            .collect();
        Some(elements)
    })
    .unwrap_or_default()
}

/// Extract string values from a property path, searching inside all values of an object.
#[must_use]
pub(crate) fn extract_config_object_nested_string_or_array(
    source: &str,
    path: &Path,
    object_path: &[&str],
    inner_path: &[&str],
) -> Vec<String> {
    extract_config_object_nested(source, path, object_path, |value_obj| {
        get_nested_string_or_array(value_obj, inner_path, PathScope::Bare)
    })
}

/// Extract a single string value from each object under a property path.
#[must_use]
pub(crate) fn extract_config_object_nested_strings(
    source: &str,
    path: &Path,
    object_path: &[&str],
    inner_path: &[&str],
) -> Vec<String> {
    extract_config_object_nested(source, path, object_path, |value_obj| {
        get_nested_string_from_object(value_obj, inner_path).map(|s| vec![s])
    })
}

/// Shared helper for object-nested extraction.
fn extract_config_object_nested(
    source: &str,
    path: &Path,
    object_path: &[&str],
    extract_fn: impl Fn(&ObjectExpression<'_>) -> Option<Vec<String>> + Sync,
) -> Vec<String> {
    extract_from_source(source, path, |program| {
        let obj = find_config_object(program)?;
        let obj_expr = get_nested_expression(obj, object_path)?;
        let Expression::ObjectExpression(target_obj) = obj_expr else {
            return None;
        };
        let mut results = Vec::new();
        for prop in &target_obj.properties {
            if let ObjectPropertyKind::ObjectProperty(p) = prop
                && let Expression::ObjectExpression(value_obj) = &p.value
                && let Some(values) = extract_fn(value_obj)
            {
                results.extend(values);
            }
        }
        if results.is_empty() {
            None
        } else {
            Some(results)
        }
    })
    .unwrap_or_default()
}

/// Extract `require('...')` call argument strings from a property's value.
#[must_use]
pub(crate) fn extract_config_require_strings(source: &str, path: &Path, key: &str) -> Vec<String> {
    extract_from_source(source, path, |program| {
        let obj = find_config_object(program)?;
        let prop = find_property(obj, key)?;
        Some(collect_require_sources(&prop.value))
    })
    .unwrap_or_default()
}

/// Extract alias mappings from an object or array-based alias config.
#[must_use]
pub(crate) fn extract_config_aliases(
    source: &str,
    path: &Path,
    prop_path: &[&str],
) -> Vec<(String, String)> {
    extract_config_aliases_kinded(source, path, prop_path)
        .into_iter()
        .map(|(find, replacement, _is_bare)| (find, replacement))
        .collect()
}

/// Extract alias mappings where the replacement is a filesystem path value.
#[must_use]
pub(crate) fn extract_config_path_aliases(
    source: &str,
    path: &Path,
    prop_path: &[&str],
) -> Vec<(String, PathBuf)> {
    extract_config_aliases_kinded(source, path, prop_path)
        .into_iter()
        .map(|(find, replacement, _is_bare)| (find, path_from_config_string(&replacement)))
        .collect()
}

/// Like [`extract_config_aliases`] but each tuple carries a bare-string flag.
#[must_use]
pub(crate) fn extract_config_aliases_kinded(
    source: &str,
    path: &Path,
    prop_path: &[&str],
) -> Vec<(String, String, bool)> {
    extract_from_source(source, path, |program| {
        let obj = find_config_object(program)?;
        let expr = get_nested_expression(obj, prop_path)?;
        let mut visited = FxHashSet::default();
        let aliases = resolve_alias_pairs_kinded(program, path, expr, &mut visited, 0);
        (!aliases.is_empty()).then_some(aliases)
    })
    .unwrap_or_default()
}

/// Extract kinded alias mappings nested inside an array of config objects.
///
/// Each tuple has the same shape as in [`extract_config_aliases_kinded`].
#[must_use]
pub(crate) fn extract_config_array_nested_aliases_kinded(
    source: &str,
    path: &Path,
    array_path: &[&str],
    alias_path: &[&str],
) -> Vec<(String, String, bool)> {
    extract_from_source(source, path, |program| {
        let obj = find_config_object(program)?;
        let array_expr = get_nested_expression(obj, array_path)?;
        let Expression::ArrayExpression(arr) = array_expr else {
            return None;
        };
        let mut results = Vec::new();
        for element in &arr.elements {
            if let Some(Expression::ObjectExpression(element_obj)) = element.as_expression()
                && let Some(alias_expr) = get_nested_expression(element_obj, alias_path)
            {
                results.extend(expression_to_alias_pairs_kinded(alias_expr));
            }
        }
        (!results.is_empty()).then_some(results)
    })
    .unwrap_or_default()
}

/// Extract kinded aliases from a default-exported ARRAY config.
#[must_use]
pub(crate) fn extract_default_export_array_aliases_kinded(
    source: &str,
    path: &Path,
    alias_path: &[&str],
) -> Vec<(String, String, bool)> {
    extract_from_source(source, path, |program| {
        let arr = find_default_export_array(program)?;
        let mut results = Vec::new();
        for element in &arr.elements {
            if let Some(Expression::ObjectExpression(element_obj)) = element.as_expression()
                && let Some(alias_expr) = get_nested_expression(element_obj, alias_path)
            {
                results.extend(expression_to_alias_pairs_kinded(alias_expr));
            }
        }
        (!results.is_empty()).then_some(results)
    })
    .unwrap_or_default()
}

/// True when a parsed config has neither an object nor array default export.
#[must_use]
pub(crate) fn config_default_export_unreachable(source: &str, path: &Path) -> bool {
    extract_from_source(source, path, |program| {
        let reachable =
            find_config_object(program).is_some() || find_default_export_array(program).is_some();
        Some(reachable)
    })
    .is_some_and(|reachable| !reachable)
}

/// Extract string values from a nested array, supporting both string elements and
/// object elements with a named string/path field.
///
/// Useful for configs like:
/// - `components: ["~/components", { path: "~/feature-components" }]`
#[must_use]
pub(crate) fn extract_config_array_object_strings(
    source: &str,
    path: &Path,
    array_path: &[&str],
    key: &str,
) -> Vec<String> {
    extract_from_source(source, path, |program| {
        let obj = find_config_object(program)?;
        let array_expr = get_nested_expression(obj, array_path)?;
        let Expression::ArrayExpression(arr) = array_expr else {
            return None;
        };

        let mut results = Vec::new();
        for element in &arr.elements {
            let Some(expr) = element.as_expression() else {
                continue;
            };
            match expr {
                Expression::ObjectExpression(item) => {
                    if let Some(prop) = find_property(item, key)
                        && let Some(value) = expression_to_path_string(&prop.value)
                    {
                        results.push(value);
                    }
                }
                _ => {
                    if let Some(value) = expression_to_path_string(expr) {
                        results.push(value);
                    }
                }
            }
        }

        (!results.is_empty()).then_some(results)
    })
    .unwrap_or_default()
}

/// Extract Storybook-style static directory entries from an array.
///
/// Supports string entries and object entries with a string-like `from` plus
/// optional string-like `to`.
#[must_use]
pub(crate) fn extract_config_static_dir_entries(
    source: &str,
    path: &Path,
    array_path: &[&str],
) -> Vec<(String, Option<String>)> {
    extract_from_source(source, path, |program| {
        let obj = find_config_object(program)?;
        let array_expr = get_nested_expression(obj, array_path)?;
        let Expression::ArrayExpression(arr) = array_expr else {
            return None;
        };

        let mut results = Vec::new();
        for element in &arr.elements {
            let Some(expr) = element.as_expression() else {
                continue;
            };
            match expr {
                Expression::ObjectExpression(item) => {
                    if let Some(from) = property_string(item, "from") {
                        let to = property_string(item, "to");
                        results.push((from, to));
                    }
                }
                _ => {
                    if let Some(from) = expression_to_path_string(expr) {
                        results.push((from, None));
                    }
                }
            }
        }

        (!results.is_empty()).then_some(results)
    })
    .unwrap_or_default()
}

/// Extract paired shell command and string values from each object element of an array.
#[must_use]
pub(crate) fn extract_config_array_object_command_pairs(
    source: &str,
    path: &Path,
    array_path: &[&str],
    primary_key: &str,
    secondary_key: &str,
) -> Vec<(String, Option<String>)> {
    extract_from_source(source, path, |program| {
        let obj = find_config_object(program)?;
        let array_expr = get_nested_expression(obj, array_path)?;
        let Expression::ArrayExpression(arr) = array_expr else {
            return None;
        };

        let mut results = Vec::new();
        for element in &arr.elements {
            let Some(Expression::ObjectExpression(item)) = element.as_expression() else {
                continue;
            };
            let Some(primary) = find_property(item, primary_key)
                .and_then(|prop| expression_to_command(&prop.value))
            else {
                continue;
            };
            let secondary = find_property(item, secondary_key)
                .and_then(|prop| expression_to_path_string(&prop.value));
            results.push((primary, secondary));
        }

        (!results.is_empty()).then_some(results)
    })
    .unwrap_or_default()
}

/// Extract static specifiers from thunk-wrapped dynamic imports inside an
/// array property.
///
/// Captures the `SPEC` argument from each `() => import('SPEC')` element of
/// an array nested under `prop_path` in the config's default-exported object.
///
/// # The pattern
///
/// Configs and registries that need to defer module evaluation commonly hold
/// arrays of *thunks* — zero-argument arrow functions whose body is a single
/// dynamic import:
///
/// ```ts
/// export default defineConfig({
///     modules: [
///         () => import('./feature-a'),
///         { file: () => import('./feature-b'), enabled: true },
///     ],
/// })
/// ```
///
/// `import('SPEC')` is the ECMAScript dynamic-import expression (TC39
/// dynamic-import proposal, shipped in ES2020): a runtime module loader call
/// that returns a `Promise<Module>`. Wrapping it in `() => import('SPEC')`
/// turns "load module X now" into "value that, when invoked, loads module X"
/// — a thunk the host can call lazily.
///
/// The technique predates any single framework. It's the same shape used by
/// route-level code-splitting (`Vue Router`, `React Router`, `Next.js`),
/// `React.lazy`, Webpack's documented dynamic-import code-splitting recipes,
/// and any registry that wants to keep boot cheap, break import cycles, or
/// let bundlers tree-shake unused branches. Configs that adopt the pattern
/// can therefore declare large module graphs without forcing eager
/// evaluation of every entry at config parse time.
///
/// # Recognised array element shapes
///
/// - Concise arrow: `() => import('SPEC')`
/// - Block-body arrow with explicit return: `() => { return import('SPEC') }`
/// - Object form with a `file` property holding the arrow:
///   `{ file: () => import('SPEC'), /* peer fields */ }`
///
/// Non-matching elements (string literals, variables, template-string
/// specifiers, computed expressions) are silently skipped: callers receive
/// only the statically-resolvable specifiers, in source order.
#[must_use]
pub(crate) fn extract_lazy_imports_in_array(
    source: &str,
    path: &Path,
    prop_path: &[&str],
) -> Vec<String> {
    extract_from_source(source, path, |program| {
        let obj = find_config_object(program)?;
        let array_expr = get_nested_expression(obj, prop_path)?;
        let Expression::ArrayExpression(arr) = array_expr else {
            return None;
        };
        let mut specs = Vec::new();
        for element in &arr.elements {
            let Some(expr) = element.as_expression() else {
                continue;
            };
            if let Some(spec) = lazy_import_specifier(expr) {
                specs.push(spec);
            }
        }
        (!specs.is_empty()).then_some(specs)
    })
    .unwrap_or_default()
}

/// Read a lazy-import specifier from a single array element expression.
///
/// Two outer shapes are accepted at this level (array-element navigation):
/// - A bare callable: `() => import('SPEC')` or the function-expression
///   equivalent.
/// - An object with a `file` property holding the callable:
///   `{ file: () => import('SPEC'), /* peer fields */ }`.
///
/// The actual callable → import peeling is delegated to
/// [`extract_import_from_callable`], which is shared with the visitor-side
/// dynamic-import helpers so all three navigation pipelines stay in lockstep
/// when ECMAScript adds new wrapper shapes.
fn lazy_import_specifier(expr: &Expression<'_>) -> Option<String> {
    let callable = match expr {
        Expression::ObjectExpression(obj) => &find_property(obj, "file")?.value,
        _ => expr,
    };
    let import_expr = extract_import_from_callable(callable)?;
    expression_to_string(&import_expr.source)
}

/// Extract the first string of each `[name, options]` tuple in an array at a
/// property path, such as `modules: [["@nuxt/content", { ... }]]`. Plain
/// string entries are not returned; read them with
/// [`extract_config_string_array`].
#[must_use]
pub(crate) fn extract_config_array_tuple_heads(
    source: &str,
    path: &Path,
    array_path: &[&str],
) -> Vec<String> {
    extract_from_source(source, path, |program| {
        let obj = find_config_object(program)?;
        let Expression::ArrayExpression(entries) = get_nested_expression(obj, array_path)? else {
            return None;
        };
        let heads = entries
            .elements
            .iter()
            .filter_map(|entry| match entry.as_expression() {
                Some(Expression::ArrayExpression(tuple)) => tuple
                    .elements
                    .first()
                    .and_then(ArrayExpressionElement::as_expression)
                    .and_then(expression_to_string),
                _ => None,
            })
            .collect();
        Some(heads)
    })
    .unwrap_or_default()
}

/// Extract a string-like option from a plugin tuple inside a config plugin array.
///
/// Supports config shapes like:
/// - `{ expo: { plugins: [["expo-router", { root: "src/app" }]] } }`
/// - `export default { expo: { plugins: [["expo-router", { root: "./src/app" }]] } }`
/// - `{ plugins: [["expo-router", { root: "./src/routes" }]] }`
#[must_use]
fn extract_config_plugin_option_string(
    source: &str,
    path: &Path,
    plugins_path: &[&str],
    plugin_name: &str,
    option_key: &str,
) -> Option<String> {
    extract_from_source(source, path, |program| {
        let obj = find_config_object(program)?;
        let plugins_expr = get_nested_expression(obj, plugins_path)?;
        let Expression::ArrayExpression(plugins) = plugins_expr else {
            return None;
        };

        for entry in &plugins.elements {
            let Some(Expression::ArrayExpression(tuple)) = entry.as_expression() else {
                continue;
            };
            let Some(plugin_expr) = tuple
                .elements
                .first()
                .and_then(ArrayExpressionElement::as_expression)
            else {
                continue;
            };
            if expression_to_string(plugin_expr).as_deref() != Some(plugin_name) {
                continue;
            }

            let Some(options_expr) = tuple
                .elements
                .get(1)
                .and_then(ArrayExpressionElement::as_expression)
            else {
                continue;
            };
            let Expression::ObjectExpression(options_obj) = options_expr else {
                continue;
            };
            let option = find_property(options_obj, option_key)?;
            return expression_to_path_string(&option.value);
        }

        None
    })
}

/// Extract a string-like option from the first plugin array path that contains it.
#[must_use]
pub(crate) fn extract_config_plugin_option_string_from_paths(
    source: &str,
    path: &Path,
    plugin_paths: &[&[&str]],
    plugin_name: &str,
    option_key: &str,
) -> Option<String> {
    plugin_paths.iter().find_map(|plugins_path| {
        extract_config_plugin_option_string(source, path, plugins_path, plugin_name, option_key)
    })
}

/// A Vite plugin package whose options object names other packages as strings.
struct VitePluginOptionReader {
    package: &'static str,
    read: fn(&ObjectExpression<'_>, &mut Vec<String>),
}

/// The Vite plugins whose options name packages that the plugin loads at
/// build time. The list is closed so that an unknown plugin option never
/// credits a package.
const VITE_PLUGIN_OPTION_READERS: &[VitePluginOptionReader] = &[
    VitePluginOptionReader {
        package: "@vitejs/plugin-react",
        read: collect_vite_react_babel_dependencies,
    },
    VitePluginOptionReader {
        package: "@vitejs/plugin-react-swc",
        read: collect_vite_react_swc_dependencies,
    },
    VitePluginOptionReader {
        package: "@wyw-in-js/vite",
        read: collect_wyw_babel_options_dependencies,
    },
];

/// How many wrapper calls, such as `profile(wyw({ ... }))`, the reader looks
/// through to find a known plugin call in a `plugins` array entry.
const MAX_VITE_PLUGIN_WRAPPER_DEPTH: usize = 3;

/// Extract package names that known Vite plugins read from their options in a
/// Vite-style `plugins` array: Babel plugins and presets of
/// `@vitejs/plugin-react`, SWC plugins of `@vitejs/plugin-react-swc`, and
/// `babelOptions` of `@wyw-in-js/vite`.
#[must_use]
pub(crate) fn extract_vite_plugin_option_dependencies(source: &str, path: &Path) -> Vec<String> {
    extract_from_source(source, path, |program| {
        let bindings: Vec<(PluginImportBindings, &VitePluginOptionReader)> =
            VITE_PLUGIN_OPTION_READERS
                .iter()
                .map(|reader| {
                    (
                        collect_plugin_import_bindings(program, reader.package),
                        reader,
                    )
                })
                .filter(|(imports, _)| !imports.is_empty())
                .collect();
        if bindings.is_empty() {
            return None;
        }

        let obj = find_config_object(program)?;
        let plugins = get_nested_expression(obj, &["plugins"])?;
        let Expression::ArrayExpression(plugin_array) = plugins else {
            return None;
        };

        let mut deps = Vec::new();
        for element in &plugin_array.elements {
            if let Some(Expression::CallExpression(call)) = element.as_expression() {
                read_vite_plugin_call(call, &bindings, 0, &mut deps);
            }
        }

        (!deps.is_empty()).then_some(deps)
    })
    .unwrap_or_default()
}

fn read_vite_plugin_call(
    call: &CallExpression<'_>,
    bindings: &[(PluginImportBindings, &VitePluginOptionReader)],
    depth: usize,
    deps: &mut Vec<String>,
) {
    if let Some((_, reader)) = bindings
        .iter()
        .find(|(imports, _)| is_plugin_binding_call(call, imports))
    {
        if let Some(Expression::ObjectExpression(options)) =
            call.arguments.first().and_then(Argument::as_expression)
        {
            (reader.read)(options, deps);
        }
        return;
    }
    if depth >= MAX_VITE_PLUGIN_WRAPPER_DEPTH {
        return;
    }
    for argument in &call.arguments {
        if let Some(Expression::CallExpression(inner)) = argument.as_expression() {
            read_vite_plugin_call(inner, bindings, depth + 1, deps);
        }
    }
}

/// The package name that a config string names, such as an SWC plugin in a
/// `[name, options]` tuple. A relative or absolute path, a protocol value, or
/// an invalid specifier names no package. A subpath maps to its package.
#[must_use]
pub(crate) fn config_string_package_name(raw: &str) -> Option<String> {
    let specifier = raw.trim();
    is_package_specifier(specifier).then(|| crate::resolve::extract_package_name(specifier))
}

/// Extract the package names of SWC plugin tuples, such as
/// `swcPlugins: [["@lingui/swc-plugin", {}]]`, at a property path.
#[must_use]
pub(crate) fn extract_config_swc_plugin_dependencies(
    source: &str,
    path: &Path,
    array_path: &[&str],
) -> Vec<String> {
    extract_config_array_tuple_heads(source, path, array_path)
        .iter()
        .filter_map(|raw| config_string_package_name(raw))
        .fold(Vec::new(), |mut deps, dep| {
            push_unique_string(&mut deps, dep);
            deps
        })
}

/// How a config reader reads a path value with a leading `/`.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum LeadingSlash {
    /// Relative to the project root, as Vite reads `/src`.
    RootRelative,
    /// A filesystem path, as webpack and Node read `/src`.
    Filesystem,
}

/// Normalize a config-relative path to a project-root-relative path.
///
/// Handles values extracted from config files such as `"./src"`, `"src/lib"`,
/// `"/src"`, or absolute filesystem paths under `root`. An absolute path under
/// `root` is read as absolute. Any other leading `/` is read as relative to
/// `root`, the same as Vite: this includes the root itself and, when
/// `<root>/<root>` is a directory, every leading-`/` value. Use [`normalize_filesystem_config_path_buf`] for a reader whose tool
/// reads a leading `/` as a filesystem path.
#[must_use]
pub(crate) fn normalize_config_path_buf(
    raw: impl AsRef<Path>,
    config_path: &Path,
    root: &Path,
) -> Option<PathBuf> {
    normalize_path_value(raw.as_ref(), config_path, root, LeadingSlash::RootRelative)
}

/// Normalize a config path value for a reader whose tool reads a leading `/`
/// as a filesystem path, such as webpack. A leading-`/` path outside `root`
/// resolves to `None` (issue #2806).
#[must_use]
pub(crate) fn normalize_filesystem_config_path_buf(
    raw: impl AsRef<Path>,
    config_path: &Path,
    root: &Path,
) -> Option<PathBuf> {
    normalize_path_value(raw.as_ref(), config_path, root, LeadingSlash::Filesystem)
}

fn normalize_path_value(
    raw: &Path,
    config_path: &Path,
    root: &Path,
    leading_slash: LeadingSlash,
) -> Option<PathBuf> {
    if raw.as_os_str().is_empty() {
        return None;
    }

    let raw_string = path_to_config_string(raw);
    let raw_path = Path::new(&raw_string);
    let root_relative_slash =
        leading_slash == LeadingSlash::RootRelative && raw_string.starts_with('/');
    let absolute = raw_path
        .is_absolute()
        .then(|| lexical_normalize(raw_path))
        .filter(|absolute| absolute.starts_with(root))
        .filter(|absolute| !(root_relative_slash && (absolute == root || root_in_root(root))));
    let candidate = if let Some(absolute) = absolute {
        absolute
    } else if let Some(stripped) = raw_string.strip_prefix('/') {
        match leading_slash {
            LeadingSlash::RootRelative => lexical_normalize(&root.join(stripped)),
            LeadingSlash::Filesystem => return None,
        }
    } else if raw_path.is_absolute() {
        return None;
    } else {
        let base = config_path.parent().unwrap_or(root);
        lexical_normalize(&base.join(raw_path))
    };

    let relative = candidate.strip_prefix(root).ok()?;
    (!relative.as_os_str().is_empty()).then(|| relative.to_path_buf())
}

/// Vite's `rootInRoot` rule: when `<root>/<root>` is a directory, Vite reads
/// every leading-`/` value as relative to the root, also one that starts with
/// the root path.
fn root_in_root(root: &Path) -> bool {
    let root_string = path_to_config_string(root);
    let Some(stripped) = root_string.strip_prefix('/') else {
        return false;
    };
    !stripped.is_empty() && root.join(stripped).is_dir()
}

/// [`normalize_filesystem_config_path_buf`] as a project-root-relative
/// forward-slash string.
#[must_use]
pub(crate) fn normalize_filesystem_config_path(
    raw: impl AsRef<Path>,
    config_path: &Path,
    root: &Path,
) -> Option<String> {
    normalize_filesystem_config_path_buf(raw, config_path, root)
        .map(|path| path_to_config_string(&path))
}

/// Normalize a config-relative path to a project-root-relative forward-slash string.
#[must_use]
pub(crate) fn normalize_config_path(
    raw: impl AsRef<Path>,
    config_path: &Path,
    root: &Path,
) -> Option<String> {
    normalize_config_path_buf(raw, config_path, root).map(|path| path_to_config_string(&path))
}

/// A relative config path that climbs out of the plugin root, as a path
/// relative to that root with its leading `../` segments. The path is read
/// relative to the directory of `config_path`.
///
/// A workspace package is read with its own directory as the root, so a path
/// into a sibling workspace climbs out of it while it stays inside the project.
/// The caller registers the result as a parent-relative entry pattern, so the
/// workspace prefix resolves the `../` segments later. A path that climbs out
/// of the project keeps them and matches no project file.
pub(crate) fn parent_relative_config_path(
    target: &str,
    config_path: &Path,
    root: &Path,
) -> Option<String> {
    if !target.starts_with("../") {
        return None;
    }
    let directory = config_path.parent().unwrap_or(root);
    let candidate = lexical_normalize(&directory.join(target));
    let root = lexical_normalize(root);
    let mut ancestor = root.as_path();
    let mut climbs = 0;
    while !candidate.starts_with(ancestor) {
        ancestor = ancestor.parent()?;
        climbs += 1;
    }
    let rest = candidate.strip_prefix(ancestor).ok()?;
    (climbs > 0 && !rest.as_os_str().is_empty())
        .then(|| format!("{}{}", "../".repeat(climbs), path_to_config_string(rest)))
}

/// Parse source and run an extraction function on the AST.
///
/// JSON files (`.json`, `.jsonc`) are parsed as JavaScript expressions wrapped in
/// parentheses to produce an AST compatible with `find_config_object`. The native
/// JSON source type in Oxc produces a different AST structure that our helpers
/// don't handle.
pub(crate) fn extract_from_source<T: Send>(
    source: &str,
    path: &Path,
    extractor: impl FnOnce(&Program) -> Option<T> + Send,
) -> Option<T> {
    let is_json = path
        .extension()
        .is_some_and(|ext| ext == "json" || ext == "jsonc");
    let walk = |parsed: &oxc_parser::ParserReturn<'_>| extractor(&parsed.program);
    if is_json {
        let wrapped = wrap_json_as_expression(source);
        return fallow_extract::parse_bounded_or_default(&wrapped, SourceType::mjs(), walk);
    }
    let source_type = SourceType::from_path(path).unwrap_or_default();
    fallow_extract::parse_bounded_or_default(source, source_type, walk)
}

/// Wrap JSON or JSONC source in parentheses so Oxc parses it as one JavaScript
/// expression. The newline ends a trailing `//` comment, so the comment cannot
/// hide the closing parenthesis.
pub(crate) fn wrap_json_as_expression(source: &str) -> String {
    format!("({source}\n)")
}

/// The local names that `import` declarations bind to the default export of
/// one plugin package.
#[derive(Default)]
struct PluginImportBindings {
    callables: Vec<String>,
    namespaces: Vec<String>,
}

impl PluginImportBindings {
    fn is_empty(&self) -> bool {
        self.callables.is_empty() && self.namespaces.is_empty()
    }
}

fn collect_plugin_import_bindings(program: &Program<'_>, package: &str) -> PluginImportBindings {
    let mut imports = PluginImportBindings::default();

    for stmt in &program.body {
        let Statement::ImportDeclaration(decl) = stmt else {
            continue;
        };
        if decl.source.value != package {
            continue;
        }
        let Some(specifiers) = &decl.specifiers else {
            continue;
        };
        for specifier in specifiers {
            match specifier {
                ImportDeclarationSpecifier::ImportDefaultSpecifier(specifier) => {
                    push_unique_string(&mut imports.callables, specifier.local.name.to_string());
                }
                ImportDeclarationSpecifier::ImportSpecifier(specifier)
                    if specifier.imported.name().as_ref() == "default" =>
                {
                    push_unique_string(&mut imports.callables, specifier.local.name.to_string());
                }
                ImportDeclarationSpecifier::ImportNamespaceSpecifier(specifier) => {
                    push_unique_string(&mut imports.namespaces, specifier.local.name.to_string());
                }
                ImportDeclarationSpecifier::ImportSpecifier(_) => {}
            }
        }
    }

    imports
}

fn collect_vite_react_babel_dependencies(options: &ObjectExpression<'_>, deps: &mut Vec<String>) {
    if let Some(babel) = property_object(options, "babel") {
        collect_babel_plugin_and_preset_dependencies(babel, deps);
    }
}

/// `@wyw-in-js/vite` passes `babelOptions` to Babel, which loads each named
/// plugin and preset.
fn collect_wyw_babel_options_dependencies(options: &ObjectExpression<'_>, deps: &mut Vec<String>) {
    if let Some(babel) = property_object(options, "babelOptions") {
        collect_babel_plugin_and_preset_dependencies(babel, deps);
    }
}

/// `@vitejs/plugin-react-swc` passes `plugins` to SWC, which loads the package
/// at the head of each `[name, options]` tuple.
fn collect_vite_react_swc_dependencies(options: &ObjectExpression<'_>, deps: &mut Vec<String>) {
    let Some(prop) = find_property(options, "plugins") else {
        return;
    };
    let Expression::ArrayExpression(plugins) = &prop.value else {
        return;
    };
    for entry in &plugins.elements {
        let Some(Expression::ArrayExpression(tuple)) = entry.as_expression() else {
            continue;
        };
        if let Some(dep) = tuple
            .elements
            .first()
            .and_then(ArrayExpressionElement::as_expression)
            .and_then(expression_to_string)
            .and_then(|raw| config_string_package_name(&raw))
        {
            push_unique_string(deps, dep);
        }
    }
}

fn collect_babel_plugin_and_preset_dependencies(
    babel: &ObjectExpression<'_>,
    deps: &mut Vec<String>,
) {
    for key in ["plugins", "presets"] {
        let Some(prop) = find_property(babel, key) else {
            continue;
        };
        for raw in collect_shallow_string_values(&prop.value) {
            if let Some(dep) = vite_react_babel_dependency_name(&raw) {
                push_unique_string(deps, dep);
            }
        }
    }
}

fn vite_react_babel_dependency_name(raw: &str) -> Option<String> {
    let raw = raw.trim();
    let specifier = raw.strip_prefix("module:").unwrap_or(raw).trim();
    if specifier.is_empty()
        || specifier.starts_with('.')
        || specifier.starts_with('/')
        || specifier.contains(':')
        || specifier.contains('\\')
    {
        return None;
    }
    Some(crate::resolve::extract_package_name(specifier))
}

fn push_unique_string(items: &mut Vec<String>, value: String) {
    if !items.contains(&value) {
        items.push(value);
    }
}

/// Find the "config object": the object expression in the default export or module.exports.
///
/// Handles these patterns:
/// - `export default { ... }`
/// - `export default defineConfig({ ... })`
/// - `export default defineConfig(async () => ({ ... }))`
/// - `export default { ... } satisfies Config` / `export default { ... } as Config`
/// - `const config = { ... }; export default config;`
/// - `const config: Config = { ... }; export default config;`
/// - `module.exports = { ... }`
/// - Top-level JSON object (for .json files)
pub(crate) fn find_config_object<'a>(program: &'a Program) -> Option<&'a ObjectExpression<'a>> {
    for stmt in &program.body {
        match stmt {
            Statement::ExportDefaultDeclaration(decl) => {
                let expr: Option<&Expression> = match &decl.declaration {
                    ExportDefaultDeclarationKind::ObjectExpression(obj) => {
                        return Some(obj);
                    }
                    ExportDefaultDeclarationKind::FunctionDeclaration(func) => {
                        return extract_object_from_function(func);
                    }
                    _ => decl.declaration.as_expression(),
                };
                if let Some(expr) = expr {
                    if let Some(obj) =
                        resolve_call_config_object(program, expr, MAX_CONFIG_WRAPPER_DEPTH)
                    {
                        return Some(obj);
                    }
                    if let Some(obj) = extract_object_from_expression(expr) {
                        return Some(obj);
                    }
                    if let Some(name) = unwrap_to_identifier_name(expr) {
                        return find_variable_init_object(program, name);
                    }
                    if let Some(obj) = resolve_wrapped_config_object(program, expr) {
                        return Some(obj);
                    }
                }
            }
            Statement::ExpressionStatement(expr_stmt) => {
                if let Expression::AssignmentExpression(assign) = &expr_stmt.expression
                    && is_module_exports_target(&assign.left)
                {
                    if let Some(obj) =
                        resolve_call_config_object(program, &assign.right, MAX_CONFIG_WRAPPER_DEPTH)
                    {
                        return Some(obj);
                    }
                    if let Some(obj) = extract_object_from_expression(&assign.right) {
                        return Some(obj);
                    }
                    if let Some(name) = unwrap_to_identifier_name(&assign.right) {
                        return find_variable_init_object(program, name);
                    }
                    return resolve_wrapped_config_object(program, &assign.right);
                }
            }
            _ => {}
        }
    }

    if program.body.len() == 1
        && let Statement::ExpressionStatement(expr_stmt) = &program.body[0]
    {
        match &expr_stmt.expression {
            Expression::ObjectExpression(obj) => return Some(obj),
            Expression::ParenthesizedExpression(paren) => {
                if let Expression::ObjectExpression(obj) = &paren.expression {
                    return Some(obj);
                }
            }
            _ => {}
        }
    }

    None
}

/// Extract an `ObjectExpression` from an expression, handling wrapper patterns.
pub(crate) fn extract_object_from_expression<'a>(
    expr: &'a Expression<'a>,
) -> Option<&'a ObjectExpression<'a>> {
    match expr {
        Expression::ObjectExpression(obj) => Some(obj),
        Expression::CallExpression(call) => {
            for arg in &call.arguments {
                match arg {
                    Argument::ObjectExpression(obj) => return Some(obj),
                    // Both arrow forms reach here: the concise
                    // `defineConfig(() => ({ ... }))` and the block body
                    // `defineConfig(({ mode }) => { ...; return { ... }; })`.
                    // The block form is the common shape for configs that
                    // branch on the mode, and handling only the concise one
                    // made every such config invisible to extraction.
                    Argument::ArrowFunctionExpression(arrow) => {
                        if let Some(obj) = extract_object_from_arrow_function(arrow) {
                            return Some(obj);
                        }
                    }
                    Argument::FunctionExpression(func) => {
                        if let Some(obj) = extract_object_from_function(func) {
                            return Some(obj);
                        }
                    }
                    _ => {}
                }
            }
            None
        }
        Expression::ParenthesizedExpression(paren) => {
            extract_object_from_expression(&paren.expression)
        }
        Expression::TSSatisfiesExpression(ts_sat) => {
            extract_object_from_expression(&ts_sat.expression)
        }
        Expression::TSAsExpression(ts_as) => extract_object_from_expression(&ts_as.expression),
        Expression::ArrowFunctionExpression(arrow) => extract_object_from_arrow_function(arrow),
        Expression::FunctionExpression(func) => extract_object_from_function(func),
        _ => None,
    }
}

fn extract_object_from_arrow_function<'a>(
    arrow: &'a ArrowFunctionExpression<'a>,
) -> Option<&'a ObjectExpression<'a>> {
    match &arrow.body {
        ArrowFunctionBody::FunctionBody(body) => extract_object_from_function_body(body),
        body => body
            .as_expression()
            .and_then(extract_object_from_expression),
    }
}

fn extract_object_from_function<'a>(func: &'a Function<'a>) -> Option<&'a ObjectExpression<'a>> {
    func.body
        .as_ref()
        .and_then(|body| extract_object_from_function_body(body))
}

/// Resolve the object a config callback returns.
///
/// A return at the body's own level is the callback's main config and always
/// wins, which keeps the overwhelmingly common `guard clause; return { ... }`
/// shape resolving to the real config rather than to the guard's early return.
/// Only a body with no top-level return falls back to searching branches, which
/// is the shape Vite documents for switching config by command:
/// `if (command === "serve") { return { ... } } else { return { ... } }`.
fn extract_object_from_function_body<'a>(
    body: &'a FunctionBody<'a>,
) -> Option<&'a ObjectExpression<'a>> {
    find_top_level_returned_object(&body.statements)
        .or_else(|| find_returned_object(&body.statements, MAX_CONFIG_BRANCH_DEPTH))
}

/// Maximum control-flow nesting searched for a config `return`.
const MAX_CONFIG_BRANCH_DEPTH: u8 = 4;

/// Find the first object returned by a statement at this exact level.
fn find_top_level_returned_object<'a>(
    statements: &'a [Statement<'a>],
) -> Option<&'a ObjectExpression<'a>> {
    statements.iter().find_map(|stmt| match stmt {
        Statement::ReturnStatement(ret) => ret
            .argument
            .as_ref()
            .and_then(|argument| extract_object_from_expression(argument)),
        _ => None,
    })
}

/// Find the first returned object literal in `statements`, descending into
/// control flow.
///
/// Nested function and arrow bodies are deliberately not searched: their returns
/// belong to the inner function, not to the config callback.
///
/// The first return in source order wins. A config whose branches declare
/// different values therefore contributes only the first branch's.
fn find_returned_object<'a>(
    statements: &'a [Statement<'a>],
    depth: u8,
) -> Option<&'a ObjectExpression<'a>> {
    if depth == 0 {
        return None;
    }
    for stmt in statements {
        let found = match stmt {
            Statement::ReturnStatement(ret) => ret
                .argument
                .as_ref()
                .and_then(|argument| extract_object_from_expression(argument)),
            Statement::BlockStatement(block) => find_returned_object(&block.body, depth - 1),
            Statement::IfStatement(if_stmt) => {
                find_returned_object_in_statement(&if_stmt.consequent, depth - 1).or_else(|| {
                    if_stmt
                        .alternate
                        .as_ref()
                        .and_then(|alt| find_returned_object_in_statement(alt, depth - 1))
                })
            }
            Statement::TryStatement(try_stmt) => {
                find_returned_object(&try_stmt.block.body, depth - 1)
                    .or_else(|| {
                        try_stmt
                            .handler
                            .as_ref()
                            .and_then(|handler| find_returned_object(&handler.body.body, depth - 1))
                    })
                    .or_else(|| {
                        try_stmt
                            .finalizer
                            .as_ref()
                            .and_then(|finalizer| find_returned_object(&finalizer.body, depth - 1))
                    })
            }
            Statement::SwitchStatement(switch) => switch
                .cases
                .iter()
                .find_map(|case| find_returned_object(&case.consequent, depth - 1)),
            _ => None,
        };
        if found.is_some() {
            return found;
        }
    }
    None
}

fn find_returned_object_in_statement<'a>(
    stmt: &'a Statement<'a>,
    depth: u8,
) -> Option<&'a ObjectExpression<'a>> {
    match stmt {
        Statement::BlockStatement(block) => find_returned_object(&block.body, depth),
        other => find_returned_object(std::slice::from_ref(other), depth),
    }
}

/// Check if an assignment target is `module.exports`.
fn is_module_exports_target(target: &AssignmentTarget) -> bool {
    if let AssignmentTarget::StaticMemberExpression(member) = target
        && let Expression::Identifier(obj) = &member.object
    {
        return obj.name == "module" && member.property.name == "exports";
    }
    false
}

/// Unwrap TS annotations and return the identifier name if the expression resolves to one.
///
/// Handles `config`, `config satisfies Type`, `config as Type`.
fn unwrap_to_identifier_name<'a>(expr: &'a Expression<'a>) -> Option<&'a str> {
    match expr {
        Expression::Identifier(id) => Some(&id.name),
        Expression::TSSatisfiesExpression(ts_sat) => unwrap_to_identifier_name(&ts_sat.expression),
        Expression::TSAsExpression(ts_as) => unwrap_to_identifier_name(&ts_as.expression),
        _ => None,
    }
}

/// Find a top-level variable declaration by name and extract its init as an object expression.
///
/// Handles `const config = { ... }`, `const config: Type = { ... }`,
/// and `const config = defineConfig({ ... })`.
pub(crate) fn find_variable_init_object<'a>(
    program: &'a Program,
    name: &str,
) -> Option<&'a ObjectExpression<'a>> {
    for decl in top_level_variable_declarations(program) {
        for declarator in &decl.declarations {
            if let BindingPattern::BindingIdentifier(id) = &declarator.id
                && id.name == name
                && let Some(init) = &declarator.init
            {
                return extract_object_from_expression(init);
            }
        }
    }
    None
}

/// The init expression of the first top-level variable declaration of `name`.
fn find_variable_init<'a>(program: &'a Program<'a>, name: &str) -> Option<&'a Expression<'a>> {
    top_level_variable_declarations(program)
        .flat_map(|decl| &decl.declarations)
        .find(|declarator| {
            matches!(&declarator.id, BindingPattern::BindingIdentifier(id) if id.name == name)
        })
        .and_then(|declarator| declarator.init.as_ref())
}

/// The expression that the config file exports with `export default` or
/// `module.exports =`.
fn exported_config_expression<'a>(program: &'a Program<'a>) -> Option<&'a Expression<'a>> {
    program.body.iter().find_map(|stmt| match stmt {
        Statement::ExportDefaultDeclaration(decl) => decl.declaration.as_expression(),
        Statement::ExpressionStatement(expr_stmt) => match &expr_stmt.expression {
            Expression::AssignmentExpression(assign) if is_module_exports_target(&assign.left) => {
                Some(&assign.right)
            }
            _ => None,
        },
        _ => None,
    })
}

/// The call that `expr` stands for, through parentheses, type assertions and
/// one top-level variable binding.
fn config_call<'a>(
    program: &'a Program<'a>,
    expr: &'a Expression<'a>,
    follow_binding: bool,
) -> Option<&'a CallExpression<'a>> {
    match expr {
        Expression::CallExpression(call) => Some(call),
        Expression::ParenthesizedExpression(paren) => {
            config_call(program, &paren.expression, follow_binding)
        }
        Expression::TSSatisfiesExpression(ts_sat) => {
            config_call(program, &ts_sat.expression, follow_binding)
        }
        Expression::TSAsExpression(ts_as) => {
            config_call(program, &ts_as.expression, follow_binding)
        }
        Expression::Identifier(id) if follow_binding => {
            config_call(program, find_variable_init(program, &id.name)?, false)
        }
        _ => None,
    }
}

/// The arguments of an exported config call with more than one argument, such
/// as `defineConfig(base, { ... })`, in source order.
///
/// Some tools merge every argument into one config. Each argument resolves to
/// its object. An argument that does not resolve to one local object is
/// `None`, because it can set any key: a spread, an imported binding, or a
/// nested call that merges more than one argument. Returns `None` when the
/// exported config is not a call with more than one argument.
pub(crate) fn find_config_merge_arguments<'a>(
    program: &'a Program<'a>,
) -> Option<Vec<Option<&'a ObjectExpression<'a>>>> {
    let call = config_call(program, exported_config_expression(program)?, true)?;
    if call.arguments.len() < 2 {
        return None;
    }
    let resolve = |arg: &'a Argument<'a>| {
        let expr = arg.as_expression()?;
        if config_call(program, expr, true).is_some_and(|nested| nested.arguments.len() > 1) {
            return None;
        }
        resolve_config_argument(program, expr, MAX_CONFIG_WRAPPER_DEPTH)
    };
    Some(call.arguments.iter().map(resolve).collect())
}

/// Every top-level variable declaration, including the one an
/// `export const NAME = ...` declaration wraps.
fn top_level_variable_declarations<'a>(
    program: &'a Program<'a>,
) -> impl Iterator<Item = &'a VariableDeclaration<'a>> {
    program.body.iter().filter_map(|stmt| match stmt {
        Statement::VariableDeclaration(decl) => Some(&**decl),
        Statement::ExportDeclaration(export) => match &export.declaration {
            Declaration::VariableDeclaration(decl) => Some(&**decl),
            _ => None,
        },
        _ => None,
    })
}

/// The init expression of a top-level `const` or `let` that is the only binding
/// of `name` in the program and that no expression writes to.
///
/// `new ModuleFederationPlugin(mfConfig)` is the common shape for plugin options
/// that a config declares above the plugin list. A reader that accepts the
/// inline object only reads nothing there.
///
/// The name resolves only when the program holds one binding of that name. A
/// second binding, a parameter of the same name, or a write to the binding means
/// the expression can name another value than the top-level one, so the
/// resolver declines instead of reading the wrong value.
pub(crate) fn find_stable_binding_init<'a>(
    program: &'a Program<'a>,
    name: &str,
) -> Option<&'a Expression<'a>> {
    if !holds_one_stable_object(program, name) {
        return None;
    }
    find_variable_init_expression(program, name)
}

/// Whether one top-level `const` or `let` is the only binding of `name` in the
/// program, and no expression writes to it or to one of its members.
fn holds_one_stable_object(program: &Program<'_>, name: &str) -> bool {
    if !declares_top_level_const_or_let(program, name) {
        return false;
    }
    let mut usage = NameUsage::new(name);
    usage.visit_program(program);
    usage.bindings == 1 && usage.writes == 0
}

/// Whether a top-level `const` or `let` statement declares `name`. A `var` is
/// function scoped and hoisted, so a later statement can hold its value.
fn declares_top_level_const_or_let(program: &Program<'_>, name: &str) -> bool {
    top_level_variable_declarations(program).any(|decl| {
        matches!(
            decl.kind,
            VariableDeclarationKind::Const | VariableDeclarationKind::Let
        ) && decl.declarations.iter().any(|declarator| {
            matches!(&declarator.id, BindingPattern::BindingIdentifier(id) if id.name == name)
        })
    })
}

/// What one program does with one name: the number of bindings that declare it,
/// and the number of expressions that write to it or to one of its members.
struct NameUsage<'n> {
    name: &'n str,
    bindings: usize,
    writes: usize,
    write_depth: usize,
}

impl<'n> NameUsage<'n> {
    const fn new(name: &'n str) -> Self {
        Self {
            name,
            bindings: 0,
            writes: 0,
            write_depth: 0,
        }
    }
}

impl<'a> Visit<'a> for NameUsage<'_> {
    fn visit_binding_identifier(&mut self, identifier: &BindingIdentifier<'a>) {
        if identifier.name == self.name {
            self.bindings += 1;
        }
    }

    fn visit_identifier_reference(&mut self, identifier: &IdentifierReference<'a>) {
        if self.write_depth > 0 && identifier.name == self.name {
            self.writes += 1;
        }
    }

    fn visit_assignment_target(&mut self, target: &AssignmentTarget<'a>) {
        self.write_depth += 1;
        walk::walk_assignment_target(self, target);
        self.write_depth -= 1;
    }

    fn visit_update_expression(&mut self, expression: &UpdateExpression<'a>) {
        self.write_depth += 1;
        walk::walk_update_expression(self, expression);
        self.write_depth -= 1;
    }

    fn visit_unary_expression(&mut self, expression: &UnaryExpression<'a>) {
        if expression.operator != UnaryOperator::Delete {
            walk::walk_unary_expression(self, expression);
            return;
        }
        self.write_depth += 1;
        walk::walk_unary_expression(self, expression);
        self.write_depth -= 1;
    }
}

/// Resolve a config object that is passed as a NAMED CONST to a wrapper call:
/// `export default withMDX(nextConfig)`, `module.exports = createJestConfig(cfg)`,
/// nested `withMDX(withFoo(nextConfig))`, and curried `compose(...)(nextConfig)`.
/// This is the call-argument analog of the bare `export default config` identifier
/// resolution already done via [`unwrap_to_identifier_name`] +
/// [`find_variable_init_object`]; it lets the official `@next/mdx` /
/// `withSentry(nextConfig)` / `next-compose-plugins` idioms resolve so their
/// `pageExtensions` / plugin config is extracted instead of silently dropped.
///
/// Returns the first argument (scanning nested wrapper calls) that resolves to a
/// local `const NAME = { ... }`. Inline object and callback arguments are handled
/// by [`resolve_call_config_object`], which the caller tries first.
fn resolve_wrapped_config_object<'a>(
    program: &'a Program,
    expr: &'a Expression<'a>,
) -> Option<&'a ObjectExpression<'a>> {
    let call = match expr {
        Expression::CallExpression(call) => call,
        Expression::ParenthesizedExpression(paren) => {
            return resolve_wrapped_config_object(program, &paren.expression);
        }
        Expression::TSSatisfiesExpression(ts_sat) => {
            return resolve_wrapped_config_object(program, &ts_sat.expression);
        }
        Expression::TSAsExpression(ts_as) => {
            return resolve_wrapped_config_object(program, &ts_as.expression);
        }
        _ => return None,
    };
    for arg in &call.arguments {
        let Some(arg_expr) = arg.as_expression() else {
            continue;
        };
        if let Some(name) = unwrap_to_identifier_name(arg_expr)
            && let Some(obj) = find_variable_init_object(program, name)
        {
            return Some(obj);
        }
        if let Some(obj) = resolve_wrapped_config_object(program, arg_expr) {
            return Some(obj);
        }
    }
    None
}

/// Maximum wrapper nesting resolved by [`resolve_call_config_object`].
///
/// Covers the shapes seen in the wild (`defineConfig(mergeConfig(base, defineConfig({..})))`)
/// while keeping a hand-written config from driving unbounded recursion.
const MAX_CONFIG_WRAPPER_DEPTH: u8 = 3;

/// Resolve the config object carried by a wrapper call, giving each argument the
/// full resolution chain in source order.
///
/// Config wrappers take the config first and their own options after it, as in
/// `withSentryConfig(nextConfig, { org, project })` or
/// `mergeConfig(viteConfig, defineConfig({ test }))`. Scanning the whole argument
/// list for the first object literal therefore picks up the wrapper's options
/// object whenever the config itself arrives as an identifier or a nested call,
/// silently reading the wrong object. Resolving argument by argument, chain-first,
/// keeps the config's own position winning.
fn resolve_call_config_object<'a>(
    program: &'a Program,
    expr: &'a Expression<'a>,
    depth: u8,
) -> Option<&'a ObjectExpression<'a>> {
    if depth == 0 {
        return None;
    }
    let call = match expr {
        Expression::CallExpression(call) => call,
        Expression::ParenthesizedExpression(paren) => {
            return resolve_call_config_object(program, &paren.expression, depth);
        }
        Expression::TSSatisfiesExpression(ts_sat) => {
            return resolve_call_config_object(program, &ts_sat.expression, depth);
        }
        Expression::TSAsExpression(ts_as) => {
            return resolve_call_config_object(program, &ts_as.expression, depth);
        }
        _ => return None,
    };

    call.arguments
        .iter()
        .filter_map(oxc_ast::ast::Argument::as_expression)
        .find_map(|arg| resolve_config_argument(program, arg, depth))
}

/// Resolve one wrapper argument to the object it stands for.
fn resolve_config_argument<'a>(
    program: &'a Program,
    expr: &'a Expression<'a>,
    depth: u8,
) -> Option<&'a ObjectExpression<'a>> {
    match expr {
        Expression::ObjectExpression(obj) => Some(obj),
        Expression::ArrowFunctionExpression(arrow) => extract_object_from_arrow_function(arrow),
        Expression::FunctionExpression(func) => extract_object_from_function(func),
        Expression::ParenthesizedExpression(paren) => {
            resolve_config_argument(program, &paren.expression, depth)
        }
        Expression::TSSatisfiesExpression(ts_sat) => {
            resolve_config_argument(program, &ts_sat.expression, depth)
        }
        Expression::TSAsExpression(ts_as) => {
            resolve_config_argument(program, &ts_as.expression, depth)
        }
        Expression::CallExpression(_) => resolve_call_config_object(program, expr, depth - 1),
        _ => unwrap_to_identifier_name(expr)
            .and_then(|name| find_variable_init_object(program, name)),
    }
}

/// Find a named property in an object expression.
pub(crate) fn find_property<'a>(
    obj: &'a ObjectExpression<'a>,
    key: &str,
) -> Option<&'a ObjectProperty<'a>> {
    for prop in &obj.properties {
        if let ObjectPropertyKind::ObjectProperty(p) = prop
            && property_key_matches(&p.key, key)
        {
            return Some(p);
        }
    }
    None
}

/// Check if a property key matches a string.
fn property_key_matches(key: &PropertyKey, name: &str) -> bool {
    match key {
        PropertyKey::StaticIdentifier(id) => id.name == name,
        PropertyKey::StringLiteral(s) => s.value == name,
        _ => false,
    }
}

/// Get a string value from an object property.
fn get_object_string_property(obj: &ObjectExpression, key: &str) -> Option<String> {
    find_property(obj, key).and_then(|p| expression_to_string(&p.value))
}

/// Get an array of strings from an object property.
fn get_object_string_array_property(obj: &ObjectExpression, key: &str) -> Vec<String> {
    find_property(obj, key)
        .map(|p| expression_to_string_array(&p.value))
        .unwrap_or_default()
}

/// Navigate a nested property path and get a string array.
fn get_nested_string_array_from_object(
    obj: &ObjectExpression,
    path: &[&str],
) -> Option<Vec<String>> {
    if path.is_empty() {
        return None;
    }
    if path.len() == 1 {
        return Some(get_object_string_array_property(obj, path[0]));
    }
    let prop = find_property(obj, path[0])?;
    if let Expression::ObjectExpression(nested) = &prop.value {
        get_nested_string_array_from_object(nested, &path[1..])
    } else {
        None
    }
}

/// Navigate a nested property path and get a string value.
fn get_nested_string_from_object(obj: &ObjectExpression, path: &[&str]) -> Option<String> {
    if path.is_empty() {
        return None;
    }
    if path.len() == 1 {
        return get_object_string_property(obj, path[0]);
    }
    let prop = find_property(obj, path[0])?;
    if let Expression::ObjectExpression(nested) = &prop.value {
        get_nested_string_from_object(nested, &path[1..])
    } else {
        None
    }
}

/// Navigate a nested property path and get a shell command value.
fn get_nested_command_from_object(obj: &ObjectExpression, path: &[&str]) -> Option<String> {
    if path.is_empty() {
        return None;
    }
    if path.len() == 1 {
        return find_property(obj, path[0]).and_then(|prop| expression_to_command(&prop.value));
    }
    let prop = find_property(obj, path[0])?;
    if let Expression::ObjectExpression(nested) = &prop.value {
        get_nested_command_from_object(nested, &path[1..])
    } else {
        None
    }
}

/// Convert an expression to a string if it's a string literal.
pub(crate) fn expression_to_string(expr: &Expression) -> Option<String> {
    match expr {
        Expression::StringLiteral(s) => Some(s.value.text().into_owned()),
        Expression::TemplateLiteral(t) if t.expressions.is_empty() => {
            t.quasis.first().map(|q| q.value.raw.to_string())
        }
        _ => None,
    }
}

/// Convert an expression to a shell command when static command tokens are recoverable.
fn expression_to_command(expr: &Expression) -> Option<String> {
    match expr {
        Expression::StringLiteral(s) => Some(s.value.text().into_owned()),
        Expression::TemplateLiteral(template) => template_literal_to_command(template),
        Expression::ParenthesizedExpression(paren) => expression_to_command(&paren.expression),
        Expression::TSAsExpression(ts_as) => expression_to_command(&ts_as.expression),
        Expression::TSSatisfiesExpression(ts_sat) => expression_to_command(&ts_sat.expression),
        _ => None,
    }
}

fn template_literal_to_command(template: &TemplateLiteral<'_>) -> Option<String> {
    let first = template.quasis.first()?.value.raw.as_str();
    if first.trim_start().is_empty() {
        return None;
    }

    let mut command = String::new();
    for (idx, quasi) in template.quasis.iter().enumerate() {
        command.push_str(quasi.value.raw.as_str());
        if idx < template.expressions.len() {
            let next = template
                .quasis
                .get(idx + 1)
                .map_or("", |next| next.value.raw.as_str());
            if dynamic_template_boundary_splits_static_token(quasi.value.raw.as_str(), next) {
                return None;
            }
            command.push(' ');
        }
    }

    Some(command)
}

fn dynamic_template_boundary_splits_static_token(before: &str, after: &str) -> bool {
    before
        .chars()
        .next_back()
        .is_some_and(is_command_token_char)
        && after.chars().next().is_some_and(is_command_token_char)
}

fn is_command_token_char(ch: char) -> bool {
    !ch.is_whitespace() && !matches!(ch, '&' | '|' | ';' | '"' | '\'')
}

/// The identifiers that a path expression can resolve.
#[derive(Clone, Copy)]
enum PathScope<'p> {
    /// No identifier resolves.
    Bare,
    /// A call to a module-level path helper of this program resolves.
    Program(&'p Program<'p>),
    /// Inside a helper body, the parameter `name` holds the literal `value`.
    Param { name: &'p str, value: &'p str },
}

/// Convert an expression to a path-like string if it's statically recoverable.
pub(crate) fn expression_to_path_string(expr: &Expression) -> Option<String> {
    path_string_in(expr, PathScope::Bare)
}

fn path_string_in(expr: &Expression, scope: PathScope<'_>) -> Option<String> {
    match expr {
        Expression::ParenthesizedExpression(paren) => path_string_in(&paren.expression, scope),
        Expression::TSAsExpression(ts_as) => path_string_in(&ts_as.expression, scope),
        Expression::TSSatisfiesExpression(ts_sat) => path_string_in(&ts_sat.expression, scope),
        Expression::StaticMemberExpression(member) if member.property.name == "pathname" => {
            path_string_in(&member.object, scope)
        }
        Expression::CallExpression(call) => call_expression_to_path_string(call, scope),
        Expression::NewExpression(new_expr) => new_expression_to_path_string(new_expr, scope),
        _ => scoped_string(expr, scope),
    }
}

/// A string literal, or the helper parameter that stands for one.
fn scoped_string(expr: &Expression, scope: PathScope<'_>) -> Option<String> {
    match (expr, scope) {
        (Expression::Identifier(id), PathScope::Param { name, value }) if id.name == name => {
            Some(value.to_string())
        }
        _ => expression_to_string(expr),
    }
}

fn call_expression_to_path_string(call: &CallExpression, scope: PathScope<'_>) -> Option<String> {
    if let PathScope::Program(program) = scope
        && let Expression::Identifier(id) = &call.callee
        && let Some(path) = local_helper_call_path(program, &id.name, call)
    {
        return Some(path);
    }

    if matches!(&call.callee, Expression::Identifier(id) if id.name == "fileURLToPath") {
        return call
            .arguments
            .first()
            .and_then(Argument::as_expression)
            .and_then(|arg| path_string_in(arg, scope));
    }

    let callee_name = match &call.callee {
        Expression::Identifier(id) => Some(id.name.as_str()),
        Expression::StaticMemberExpression(member) => Some(member.property.name.as_str()),
        _ => None,
    }?;

    if !matches!(callee_name, "resolve" | "join") {
        return None;
    }

    let mut segments = Vec::new();
    for (index, arg) in call.arguments.iter().enumerate() {
        let expr = arg.as_expression()?;

        if is_dirname_anchor(expr) {
            if index == 0 {
                continue;
            }
            return None;
        }

        segments.push(scoped_string(expr, scope)?);
    }

    (!segments.is_empty()).then(|| join_path_segments(&segments))
}

/// Evaluate a call to a module-level path helper with one literal argument.
///
/// Configs often declare a small helper such as
/// `const p = (rel) => fileURLToPath(new URL(rel, import.meta.url))` and call
/// it as `p("./src/main.ts")`. The helper body is evaluated with its parameter
/// bound to the literal argument. The body can not call another helper.
fn local_helper_call_path(program: &Program, name: &str, call: &CallExpression) -> Option<String> {
    let [argument] = call.arguments.as_slice() else {
        return None;
    };
    let value = expression_to_string(argument.as_expression()?)?;
    let (param, body) = find_local_path_helper(program, name)?;
    path_string_in(
        body,
        PathScope::Param {
            name: param,
            value: &value,
        },
    )
}

/// Find a module-level function `name` with one simple parameter and a body
/// that only returns one expression. Return the parameter name and that
/// expression.
fn find_local_path_helper<'a>(
    program: &'a Program<'a>,
    name: &str,
) -> Option<(&'a str, &'a Expression<'a>)> {
    let declared = program.body.iter().find_map(|stmt| {
        let func = match stmt {
            Statement::FunctionDeclaration(func) => func,
            Statement::ExportDeclaration(export) => match &export.declaration {
                Declaration::FunctionDeclaration(func) => func,
                _ => return None,
            },
            _ => return None,
        };
        func.id
            .as_ref()
            .is_some_and(|id| id.name == name)
            .then_some(&**func)
    });
    if let Some(func) = declared {
        return function_helper_body(func);
    }
    match find_variable_init_expression(program, name)?.without_parentheses() {
        Expression::ArrowFunctionExpression(arrow) => {
            let param = single_simple_param(&arrow.params)?;
            let body = match &arrow.body {
                ArrowFunctionBody::FunctionBody(body) => single_returned_expression(body)?,
                body => body.as_expression()?,
            };
            Some((param, body))
        }
        Expression::FunctionExpression(func) => function_helper_body(func),
        _ => None,
    }
}

fn function_helper_body<'a>(func: &'a Function<'a>) -> Option<(&'a str, &'a Expression<'a>)> {
    let param = single_simple_param(&func.params)?;
    let body = single_returned_expression(func.body.as_ref()?)?;
    Some((param, body))
}

fn single_simple_param<'a>(params: &'a FormalParameters<'a>) -> Option<&'a str> {
    let [param] = params.items.as_slice() else {
        return None;
    };
    if params.rest.is_some() || param.initializer.is_some() {
        return None;
    }
    match &param.pattern {
        BindingPattern::BindingIdentifier(id) => Some(id.name.as_str()),
        _ => None,
    }
}

fn single_returned_expression<'a>(body: &'a FunctionBody<'a>) -> Option<&'a Expression<'a>> {
    match body.statements.as_slice() {
        [Statement::ReturnStatement(ret)] => ret.argument.as_ref(),
        _ => None,
    }
}

/// True when an expression is a "current directory" anchor: the `__dirname`
/// CommonJS global or its ESM equivalent `import.meta.dirname` (Node 20.11+).
/// As the leading argument of `resolve(...)` / `join(...)` it is dropped so the
/// remaining literal segments yield a config-directory-relative path.
fn is_dirname_anchor(expr: &Expression) -> bool {
    match expr {
        Expression::Identifier(id) => id.name == "__dirname",
        Expression::StaticMemberExpression(member) => {
            member.property.name == "dirname" && is_import_meta_expression(&member.object)
        }
        _ => false,
    }
}

/// True for the `import.meta` meta-property, distinct from `new.target`.
fn is_import_meta_expression(expr: &Expression) -> bool {
    matches!(expr, Expression::ImportMeta(_))
}

fn new_expression_to_path_string(new_expr: &NewExpression, scope: PathScope<'_>) -> Option<String> {
    if !matches!(&new_expr.callee, Expression::Identifier(id) if id.name == "URL") {
        return None;
    }

    let source = new_expr
        .arguments
        .first()
        .and_then(Argument::as_expression)
        .and_then(|arg| scoped_string(arg, scope))?;

    let base = new_expr
        .arguments
        .get(1)
        .and_then(Argument::as_expression)?;
    is_import_meta_url_expression(base).then_some(source)
}

fn is_import_meta_url_expression(expr: &Expression) -> bool {
    if let Expression::StaticMemberExpression(member) = expr {
        member.property.name == "url"
            && matches!(
                member.object,
                Expression::ImportMeta(_) | Expression::NewTarget(_)
            )
    } else {
        false
    }
}

fn join_path_segments(segments: &[String]) -> String {
    let mut joined = PathBuf::new();
    for segment in segments {
        joined.push(segment);
    }
    joined.to_string_lossy().replace('\\', "/")
}

/// Convert an alias object or `{ find, replacement }` array to alias tuples.
///
/// Each tuple carries a `replacement_is_bare_string_literal` flag. See
/// [`extract_config_aliases_kinded`].
fn expression_to_alias_pairs_kinded(expr: &Expression) -> Vec<(String, String, bool)> {
    match expr {
        Expression::ObjectExpression(obj) => obj
            .properties
            .iter()
            .filter_map(|prop| {
                let ObjectPropertyKind::ObjectProperty(prop) = prop else {
                    return None;
                };
                let find = property_key_to_string(&prop.key)?;
                let (replacement, is_bare) =
                    alias_replacement_kinded(&prop.value, PathScope::Bare)?;
                Some((find, replacement, is_bare))
            })
            .collect(),
        Expression::ArrayExpression(arr) => arr
            .elements
            .iter()
            .filter_map(|element| {
                let Expression::ObjectExpression(obj) = element.as_expression()? else {
                    return None;
                };
                let find = find_property(obj, "find")
                    .and_then(|prop| expression_to_string(&prop.value))?;
                let (replacement, is_bare) = find_property(obj, "replacement")
                    .and_then(|prop| alias_replacement_kinded(&prop.value, PathScope::Bare))?;
                Some((find, replacement, is_bare))
            })
            .collect(),
        _ => Vec::new(),
    }
}

/// Extract an alias replacement string plus whether it was written as a plain
/// bare string literal. A bare string literal (not starting with `./`/`../`/`/`)
/// signals a potential package-to-package alias; a path expression
/// (`path.resolve(...)`, `path.join(...)`, `fileURLToPath(...)`, `new URL(...)`)
/// or a `./`-prefixed string is always a filesystem path. This is the
/// filesystem-free discriminator the package-to-package gate relies on.
fn alias_replacement_kinded(expr: &Expression, scope: PathScope<'_>) -> Option<(String, bool)> {
    match expr {
        Expression::ParenthesizedExpression(paren) => {
            alias_replacement_kinded(&paren.expression, scope)
        }
        Expression::TSAsExpression(ts_as) => alias_replacement_kinded(&ts_as.expression, scope),
        Expression::TSSatisfiesExpression(ts_sat) => {
            alias_replacement_kinded(&ts_sat.expression, scope)
        }
        Expression::StringLiteral(s) => {
            let value = s.value.text().into_owned();
            let is_bare =
                !value.starts_with("./") && !value.starts_with("../") && !value.starts_with('/');
            Some((value, is_bare))
        }
        // tsconfig `compilerOptions.paths` maps each key to an ARRAY of targets
        // (`{ "@/*": ["./src/*"] }`); take the first entry, matching the prior
        // non-kinded `expression_to_path_values().next()` behavior.
        Expression::ArrayExpression(arr) => arr
            .elements
            .iter()
            .find_map(ArrayExpressionElement::as_expression)
            .and_then(|element| alias_replacement_kinded(element, scope)),
        _ => path_string_in(expr, scope).map(|value| (value, false)),
    }
}

/// Maximum identifier-indirection hops the alias resolver follows before giving
/// up. Each local-variable or imported-binding resolution counts one hop. The
/// per-file `visited` set is the real cycle guard; this bound additionally
/// terminates pathological local self-references (`const a = a`). Real configs
/// rarely exceed one or two hops (`alias: importedAliases`).
const MAX_ALIAS_RESOLVE_DEPTH: usize = 8;

/// Sibling-file extensions probed when an alias identifier is imported from a
/// relative specifier. Mirrors the JS/TS config extensions Vite/Vitest configs
/// and their shared alias modules use. `.js` first matches the common
/// JS-project case; the direct-as-written read happens before any probing. JSON
/// is intentionally excluded: it parses as a bare expression with no `export`,
/// so `find_exported_init` could never recover an alias literal from it.
const ALIAS_SIBLING_EXTS: [&str; 6] = ["js", "mjs", "cjs", "ts", "mts", "cts"];

/// Resolve an alias expression into `(find, replacement, is_bare)` tuples,
/// following identifiers and expanding spreads.
///
/// Beyond the inline object (`{ '@': './src' }`) and array
/// (`[{ find, replacement }]`) forms, this handles the indirection shapes from
/// issue #811:
/// - an identifier bound to a local `const NAME = [...] | {...}`,
/// - an identifier imported from a relative sibling file
///   (`import { sharedAliases } from "./vite.shared.js"`), read one hop and
///   parsed for `export const NAME` / `export default` / `export { NAME }`,
/// - array spread elements (`[...a, ...b]`) and object spread properties
///   (`{ ...a, '@': './src' }`), each resolved recursively.
///
/// `config_path` is the file `expr` lives in (used to resolve relative sibling
/// imports). `visited` holds already-read sibling paths to break import cycles;
/// `depth` bounds identifier indirection via [`MAX_ALIAS_RESOLVE_DEPTH`].
fn resolve_alias_pairs_kinded(
    program: &Program,
    config_path: &Path,
    expr: &Expression,
    visited: &mut FxHashSet<PathBuf>,
    depth: usize,
) -> Vec<(String, String, bool)> {
    match expr {
        Expression::ParenthesizedExpression(paren) => {
            resolve_alias_pairs_kinded(program, config_path, &paren.expression, visited, depth)
        }
        Expression::TSAsExpression(ts_as) => {
            resolve_alias_pairs_kinded(program, config_path, &ts_as.expression, visited, depth)
        }
        Expression::TSSatisfiesExpression(ts_sat) => {
            resolve_alias_pairs_kinded(program, config_path, &ts_sat.expression, visited, depth)
        }
        Expression::ObjectExpression(obj) => {
            resolve_object_alias_pairs_kinded(program, config_path, obj, visited, depth)
        }
        Expression::ArrayExpression(arr) => {
            resolve_array_alias_pairs_kinded(program, config_path, arr, visited, depth)
        }
        Expression::Identifier(id) => {
            resolve_identifier_alias_pairs(program, config_path, id.name.as_str(), visited, depth)
        }
        _ => Vec::new(),
    }
}

/// Resolve object-form alias pairs (`{ '@': './src', ...spread }`), expanding
/// spread properties recursively.
fn resolve_object_alias_pairs_kinded(
    program: &Program,
    config_path: &Path,
    obj: &ObjectExpression,
    visited: &mut FxHashSet<PathBuf>,
    depth: usize,
) -> Vec<(String, String, bool)> {
    let mut pairs = Vec::new();
    for prop in &obj.properties {
        match prop {
            ObjectPropertyKind::ObjectProperty(prop) => {
                if let Some(find) = property_key_to_string(&prop.key)
                    && let Some((replacement, is_bare)) =
                        alias_replacement_kinded(&prop.value, PathScope::Program(program))
                {
                    pairs.push((find, replacement, is_bare));
                }
            }
            // `{ ...sharedAliases, '@': './src' }`
            ObjectPropertyKind::SpreadProperty(spread) => {
                pairs.extend(resolve_alias_pairs_kinded(
                    program,
                    config_path,
                    &spread.argument,
                    visited,
                    depth,
                ));
            }
        }
    }
    pairs
}

/// Resolve array-form alias pairs (`[{ find, replacement }, ...spread]`),
/// expanding spread elements recursively.
fn resolve_array_alias_pairs_kinded(
    program: &Program,
    config_path: &Path,
    arr: &ArrayExpression,
    visited: &mut FxHashSet<PathBuf>,
    depth: usize,
) -> Vec<(String, String, bool)> {
    let mut pairs = Vec::new();
    for element in &arr.elements {
        match element {
            // `[...sharedAliases, { find, replacement }]`
            ArrayExpressionElement::SpreadElement(spread) => {
                pairs.extend(resolve_alias_pairs_kinded(
                    program,
                    config_path,
                    &spread.argument,
                    visited,
                    depth,
                ));
            }
            _ => {
                if let Some(Expression::ObjectExpression(obj)) = element.as_expression()
                    && let Some(find) = find_property(obj, "find")
                        .and_then(|prop| expression_to_string(&prop.value))
                    && let Some((replacement, is_bare)) = find_property(obj, "replacement")
                        .and_then(|prop| {
                            alias_replacement_kinded(&prop.value, PathScope::Program(program))
                        })
                {
                    pairs.push((find, replacement, is_bare));
                }
            }
        }
    }
    pairs
}

/// Resolve an identifier used as an alias value to its literal pairs, first by
/// local `const`/`let`/`var` binding, then by a one-hop relative import.
fn resolve_identifier_alias_pairs(
    program: &Program,
    config_path: &Path,
    name: &str,
    visited: &mut FxHashSet<PathBuf>,
    depth: usize,
) -> Vec<(String, String, bool)> {
    if depth >= MAX_ALIAS_RESOLVE_DEPTH {
        return Vec::new();
    }
    // Local `const NAME = [...] | {...}` (or `const NAME = otherIdentifier`).
    if let Some(init) = find_variable_init_expression(program, name) {
        return resolve_alias_pairs_kinded(program, config_path, init, visited, depth + 1);
    }
    // `import { NAME } from "./sibling"` / `import NAME from "./sibling"`.
    let Some((specifier, imported_name)) = find_relative_import_binding(program, name) else {
        return Vec::new();
    };
    resolve_imported_alias_pairs(
        config_path,
        &specifier,
        imported_name.as_deref(),
        visited,
        depth + 1,
    )
}

/// Read a relative sibling file and resolve the alias literal it exports under
/// `imported_name` (`None` = default export).
fn resolve_imported_alias_pairs(
    config_path: &Path,
    specifier: &str,
    imported_name: Option<&str>,
    visited: &mut FxHashSet<PathBuf>,
    depth: usize,
) -> Vec<(String, String, bool)> {
    let Some((sibling_path, sibling_source)) = resolve_sibling_module(config_path, specifier)
    else {
        return Vec::new();
    };
    if !visited.insert(sibling_path.clone()) {
        return Vec::new();
    }
    extract_from_source(&sibling_source, &sibling_path, |program| {
        let init = find_exported_init(program, imported_name)?;
        let pairs = resolve_alias_pairs_kinded(program, &sibling_path, init, visited, depth);
        (!pairs.is_empty()).then_some(pairs)
    })
    .unwrap_or_default()
}

/// Find a top-level variable declaration by name and return its init expression
/// (array, object, or another identifier). Covers bare `const NAME = ...` and
/// `export const NAME = ...`. Generalizes [`find_variable_init_object`] to any
/// init shape so the alias resolver can recurse on array/identifier inits.
fn find_variable_init_expression<'a>(
    program: &'a Program<'a>,
    name: &str,
) -> Option<&'a Expression<'a>> {
    for decl in top_level_variable_declarations(program) {
        for declarator in &decl.declarations {
            if let BindingPattern::BindingIdentifier(id) = &declarator.id
                && id.name == name
                && let Some(init) = &declarator.init
            {
                return Some(init);
            }
        }
    }
    None
}

/// The expression a module exports as a whole: the right side of
/// `module.exports = ...`, or the expression of `export default ...`.
pub(crate) fn find_module_export_expression<'a>(
    program: &'a Program<'a>,
) -> Option<&'a Expression<'a>> {
    program.body.iter().find_map(|stmt| match stmt {
        Statement::ExportDefaultDeclaration(decl) => decl.declaration.as_expression(),
        Statement::ExpressionStatement(expr_stmt) => match &expr_stmt.expression {
            Expression::AssignmentExpression(assign) if is_module_exports_target(&assign.left) => {
                Some(&assign.right)
            }
            _ => None,
        },
        _ => None,
    })
}

/// Find the init expression a sibling module exports under `name`
/// (`None` = default export). For named exports this covers both
/// `export const NAME = ...` and a local `const NAME = ...` later re-exported
/// via `export { NAME }` (both surface through [`find_variable_init_expression`]).
pub(crate) fn find_exported_init<'a>(
    program: &'a Program<'a>,
    name: Option<&str>,
) -> Option<&'a Expression<'a>> {
    match name {
        Some(name) => find_variable_init_expression(program, name),
        None => program.body.iter().find_map(|stmt| {
            if let Statement::ExportDefaultDeclaration(decl) = stmt {
                decl.declaration.as_expression()
            } else {
                None
            }
        }),
    }
}

/// Find the import that binds local `name` to a RELATIVE module, returning the
/// specifier and the imported name (`None` for a default import). Bare-package
/// imports are intentionally skipped: reading a literal alias table out of
/// `node_modules` is not a real-world config shape.
pub(crate) fn find_relative_import_binding(
    program: &Program,
    name: &str,
) -> Option<(String, Option<String>)> {
    for stmt in &program.body {
        let Statement::ImportDeclaration(decl) = stmt else {
            continue;
        };
        let specifier = &*decl.source.value.text();
        if !is_relative_specifier(specifier) {
            continue;
        }
        let Some(specifiers) = &decl.specifiers else {
            continue;
        };
        for spec in specifiers {
            match spec {
                ImportDeclarationSpecifier::ImportSpecifier(spec) if spec.local.name == name => {
                    return Some((
                        specifier.to_string(),
                        Some(spec.imported.name().to_string()),
                    ));
                }
                ImportDeclarationSpecifier::ImportDefaultSpecifier(spec)
                    if spec.local.name == name =>
                {
                    return Some((specifier.to_string(), None));
                }
                _ => {}
            }
        }
    }
    None
}

/// True for a relative/absolute module specifier (`./x`, `../x`, `/x`), the
/// shapes that point at a sibling file rather than an npm package.
pub(crate) fn is_relative_specifier(specifier: &str) -> bool {
    specifier.starts_with("./") || specifier.starts_with("../") || specifier.starts_with('/')
}

/// Resolve a relative specifier against `config_path`'s directory to a readable
/// sibling file, returning the resolved path and its source. Tries the path as
/// written first (covers `./vite.shared.js`), then appends each known config
/// extension (covers extensionless `./vite.shared` and dotted basenames where
/// `Path::extension` would misread `.shared`), then an `index.*` directory file.
pub(crate) fn resolve_sibling_module(
    config_path: &Path,
    specifier: &str,
) -> Option<(PathBuf, String)> {
    let parent = config_path.parent().unwrap_or(config_path);
    let direct = parent.join(specifier);
    if let Ok(source) = std::fs::read_to_string(&direct) {
        return Some((direct, source));
    }
    for ext in ALIAS_SIBLING_EXTS {
        let candidate = parent.join(format!("{specifier}.{ext}"));
        if let Ok(source) = std::fs::read_to_string(&candidate) {
            return Some((candidate, source));
        }
    }
    for ext in ALIAS_SIBLING_EXTS {
        let candidate = direct.join(format!("index.{ext}"));
        if let Ok(source) = std::fs::read_to_string(&candidate) {
            return Some((candidate, source));
        }
    }
    None
}

/// Find a default-exported array config, the `defineWorkspace([...])` /
/// `vitest.workspace.{ts,js}` shape. Handles `export default [...]` and
/// `export default defineWorkspace([...])` / `defineConfig([...])` (the array as
/// the call's first argument), function configs with a static array return, and
/// parenthesised / `as` wrappers.
fn find_default_export_array<'a>(program: &'a Program<'a>) -> Option<&'a ArrayExpression<'a>> {
    for stmt in &program.body {
        if let Statement::ExportDefaultDeclaration(decl) = stmt {
            if let ExportDefaultDeclarationKind::FunctionDeclaration(function) = &decl.declaration {
                if function.generator {
                    return None;
                }
                return function.body.as_ref().and_then(|body| returned_array(body));
            }
            return decl
                .declaration
                .as_expression()
                .and_then(array_from_config_expression);
        }
    }
    None
}

/// Read only returns belonging to this callback, never nested helper functions.
fn returned_array<'a>(body: &'a FunctionBody<'a>) -> Option<&'a ArrayExpression<'a>> {
    body.statements
        .iter()
        .find_map(|statement| match statement {
            Statement::ReturnStatement(returned) => Some(returned),
            _ => None,
        })
        .and_then(|returned| returned.argument.as_ref())
        .and_then(array_from_expression)
}

/// A config provider invokes its callback once; returned callbacks are values.
fn array_from_config_expression<'a>(expr: &'a Expression<'a>) -> Option<&'a ArrayExpression<'a>> {
    match expr {
        Expression::ArrowFunctionExpression(arrow) => match &arrow.body {
            ArrowFunctionBody::FunctionBody(body) => returned_array(body),
            body => body.as_expression().and_then(array_from_expression),
        },
        Expression::FunctionExpression(function) => {
            if function.generator {
                return None;
            }
            function.body.as_ref().and_then(|body| returned_array(body))
        }
        Expression::ParenthesizedExpression(paren) => {
            array_from_config_expression(&paren.expression)
        }
        Expression::TSAsExpression(ts_as) => array_from_config_expression(&ts_as.expression),
        Expression::TSSatisfiesExpression(ts_sat) => {
            array_from_config_expression(&ts_sat.expression)
        }
        Expression::CallExpression(call) => call
            .arguments
            .first()
            .and_then(Argument::as_expression)
            .and_then(array_from_config_expression),
        _ => array_from_expression(expr),
    }
}

fn array_from_expression<'a>(expr: &'a Expression<'a>) -> Option<&'a ArrayExpression<'a>> {
    match expr {
        Expression::ArrayExpression(arr) => Some(arr),
        Expression::ParenthesizedExpression(paren) => array_from_expression(&paren.expression),
        Expression::TSAsExpression(ts_as) => array_from_expression(&ts_as.expression),
        Expression::TSSatisfiesExpression(ts_sat) => array_from_expression(&ts_sat.expression),
        Expression::CallExpression(call) => call
            .arguments
            .first()
            .and_then(Argument::as_expression)
            .and_then(array_from_expression),
        _ => None,
    }
}

pub(crate) fn lexical_normalize(path: &Path) -> PathBuf {
    let mut normalized = PathBuf::new();

    for component in path.components() {
        match component {
            std::path::Component::CurDir => {}
            std::path::Component::ParentDir => {
                normalized.pop();
            }
            _ => normalized.push(component.as_os_str()),
        }
    }

    normalized
}

/// Whether an existing `path` resolves inside `root`.
///
/// The check resolves `..` segments and symlinks, so a glob match such as
/// `packages/a/../../x` or a symlink to a directory above the project does not
/// pass. A path that does not exist does not pass.
pub(crate) fn is_inside_root(path: &Path, root: &Path) -> bool {
    let Ok(resolved) = std::fs::canonicalize(path) else {
        return false;
    };
    let root = std::fs::canonicalize(root).unwrap_or_else(|_| root.to_path_buf());
    resolved.starts_with(root)
}

/// Whether the literal base of a glob `pattern`, resolved against `dir`, is
/// inside `root`. The base is the part before the first glob character. An
/// absolute `pattern` replaces `dir`.
///
/// Check this before the glob runs, so a pattern such as `../**` never walks
/// the file system above the project. The base check is lexical. Filter each
/// match with [`is_inside_root`] too, because a glob segment can match `..`
/// or a symlink.
pub(crate) fn glob_base_is_inside_root(dir: &Path, pattern: &str, root: &Path) -> bool {
    let literal = &pattern[..pattern.find(['*', '?', '[', '{']).unwrap_or(pattern.len())];
    lexical_normalize(&dir.join(path_from_config_string(literal))).starts_with(root)
}

/// Whether `specifier` is a bare package specifier: not empty, not relative or
/// absolute, not protocol-prefixed, and free of characters that are invalid in
/// an npm package name (backslashes, whitespace).
pub(crate) fn is_package_specifier(specifier: &str) -> bool {
    !specifier.is_empty()
        && specifier != "."
        && specifier != ".."
        && !specifier.starts_with("./")
        && !specifier.starts_with("../")
        && !specifier.starts_with('/')
        && !specifier.contains(':')
        && !specifier.contains('\\')
        && !specifier.chars().any(char::is_whitespace)
}

/// Convert an expression to a string array if it's an array of string literals.
fn expression_to_string_array(expr: &Expression) -> Vec<String> {
    match expr {
        Expression::ArrayExpression(arr) => arr
            .elements
            .iter()
            .filter_map(|el| match el {
                ArrayExpressionElement::SpreadElement(_) => None,
                _ => el.as_expression().and_then(expression_to_string),
            })
            .collect(),
        _ => vec![],
    }
}

/// Collect only top-level string values from an expression.
///
/// For arrays, extracts direct string elements and the first string element of sub-arrays
/// (to handle `["pkg-name", { options }]` tuples). Does NOT recurse into objects.
pub(crate) fn collect_shallow_string_values(expr: &Expression) -> Vec<String> {
    let mut values = Vec::new();
    match expr {
        Expression::StringLiteral(s) => {
            values.push(s.value.text().into_owned());
        }
        Expression::ArrayExpression(arr) => collect_shallow_array_values(arr, &mut values),
        Expression::ObjectExpression(obj) => {
            for prop in &obj.properties {
                if let ObjectPropertyKind::ObjectProperty(p) = prop {
                    match &p.value {
                        Expression::StringLiteral(s) => {
                            values.push(s.value.text().into_owned());
                        }
                        Expression::ArrayExpression(sub_arr) => {
                            if let Some(first) = sub_arr.elements.first()
                                && let Some(first_expr) = first.as_expression()
                                && let Some(s) = expression_to_string(first_expr)
                            {
                                values.push(s);
                            }
                        }
                        _ => {}
                    }
                }
            }
        }
        _ => {}
    }
    values
}

/// Collect the strings and the first string of each tuple in an array. A
/// spread of an array literal, also behind a condition such as
/// `...(isCI ? ['a'] : [])`, adds the values of each branch.
fn collect_shallow_array_values(arr: &ArrayExpression<'_>, values: &mut Vec<String>) {
    for element in &arr.elements {
        let inner = match element {
            ArrayExpressionElement::SpreadElement(spread) => {
                collect_spread_array_values(&spread.argument, values);
                continue;
            }
            element => match element.as_expression() {
                Some(expr) => expr.get_inner_expression(),
                None => continue,
            },
        };
        match inner {
            Expression::StringLiteral(s) => values.push(s.value.text().into_owned()),
            Expression::ArrayExpression(sub_arr) => {
                if let Some(first) = sub_arr.elements.first()
                    && let Some(first_expr) = first.as_expression()
                    && let Some(s) = expression_to_string(first_expr)
                {
                    values.push(s);
                }
            }
            _ => {}
        }
    }
}

/// Collect the values of a spread argument that is an array literal or a
/// condition with array literal branches.
fn collect_spread_array_values(expr: &Expression<'_>, values: &mut Vec<String>) {
    match expr.get_inner_expression() {
        Expression::ArrayExpression(arr) => collect_shallow_array_values(arr, values),
        Expression::ConditionalExpression(conditional) => {
            collect_spread_array_values(&conditional.consequent, values);
            collect_spread_array_values(&conditional.alternate, values);
        }
        Expression::LogicalExpression(logical) => {
            collect_spread_array_values(&logical.right, values);
        }
        _ => {}
    }
}

/// Collect top-level string values, plus a named string property from object entries.
pub(crate) fn collect_shallow_string_or_object_property_values(
    expr: &Expression,
    object_property: &str,
) -> Vec<String> {
    match expr {
        Expression::ArrayExpression(arr) => arr
            .elements
            .iter()
            .filter_map(|element| {
                element
                    .as_expression()
                    .and_then(|expr| shallow_string_or_object_property(expr, object_property))
            })
            .collect(),
        _ => shallow_string_or_object_property(expr, object_property)
            .into_iter()
            .collect(),
    }
}

fn shallow_string_or_object_property(expr: &Expression, object_property: &str) -> Option<String> {
    match expr {
        Expression::ParenthesizedExpression(paren) => {
            shallow_string_or_object_property(&paren.expression, object_property)
        }
        Expression::TSSatisfiesExpression(ts_sat) => {
            shallow_string_or_object_property(&ts_sat.expression, object_property)
        }
        Expression::TSAsExpression(ts_as) => {
            shallow_string_or_object_property(&ts_as.expression, object_property)
        }
        Expression::ArrayExpression(sub_arr) => sub_arr
            .elements
            .first()
            .and_then(ArrayExpressionElement::as_expression)
            .and_then(expression_to_string),
        Expression::ObjectExpression(obj) => {
            find_property(obj, object_property).and_then(|prop| expression_to_string(&prop.value))
        }
        _ => expression_to_string(expr),
    }
}

/// Recursively collect all string literal values from an expression tree.
fn collect_all_string_values(expr: &Expression, values: &mut Vec<String>) {
    match expr {
        Expression::StringLiteral(s) => {
            values.push(s.value.text().into_owned());
        }
        Expression::ArrayExpression(arr) => {
            for el in &arr.elements {
                if let Some(expr) = el.as_expression() {
                    collect_all_string_values(expr, values);
                }
            }
        }
        Expression::ObjectExpression(obj) => {
            for prop in &obj.properties {
                if let ObjectPropertyKind::ObjectProperty(p) = prop {
                    collect_all_string_values(&p.value, values);
                }
            }
        }
        _ => {}
    }
}

/// Convert a `PropertyKey` to a `String`.
fn property_key_to_string(key: &PropertyKey) -> Option<String> {
    match key {
        PropertyKey::StaticIdentifier(id) => Some(id.name.to_string()),
        PropertyKey::StringLiteral(s) => Some(s.value.text().into_owned()),
        _ => None,
    }
}

/// Extract keys of an object at a nested property path.
fn get_nested_object_keys(obj: &ObjectExpression, path: &[&str]) -> Option<Vec<String>> {
    if path.is_empty() {
        return None;
    }
    let prop = find_property(obj, path[0])?;
    if path.len() == 1 {
        if let Expression::ObjectExpression(nested) = &prop.value {
            let keys = nested
                .properties
                .iter()
                .filter_map(|p| {
                    if let ObjectPropertyKind::ObjectProperty(p) = p {
                        property_key_to_string(&p.key)
                    } else {
                        None
                    }
                })
                .collect();
            return Some(keys);
        }
        return None;
    }
    if let Expression::ObjectExpression(nested) = &prop.value {
        get_nested_object_keys(nested, &path[1..])
    } else {
        None
    }
}

/// Navigate a nested property path and return the raw expression at the end.
fn get_nested_expression<'a>(
    obj: &'a ObjectExpression<'a>,
    path: &[&str],
) -> Option<&'a Expression<'a>> {
    if path.is_empty() {
        return None;
    }
    let prop = find_property(obj, path[0])?;
    if path.len() == 1 {
        return Some(&prop.value);
    }
    if let Expression::ObjectExpression(nested) = &prop.value {
        get_nested_expression(nested, &path[1..])
    } else {
        None
    }
}

/// Navigate a nested path and extract a string, string array, or object string/array values.
fn get_nested_string_or_array(
    obj: &ObjectExpression,
    path: &[&str],
    scope: PathScope<'_>,
) -> Option<Vec<String>> {
    if path.is_empty() {
        return None;
    }
    if path.len() == 1 {
        let prop = find_property(obj, path[0])?;
        return Some(string_or_array_in(&prop.value, scope));
    }
    let prop = find_property(obj, path[0])?;
    if let Expression::ObjectExpression(nested) = &prop.value {
        get_nested_string_or_array(nested, &path[1..], scope)
    } else {
        None
    }
}

/// Convert an expression to a `Vec<String>`, handling string, array, object-with-string/array values,
/// and Webpack 5 entry descriptors (`{ import: "..." }`).
///
/// Array elements that are object literals are inspected for an `input` property
/// (Angular CLI schema for `styles`/`scripts`/`polyfills`:
/// `{ "input": "src/x.scss", "bundleName": "x", "inject": false }`). Extracting
/// `input` prevents object-form entries from being silently dropped. See #126.
pub(crate) fn expression_to_string_or_array(expr: &Expression) -> Vec<String> {
    string_or_array_in(expr, PathScope::Bare)
}

fn string_or_array_in(expr: &Expression, scope: PathScope<'_>) -> Vec<String> {
    match expr {
        Expression::StringLiteral(s) => vec![s.value.text().into_owned()],
        Expression::TemplateLiteral(t) if t.expressions.is_empty() => t
            .quasis
            .first()
            .map(|q| vec![q.value.raw.to_string()])
            .unwrap_or_default(),
        Expression::ArrayExpression(arr) => arr
            .elements
            .iter()
            .filter_map(|el| el.as_expression())
            .flat_map(|e| match e {
                Expression::ObjectExpression(obj) => find_property(obj, "input")
                    .map(|p| string_or_array_in(&p.value, scope))
                    .unwrap_or_default(),
                _ => path_string_in(e, scope).into_iter().collect(),
            })
            .collect(),
        Expression::ObjectExpression(obj) => obj
            .properties
            .iter()
            .flat_map(|p| {
                if let ObjectPropertyKind::ObjectProperty(p) = p {
                    match &p.value {
                        Expression::ArrayExpression(_) => string_or_array_in(&p.value, scope),
                        Expression::ObjectExpression(value_obj) => {
                            find_property(value_obj, "import")
                                .map(|import_prop| string_or_array_in(&import_prop.value, scope))
                                .unwrap_or_default()
                        }
                        _ => path_string_in(&p.value, scope).into_iter().collect(),
                    }
                } else {
                    Vec::new()
                }
            })
            .collect(),
        _ => path_string_in(expr, scope).into_iter().collect(),
    }
}

/// Collect `require('...')` argument strings from an expression.
fn collect_require_sources(expr: &Expression) -> Vec<String> {
    let mut sources = Vec::new();
    match expr {
        Expression::CallExpression(call) if is_require_call(call) => {
            if let Some(s) = get_require_source(call) {
                sources.push(s);
            }
        }
        Expression::ArrayExpression(arr) => {
            for el in &arr.elements {
                if let Some(inner) = el.as_expression() {
                    match inner {
                        Expression::CallExpression(call) if is_require_call(call) => {
                            if let Some(s) = get_require_source(call) {
                                sources.push(s);
                            }
                        }
                        Expression::ArrayExpression(sub_arr) => {
                            if let Some(first) = sub_arr.elements.first()
                                && let Some(Expression::CallExpression(call)) =
                                    first.as_expression()
                                && is_require_call(call)
                                && let Some(s) = get_require_source(call)
                            {
                                sources.push(s);
                            }
                        }
                        _ => {}
                    }
                }
            }
        }
        _ => {}
    }
    sources
}

/// Check if a call expression is `require(...)`.
pub(crate) fn is_require_call(call: &CallExpression) -> bool {
    matches!(&call.callee, Expression::Identifier(id) if id.name == "require")
}

/// Get the first string argument of a `require()` call.
pub(crate) fn get_require_source(call: &CallExpression) -> Option<String> {
    call.arguments.first().and_then(|arg| {
        if let Argument::StringLiteral(s) = arg {
            Some(s.value.text().into_owned())
        } else {
            None
        }
    })
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::path::PathBuf;

    fn js_path() -> PathBuf {
        PathBuf::from("config.js")
    }

    fn ts_path() -> PathBuf {
        PathBuf::from("config.ts")
    }

    #[test]
    fn extract_config_array_tuple_heads_reads_first_string_of_each_tuple() {
        let source = r#"
            export default defineNuxtConfig({
                modules: ["@nuxt/image", ["@nuxt/content", { watch: false }], [someModule, {}], []]
            });
        "#;
        assert_eq!(
            extract_config_array_tuple_heads(source, &ts_path(), &["modules"]),
            vec!["@nuxt/content".to_string()]
        );
    }

    #[test]
    fn extract_lazy_imports_bare_arrows() {
        let source = r"
            import { defineConfig } from '@adonisjs/core/app'
            export default defineConfig({
                preloads: [
                    () => import('#start/routes'),
                    () => import('#start/kernel'),
                ],
            })
        ";
        let specs = extract_lazy_imports_in_array(source, &ts_path(), &["preloads"]);
        assert_eq!(specs, vec!["#start/routes", "#start/kernel"]);
    }

    #[test]
    fn extract_lazy_imports_object_form_with_file_key() {
        let source = r"
            export default defineConfig({
                providers: [
                    () => import('@adonisjs/core/providers/app_provider'),
                    {
                        file: () => import('@adonisjs/core/providers/repl_provider'),
                        environment: ['repl', 'test'],
                    },
                ],
            })
        ";
        let specs = extract_lazy_imports_in_array(source, &ts_path(), &["providers"]);
        assert_eq!(
            specs,
            vec![
                "@adonisjs/core/providers/app_provider",
                "@adonisjs/core/providers/repl_provider",
            ]
        );
    }

    #[test]
    fn extract_lazy_imports_block_body_with_return() {
        let source = r"
            export default defineConfig({
                commands: [
                    () => { return import('@adonisjs/core/commands') },
                ],
            })
        ";
        let specs = extract_lazy_imports_in_array(source, &ts_path(), &["commands"]);
        assert_eq!(specs, vec!["@adonisjs/core/commands"]);
    }

    #[test]
    fn extract_lazy_imports_skips_unknown_element_shapes() {
        let source = r"
            export default defineConfig({
                commands: [
                    'string-entry',
                    42,
                    { other: 'value' },
                    () => import('@adonisjs/lucid/commands'),
                ],
            })
        ";
        let specs = extract_lazy_imports_in_array(source, &ts_path(), &["commands"]);
        assert_eq!(specs, vec!["@adonisjs/lucid/commands"]);
    }

    #[test]
    fn extract_lazy_imports_missing_property_returns_empty() {
        let source = r"
            export default defineConfig({
                preloads: [() => import('#start/routes')],
            })
        ";
        let specs = extract_lazy_imports_in_array(source, &ts_path(), &["providers"]);
        assert!(specs.is_empty());
    }

    #[test]
    fn extract_imports_basic() {
        let source = r"
            import foo from 'foo-pkg';
            import { bar } from '@scope/bar';
            export default {};
        ";
        let imports = extract_imports(source, &js_path());
        assert_eq!(imports, vec!["foo-pkg", "@scope/bar"]);
    }

    #[test]
    fn extract_default_export_object_property() {
        let source = r#"export default { testDir: "./tests" };"#;
        let val = extract_config_string(source, &js_path(), &["testDir"]);
        assert_eq!(val, Some("./tests".to_string()));
    }

    #[test]
    fn extract_define_config_property() {
        let source = r#"
            import { defineConfig } from 'vitest/config';
            export default defineConfig({
                test: {
                    include: ["**/*.test.ts", "**/*.spec.ts"],
                    setupFiles: ["./test/setup.ts"]
                }
            });
        "#;
        let include = extract_config_string_array(source, &ts_path(), &["test", "include"]);
        assert_eq!(include, vec!["**/*.test.ts", "**/*.spec.ts"]);

        let setup = extract_config_string_array(source, &ts_path(), &["test", "setupFiles"]);
        assert_eq!(setup, vec!["./test/setup.ts"]);
    }

    #[test]
    fn extract_module_exports_property() {
        let source = r#"module.exports = { testEnvironment: "jsdom" };"#;
        let val = extract_config_string(source, &js_path(), &["testEnvironment"]);
        assert_eq!(val, Some("jsdom".to_string()));
    }

    #[test]
    fn extract_nested_string_array() {
        let source = r#"
            export default {
                resolve: {
                    alias: {
                        "@": "./src"
                    }
                },
                test: {
                    include: ["src/**/*.test.ts"]
                }
            };
        "#;
        let include = extract_config_string_array(source, &js_path(), &["test", "include"]);
        assert_eq!(include, vec!["src/**/*.test.ts"]);
    }

    #[test]
    fn extract_addons_array() {
        let source = r#"
            export default {
                addons: [
                    "@storybook/addon-a11y",
                    "@storybook/addon-docs",
                    "@storybook/addon-links"
                ]
            };
        "#;
        let addons = extract_config_property_strings(source, &ts_path(), "addons");
        assert_eq!(
            addons,
            vec![
                "@storybook/addon-a11y",
                "@storybook/addon-docs",
                "@storybook/addon-links"
            ]
        );
    }

    #[test]
    fn handle_empty_config() {
        let source = "";
        let result = extract_config_string(source, &js_path(), &["key"]);
        assert_eq!(result, None);
    }

    #[test]
    fn object_keys_postcss_plugins() {
        let source = r"
            module.exports = {
                plugins: {
                    autoprefixer: {},
                    tailwindcss: {},
                    'postcss-import': {}
                }
            };
        ";
        let keys = extract_config_object_keys(source, &js_path(), &["plugins"]);
        assert_eq!(keys, vec!["autoprefixer", "tailwindcss", "postcss-import"]);
    }

    #[test]
    fn object_keys_nested_path() {
        let source = r"
            export default {
                build: {
                    plugins: {
                        minify: {},
                        compress: {}
                    }
                }
            };
        ";
        let keys = extract_config_object_keys(source, &js_path(), &["build", "plugins"]);
        assert_eq!(keys, vec!["minify", "compress"]);
    }

    #[test]
    fn object_keys_empty_object() {
        let source = r"export default { plugins: {} };";
        let keys = extract_config_object_keys(source, &js_path(), &["plugins"]);
        assert!(keys.is_empty());
    }

    #[test]
    fn object_keys_non_object_returns_empty() {
        let source = r#"export default { plugins: ["a", "b"] };"#;
        let keys = extract_config_object_keys(source, &js_path(), &["plugins"]);
        assert!(keys.is_empty());
    }

    #[test]
    fn string_or_array_single_string() {
        let source = r#"export default { entry: "./src/index.js" };"#;
        let result = extract_config_string_or_array(source, &js_path(), &["entry"]);
        assert_eq!(result, vec!["./src/index.js"]);
    }

    #[test]
    fn string_or_array_array() {
        let source = r#"export default { entry: ["./src/a.js", "./src/b.js"] };"#;
        let result = extract_config_string_or_array(source, &js_path(), &["entry"]);
        assert_eq!(result, vec!["./src/a.js", "./src/b.js"]);
    }

    #[test]
    fn string_or_array_object_values() {
        let source =
            r#"export default { entry: { main: "./src/main.js", vendor: "./src/vendor.js" } };"#;
        let result = extract_config_string_or_array(source, &js_path(), &["entry"]);
        assert_eq!(result, vec!["./src/main.js", "./src/vendor.js"]);
    }

    #[test]
    fn array_or_object_string_or_array_reads_each_array_element() {
        let source = r#"
            const shared = { format: ["esm"] };
            export default defineConfig([
                { entry: "./src/a.ts" },
                ({ ...shared, entry: { b: "./src/b.ts" } }),
                { entry: ["./src/c.ts"] } satisfies Options,
                { format: ["cjs"] },
                shared,
            ] as Options[]);
        "#;
        let result = extract_config_array_or_object_string_or_array(source, &ts_path(), &["entry"]);
        assert_eq!(result, vec!["./src/a.ts", "./src/b.ts", "./src/c.ts"]);
    }

    #[test]
    fn array_or_object_string_or_array_falls_back_to_config_object() {
        let source = r#"export default defineConfig({ entry: { main: "./src/main.ts" } });"#;
        let result = extract_config_array_or_object_string_or_array(source, &ts_path(), &["entry"]);
        assert_eq!(result, vec!["./src/main.ts"]);
    }

    #[test]
    fn string_or_array_object_array_values() {
        let source = r#"export default { entry: { app: ["./src/polyfill.js", "./src/app.js"] } };"#;
        let result = extract_config_string_or_array(source, &js_path(), &["entry"]);
        assert_eq!(result, vec!["./src/polyfill.js", "./src/app.js"]);
    }

    #[test]
    fn string_or_array_webpack_entry_descriptors() {
        let source = r#"
            export default {
                entry: {
                    app: {
                        import: "./src/app.js",
                        filename: "pages/app.js",
                        dependOn: "shared",
                    },
                    admin: {
                        import: ["./src/admin-polyfill.js", "./src/admin.js"],
                        runtime: "runtime",
                    },
                    shared: ["react", "react-dom"],
                },
            };
        "#;
        let result = extract_config_string_or_array(source, &js_path(), &["entry"]);
        assert_eq!(
            result,
            vec![
                "./src/app.js",
                "./src/admin-polyfill.js",
                "./src/admin.js",
                "react",
                "react-dom"
            ]
        );
    }

    #[test]
    fn string_or_array_nested_path() {
        let source = r#"
            export default {
                build: {
                    rollupOptions: {
                        input: ["./index.html", "./about.html"]
                    }
                }
            };
        "#;
        let result = extract_config_string_or_array(
            source,
            &js_path(),
            &["build", "rollupOptions", "input"],
        );
        assert_eq!(result, vec!["./index.html", "./about.html"]);
    }

    #[test]
    fn string_or_array_template_literal() {
        let source = r"export default { entry: `./src/index.js` };";
        let result = extract_config_string_or_array(source, &js_path(), &["entry"]);
        assert_eq!(result, vec!["./src/index.js"]);
    }

    #[test]
    fn string_or_array_object_path_helper_values() {
        let source = r#"
            import { resolve, join } from "node:path";
            import path from "node:path";
            export default {
                build: {
                    rollupOptions: {
                        input: {
                            app: resolve(__dirname, "src/app.ts"),
                            modal: path.resolve(__dirname, "src/modal.ts"),
                            tabs: join(__dirname, "src/tabs.ts"),
                            styles: resolve(__dirname, "src/index.css"),
                        },
                    },
                },
            };
        "#;
        let result = extract_config_string_or_array(
            source,
            &js_path(),
            &["build", "rollupOptions", "input"],
        );
        assert_eq!(
            result,
            vec!["src/app.ts", "src/modal.ts", "src/tabs.ts", "src/index.css"]
        );
    }

    #[test]
    fn string_or_array_array_path_helper_values() {
        let source = r#"
            import { resolve } from "node:path";
            export default {
                build: {
                    rollupOptions: {
                        input: [resolve(__dirname, "src/a.ts"), "./src/b.ts"],
                    },
                },
            };
        "#;
        let result = extract_config_string_or_array(
            source,
            &js_path(),
            &["build", "rollupOptions", "input"],
        );
        assert_eq!(result, vec!["src/a.ts", "./src/b.ts"]);
    }

    #[test]
    fn string_or_array_top_level_path_helper_call() {
        let source = r#"
            import { resolve } from "node:path";
            export default { build: { lib: { entry: resolve(__dirname, "src/index.ts") } } };
        "#;
        let result = extract_config_string_or_array(source, &js_path(), &["build", "lib", "entry"]);
        assert_eq!(result, vec!["src/index.ts"]);
    }

    #[test]
    fn string_or_array_import_meta_dirname_anchor() {
        let source = r#"
            import { resolve } from "node:path";
            export default {
                build: { lib: { entry: resolve(import.meta.dirname, "src/index.ts") } },
            };
        "#;
        let result = extract_config_string_or_array(source, &ts_path(), &["build", "lib", "entry"]);
        assert_eq!(result, vec!["src/index.ts"]);
    }

    #[test]
    fn string_or_array_non_literal_path_helper_args_dropped() {
        let source = r#"
            import { resolve } from "node:path";
            export default { build: { lib: { entry: resolve(baseDir, "src/index.ts") } } };
        "#;
        let result = extract_config_string_or_array(source, &js_path(), &["build", "lib", "entry"]);
        assert!(
            result.is_empty(),
            "non-literal path-helper args must be dropped: {result:?}"
        );
    }

    #[test]
    fn require_strings_array() {
        let source = r"
            module.exports = {
                plugins: [
                    require('autoprefixer'),
                    require('postcss-import')
                ]
            };
        ";
        let deps = extract_config_require_strings(source, &js_path(), "plugins");
        assert_eq!(deps, vec!["autoprefixer", "postcss-import"]);
    }

    #[test]
    fn require_strings_with_tuples() {
        let source = r"
            module.exports = {
                plugins: [
                    require('autoprefixer'),
                    [require('postcss-preset-env'), { stage: 3 }]
                ]
            };
        ";
        let deps = extract_config_require_strings(source, &js_path(), "plugins");
        assert_eq!(deps, vec!["autoprefixer", "postcss-preset-env"]);
    }

    #[test]
    fn require_strings_empty_array() {
        let source = r"module.exports = { plugins: [] };";
        let deps = extract_config_require_strings(source, &js_path(), "plugins");
        assert!(deps.is_empty());
    }

    #[test]
    fn require_strings_no_require_calls() {
        let source = r#"module.exports = { plugins: ["a", "b"] };"#;
        let deps = extract_config_require_strings(source, &js_path(), "plugins");
        assert!(deps.is_empty());
    }

    #[test]
    fn extract_aliases_from_object_with_file_url_to_path() {
        let source = r#"
            import { defineConfig } from 'vite';
            import { fileURLToPath, URL } from 'node:url';

            export default defineConfig({
                resolve: {
                    alias: {
                        "@": fileURLToPath(new URL("./src", import.meta.url))
                    }
                }
            });
        "#;

        let aliases = extract_config_aliases(source, &ts_path(), &["resolve", "alias"]);
        assert_eq!(aliases, vec![("@".to_string(), "./src".to_string())]);
    }

    #[test]
    fn extract_aliases_from_array_form() {
        let source = r#"
            export default {
                resolve: {
                    alias: [
                        { find: "@", replacement: "./src" },
                        { find: "$utils", replacement: "src/lib/utils" }
                    ]
                }
            };
        "#;

        let aliases = extract_config_aliases(source, &ts_path(), &["resolve", "alias"]);
        assert_eq!(
            aliases,
            vec![
                ("@".to_string(), "./src".to_string()),
                ("$utils".to_string(), "src/lib/utils".to_string())
            ]
        );
    }

    #[test]
    fn extract_aliases_from_object_with_array_values() {
        let source = r#"
            ({
                compilerOptions: {
                    paths: {
                        "@/*": ["./src/*"],
                        "@shared/*": ["./shared/*", "./fallback/*"]
                    }
                }
            })
        "#;

        let aliases = extract_config_aliases(source, &js_path(), &["compilerOptions", "paths"]);
        assert_eq!(
            aliases,
            vec![
                ("@/*".to_string(), "./src/*".to_string()),
                ("@shared/*".to_string(), "./shared/*".to_string())
            ]
        );
    }

    #[test]
    fn extract_array_object_strings_mixed_forms() {
        let source = r#"
            export default {
                components: [
                    "~/components",
                    { path: "@/feature-components" }
                ]
            };
        "#;

        let values =
            extract_config_array_object_strings(source, &ts_path(), &["components"], "path");
        assert_eq!(
            values,
            vec![
                "~/components".to_string(),
                "@/feature-components".to_string()
            ]
        );
    }

    #[test]
    fn extract_config_plugin_option_string_from_json() {
        let source = r#"{
            "expo": {
                "plugins": [
                    ["expo-router", { "root": "src/app" }]
                ]
            }
        }"#;

        let value = extract_config_plugin_option_string(
            source,
            &json_path(),
            &["expo", "plugins"],
            "expo-router",
            "root",
        );

        assert_eq!(value, Some("src/app".to_string()));
    }

    #[test]
    fn extract_config_plugin_option_string_from_top_level_plugins() {
        let source = r#"{
            "plugins": [
                ["expo-router", { "root": "./src/routes" }]
            ]
        }"#;

        let value = extract_config_plugin_option_string_from_paths(
            source,
            &json_path(),
            &[&["plugins"], &["expo", "plugins"]],
            "expo-router",
            "root",
        );

        assert_eq!(value, Some("./src/routes".to_string()));
    }

    #[test]
    fn extract_config_plugin_option_string_from_ts_config() {
        let source = r"
            export default {
                expo: {
                    plugins: [
                        ['expo-router', { root: './src/app' }]
                    ]
                }
            };
        ";

        let value = extract_config_plugin_option_string(
            source,
            &ts_path(),
            &["expo", "plugins"],
            "expo-router",
            "root",
        );

        assert_eq!(value, Some("./src/app".to_string()));
    }

    #[test]
    fn extract_config_plugin_option_string_returns_none_when_plugin_missing() {
        let source = r#"{
            "expo": {
                "plugins": [
                    ["expo-font", {}]
                ]
            }
        }"#;

        let value = extract_config_plugin_option_string(
            source,
            &json_path(),
            &["expo", "plugins"],
            "expo-router",
            "root",
        );

        assert_eq!(value, None);
    }

    #[test]
    fn vite_react_babel_dependencies_extract_plain_tuple_and_prefixed_entries() {
        let source = r#"
            import react from "@vitejs/plugin-react";

            export default defineConfig({
                plugins: [
                    react({
                        babel: {
                            plugins: [
                                "babel-plugin-plain",
                                ["module:@preact/signals-react-transform", { mode: "auto" }],
                            ],
                            presets: [["@babel/preset-react", { runtime: "automatic" }]],
                        },
                    }),
                ],
            });
        "#;

        let deps = extract_vite_plugin_option_dependencies(source, &ts_path());

        assert_eq!(
            deps,
            vec![
                "babel-plugin-plain".to_string(),
                "@preact/signals-react-transform".to_string(),
                "@babel/preset-react".to_string(),
            ]
        );
    }

    #[test]
    fn vite_react_babel_dependencies_support_default_alias_import() {
        let source = r#"
            import { default as viteReact } from "@vitejs/plugin-react";

            export default {
                plugins: [
                    viteReact({
                        babel: {
                            plugins: [["module:@scope/pkg/plugin", {}]],
                        },
                    }),
                ],
            };
        "#;

        let deps = extract_vite_plugin_option_dependencies(source, &ts_path());

        assert_eq!(deps, vec!["@scope/pkg".to_string()]);
    }

    #[test]
    fn vite_react_babel_dependencies_ignore_unrelated_plugin_calls() {
        let source = r#"
            import vue from "@vitejs/plugin-vue";

            export default {
                plugins: [
                    vue({
                        babel: {
                            plugins: ["@preact/signals-react-transform"],
                        },
                    }),
                ],
            };
        "#;

        let deps = extract_vite_plugin_option_dependencies(source, &ts_path());

        assert!(deps.is_empty());
    }

    #[test]
    fn vite_react_babel_dependencies_skip_relative_and_protocol_entries() {
        let source = r#"
            import react from "@vitejs/plugin-react";

            export default {
                plugins: [
                    react({
                        babel: {
                            plugins: ["./local-plugin", "module:./local-prefixed", "http://example.com/plugin"],
                        },
                    }),
                ],
            };
        "#;

        let deps = extract_vite_plugin_option_dependencies(source, &ts_path());

        assert!(deps.is_empty());
    }

    #[test]
    fn normalize_config_path_relative_to_root() {
        let config_path = PathBuf::from("/project/vite.config.ts");
        let root = PathBuf::from("/project");

        assert_eq!(
            normalize_config_path("./src/lib", &config_path, &root),
            Some("src/lib".to_string())
        );
        assert_eq!(
            normalize_config_path("/src/lib", &config_path, &root),
            Some("src/lib".to_string())
        );
    }

    #[test]
    fn normalize_config_path_mixed_separators_and_parent_dirs() {
        let config_path = PathBuf::from("/project/config/vite.config.ts");
        let root = PathBuf::from("/project");

        assert_eq!(
            normalize_config_path(".\\src\\..\\app\\lib", &config_path, &root),
            Some("config/app/lib".to_string())
        );
    }

    /// Issue #2806: a literal absolute path under the project root is read as
    /// absolute, not joined onto the root a second time.
    #[test]
    fn normalize_config_path_reads_an_absolute_path_under_root_as_absolute() {
        let root = std::env::temp_dir().join("fallow-2806-project");
        let config_path = root.join("vite.config.ts");
        let absolute = path_to_config_string(&root.join("src").join("lib"));

        assert_eq!(
            normalize_config_path(&absolute, &config_path, &root),
            Some("src/lib".to_string())
        );
        assert_eq!(
            normalize_filesystem_config_path(&absolute, &config_path, &root),
            Some("src/lib".to_string())
        );
    }

    /// Vite reads a leading `/` as relative to the root when the value is the
    /// root itself, or when `<root>/<root>` is a directory (its `rootInRoot`
    /// rule). A project checked out at `/src` with a `src/` folder and the
    /// alias `'@': '/src'` resolves to `/src/src`.
    #[cfg(unix)]
    #[test]
    fn normalize_config_path_keeps_the_vite_root_in_root_reading() {
        let temp = tempfile::tempdir().expect("temp dir");
        let root = temp.path().join("src");
        std::fs::create_dir_all(&root).expect("root dir");
        let config_path = root.join("vite.config.ts");
        let root_string = path_to_config_string(&root);
        let nested = root_string.trim_start_matches('/').to_string();
        let under = format!("{root_string}/lib");

        assert_eq!(
            normalize_config_path(&root_string, &config_path, &root),
            Some(nested.clone())
        );
        assert_eq!(
            normalize_config_path(&under, &config_path, &root),
            Some("lib".to_string())
        );

        std::fs::create_dir_all(root.join(&nested)).expect("root-in-root dir");
        assert_eq!(
            normalize_config_path(&under, &config_path, &root),
            Some(format!("{nested}/lib"))
        );
        assert_eq!(
            normalize_filesystem_config_path(&under, &config_path, &root),
            Some("lib".to_string())
        );
    }

    /// Issue #2806: a reader with filesystem semantics reads a leading `/` as
    /// an absolute path, so a path outside the project root resolves to nothing.
    #[test]
    fn normalize_filesystem_config_path_does_not_read_a_leading_slash_as_root_relative() {
        let config_path = PathBuf::from("/project/config/webpack.config.js");
        let root = PathBuf::from("/project");

        assert_eq!(
            normalize_filesystem_config_path("/src/lib", &config_path, &root),
            None
        );
        assert_eq!(
            normalize_filesystem_config_path("./src/lib", &config_path, &root),
            Some("config/src/lib".to_string())
        );
        assert_eq!(
            normalize_config_path("/src/lib", &config_path, &root),
            Some("src/lib".to_string())
        );
    }

    #[test]
    fn normalize_config_path_leading_slash_stays_project_relative() {
        let config_path = PathBuf::from("/project/vite.config.ts");
        let root = PathBuf::from("/project");

        assert_eq!(
            normalize_config_path("/src\\lib", &config_path, &root),
            Some("src/lib".to_string())
        );
    }

    #[test]
    fn json_wrapped_in_parens_string() {
        let source = r#"({"extends": "@tsconfig/node18/tsconfig.json"})"#;
        let val = extract_config_string(source, &js_path(), &["extends"]);
        assert_eq!(val, Some("@tsconfig/node18/tsconfig.json".to_string()));
    }

    #[test]
    fn json_wrapped_in_parens_nested_array() {
        let source =
            r#"({"compilerOptions": {"types": ["node", "jest"]}, "include": ["src/**/*"]})"#;
        let types = extract_config_string_array(source, &js_path(), &["compilerOptions", "types"]);
        assert_eq!(types, vec!["node", "jest"]);

        let include = extract_config_string_array(source, &js_path(), &["include"]);
        assert_eq!(include, vec!["src/**/*"]);
    }

    #[test]
    fn json_wrapped_in_parens_object_keys() {
        let source = r#"({"plugins": {"autoprefixer": {}, "tailwindcss": {}}})"#;
        let keys = extract_config_object_keys(source, &js_path(), &["plugins"]);
        assert_eq!(keys, vec!["autoprefixer", "tailwindcss"]);
    }

    fn json_path() -> PathBuf {
        PathBuf::from("config.json")
    }

    #[test]
    fn json_file_parsed_correctly() {
        let source = r#"{"key": "value", "list": ["a", "b"]}"#;
        let val = extract_config_string(source, &json_path(), &["key"]);
        assert_eq!(val, Some("value".to_string()));

        let list = extract_config_string_array(source, &json_path(), &["list"]);
        assert_eq!(list, vec!["a", "b"]);
    }

    #[test]
    fn jsonc_file_parsed_correctly() {
        let source = r#"{"key": "value"}"#;
        let path = PathBuf::from("tsconfig.jsonc");
        let val = extract_config_string(source, &path, &["key"]);
        assert_eq!(val, Some("value".to_string()));
    }

    #[test]
    fn jsonc_file_ending_in_line_comment_parsed_correctly() {
        let source = "{\"key\": \"value\"}\n// trailing comment, no final newline";
        let path = PathBuf::from(".oxlintrc.jsonc");
        let val = extract_config_string(source, &path, &["key"]);
        assert_eq!(val, Some("value".to_string()));
    }

    #[test]
    fn extract_define_config_arrow_function() {
        let source = r#"
            import { defineConfig } from 'vite';
            export default defineConfig(() => ({
                test: {
                    include: ["**/*.test.ts"]
                }
            }));
        "#;
        let include = extract_config_string_array(source, &ts_path(), &["test", "include"]);
        assert_eq!(include, vec!["**/*.test.ts"]);
    }

    /// A block-bodied callback is the common shape for configs that branch on
    /// the build mode. Only the concise arrow used to be traversed, so every
    /// such config extracted nothing at all (issue #2005).
    #[test]
    fn extract_define_config_block_body_arrow_function() {
        let source = r#"
            import { defineConfig } from 'vite';
            export default defineConfig(({ mode }) => {
                const isProduction = mode === 'production';
                return {
                    test: {
                        environment: "jsdom",
                        setupFiles: "./tests/setup.ts"
                    },
                    base: isProduction ? '/app/' : '/'
                };
            });
        "#;
        assert_eq!(
            extract_config_string(source, &ts_path(), &["test", "environment"]).as_deref(),
            Some("jsdom")
        );
        assert_eq!(
            extract_config_string(source, &ts_path(), &["test", "setupFiles"]).as_deref(),
            Some("./tests/setup.ts")
        );
    }

    #[test]
    fn extract_define_config_function_expression() {
        let source = r#"
            import { defineConfig } from 'vite';
            export default defineConfig(function () {
                return { test: { environment: "happy-dom" } };
            });
        "#;
        assert_eq!(
            extract_config_string(source, &ts_path(), &["test", "environment"]).as_deref(),
            Some("happy-dom")
        );
    }

    /// A wrapper takes the config first and its own options after it. Scanning
    /// the argument list for the first object literal read the options object
    /// instead, which is the exact shape the @sentry/nextjs wizard emits.
    #[test]
    fn wrapper_options_object_does_not_shadow_named_config_arg() {
        let source = r#"
            const nextConfig = { pageExtensions: ["page.tsx"] };
            module.exports = withSentryConfig(nextConfig, { org: "o", project: "p", silent: true });
        "#;
        assert_eq!(
            extract_config_string_array(source, &js_path(), &["pageExtensions"]),
            vec!["page.tsx"]
        );
    }

    #[test]
    fn wrapper_options_object_does_not_shadow_named_config_arg_esm() {
        let source = r#"
            const nextConfig = { pageExtensions: ["page.tsx"] };
            export default withSentryConfig(nextConfig, { org: "o", project: "p" });
        "#;
        assert_eq!(
            extract_config_string_array(source, &ts_path(), &["pageExtensions"]),
            vec!["page.tsx"]
        );
    }

    /// Vitest's documented way to share a Vite config with the test runner.
    #[test]
    fn merge_config_extracts_nested_define_config_object() {
        let source = r#"
            import { defineConfig, mergeConfig } from 'vitest/config';
            import viteConfig from './vite.config';
            export default mergeConfig(viteConfig, defineConfig({
                test: { environment: "jsdom" }
            }));
        "#;
        assert_eq!(
            extract_config_string(source, &ts_path(), &["test", "environment"]).as_deref(),
            Some("jsdom")
        );
    }

    #[test]
    fn define_config_wrapping_merge_config_extracts_object() {
        let source = r#"
            import { defineConfig, mergeConfig } from 'vitest/config';
            import base from './base';
            export default defineConfig(mergeConfig(base, { test: { environment: "jsdom" } }));
        "#;
        assert_eq!(
            extract_config_string(source, &ts_path(), &["test", "environment"]).as_deref(),
            Some("jsdom")
        );
    }

    /// Guards against "prefer an identifier-resolved const over any object
    /// literal", which would change which object every plain config reads.
    #[test]
    fn inline_object_at_argument_zero_still_wins() {
        let source = r#"
            const unrelated = { pageExtensions: ["wrong.tsx"] };
            module.exports = withSentryConfig({ pageExtensions: ["right.tsx"] }, { org: "o" });
        "#;
        assert_eq!(
            extract_config_string_array(source, &js_path(), &["pageExtensions"]),
            vec!["right.tsx"]
        );
    }

    /// Vite's documented shape for switching config by command: every branch
    /// returns and the callback has no return of its own, so extraction has to
    /// descend to find anything at all.
    #[test]
    fn conditional_config_callback_extracts_branch_return() {
        let source = r#"
            import { defineConfig } from 'vite';
            export default defineConfig(({ command }) => {
                if (command === "serve") {
                    return { test: { environment: "jsdom" } };
                } else {
                    return { test: { environment: "node" } };
                }
            });
        "#;
        assert_eq!(
            extract_config_string(source, &ts_path(), &["test", "environment"]).as_deref(),
            Some("jsdom"),
            "with no top-level return, the first branch in source order wins"
        );
    }

    #[test]
    fn try_block_return_is_extracted() {
        let source = r#"
            export default (() => {
                try {
                    return { test: { environment: "jsdom" } };
                } catch (e) {
                    return { test: { environment: "node" } };
                }
            });
        "#;
        assert_eq!(
            extract_config_string(source, &ts_path(), &["test", "environment"]).as_deref(),
            Some("jsdom")
        );
    }

    #[test]
    fn switch_case_return_is_extracted() {
        let source = r#"
            import { defineConfig } from 'vite';
            export default defineConfig(({ mode }) => {
                switch (mode) {
                    case "test":
                        return { test: { environment: "jsdom" } };
                    default:
                        return { test: { environment: "node" } };
                }
            });
        "#;
        assert_eq!(
            extract_config_string(source, &ts_path(), &["test", "environment"]).as_deref(),
            Some("jsdom")
        );
    }

    /// A guard clause followed by the real return must resolve to the trailing
    /// return. Descending into branches before checking this level regressed it:
    /// the guard's early return shadowed the actual config.
    #[test]
    fn guard_clause_does_not_shadow_the_top_level_return() {
        let source = r#"
            import { defineConfig } from 'vite';
            export default defineConfig(({ mode }) => {
                if (!mode) {
                    return {};
                }
                return { test: { environment: "jsdom" } };
            });
        "#;
        assert_eq!(
            extract_config_string(source, &ts_path(), &["test", "environment"]).as_deref(),
            Some("jsdom"),
            "a return at the callback's own level is the main config"
        );
    }

    /// The same precedence with an else-if chain, where every branch returns and
    /// the trailing return is the default config.
    #[test]
    fn else_if_chain_does_not_shadow_the_top_level_return() {
        let source = r#"
            import { defineConfig } from 'vite';
            export default defineConfig(({ mode }) => {
                if (mode === "a") {
                    return { base: "/a/" };
                } else if (mode === "b") {
                    return { base: "/b/" };
                }
                return { test: { environment: "jsdom" } };
            });
        "#;
        assert_eq!(
            extract_config_string(source, &ts_path(), &["test", "environment"]).as_deref(),
            Some("jsdom")
        );
    }

    #[test]
    fn extract_config_from_default_export_function_declaration() {
        let source = r#"
            export default function createConfig() {
                return {
                    clientModules: ["./src/client/global.js"]
                };
            }
        "#;

        let client_modules = extract_config_string_array(source, &ts_path(), &["clientModules"]);
        assert_eq!(client_modules, vec!["./src/client/global.js"]);
    }

    #[test]
    fn extract_config_from_default_export_async_function_declaration() {
        let source = r#"
            export default async function createConfigAsync() {
                return {
                    docs: {
                        path: "knowledge"
                    }
                };
            }
        "#;

        let docs_path = extract_config_string(source, &ts_path(), &["docs", "path"]);
        assert_eq!(docs_path, Some("knowledge".to_string()));
    }

    #[test]
    fn extract_config_from_exported_arrow_function_identifier() {
        let source = r#"
            const config = async () => {
                return {
                    themes: ["classic"]
                };
            };

            export default config;
        "#;

        let themes = extract_config_shallow_strings(source, &ts_path(), "themes");
        assert_eq!(themes, vec!["classic"]);
    }

    #[test]
    fn module_exports_nested_string() {
        let source = r#"
            module.exports = {
                resolve: {
                    alias: {
                        "@": "./src"
                    }
                }
            };
        "#;
        let val = extract_config_string(source, &js_path(), &["resolve", "alias", "@"]);
        assert_eq!(val, Some("./src".to_string()));
    }

    #[test]
    fn property_strings_nested_objects() {
        let source = r#"
            export default {
                plugins: {
                    group1: { a: "val-a" },
                    group2: { b: "val-b" }
                }
            };
        "#;
        let values = extract_config_property_strings(source, &js_path(), "plugins");
        assert!(values.contains(&"val-a".to_string()));
        assert!(values.contains(&"val-b".to_string()));
    }

    #[test]
    fn property_strings_missing_key_returns_empty() {
        let source = r#"export default { other: "value" };"#;
        let values = extract_config_property_strings(source, &js_path(), "missing");
        assert!(values.is_empty());
    }

    #[test]
    fn shallow_strings_tuple_array() {
        let source = r#"
            module.exports = {
                reporters: ["default", ["jest-junit", { outputDirectory: "reports" }]]
            };
        "#;
        let values = extract_config_shallow_strings(source, &js_path(), "reporters");
        assert_eq!(values, vec!["default", "jest-junit"]);
        assert!(!values.contains(&"reports".to_string()));
    }

    #[test]
    fn shallow_strings_single_string() {
        let source = r#"export default { preset: "ts-jest" };"#;
        let values = extract_config_shallow_strings(source, &js_path(), "preset");
        assert_eq!(values, vec!["ts-jest"]);
    }

    #[test]
    fn shallow_strings_missing_key() {
        let source = r#"export default { other: "val" };"#;
        let values = extract_config_shallow_strings(source, &js_path(), "missing");
        assert!(values.is_empty());
    }

    #[test]
    fn shallow_strings_or_object_property_alias_objects() {
        let source = r#"
            export default {
                jsPlugins: [
                    "eslint-plugin-playwright",
                    ["eslint-plugin-regexp", { rules: {} }],
                    { name: "short", specifier: "eslint-plugin-with-long-name" }
                ]
            };
        "#;
        let values = extract_config_shallow_strings_or_object_property(
            source,
            &ts_path(),
            "jsPlugins",
            "specifier",
        );
        assert_eq!(
            values,
            vec![
                "eslint-plugin-playwright",
                "eslint-plugin-regexp",
                "eslint-plugin-with-long-name"
            ]
        );
    }

    #[test]
    fn nested_shallow_strings_vitest_reporters() {
        let source = r#"
            export default {
                test: {
                    reporters: ["default", "vitest-sonar-reporter"]
                }
            };
        "#;
        let values =
            extract_config_nested_shallow_strings(source, &js_path(), &["test"], "reporters");
        assert_eq!(values, vec!["default", "vitest-sonar-reporter"]);
    }

    #[test]
    fn nested_shallow_strings_tuple_format() {
        let source = r#"
            export default {
                test: {
                    reporters: ["default", ["vitest-sonar-reporter", { outputFile: "report.xml" }]]
                }
            };
        "#;
        let values =
            extract_config_nested_shallow_strings(source, &js_path(), &["test"], "reporters");
        assert_eq!(values, vec!["default", "vitest-sonar-reporter"]);
    }

    #[test]
    fn nested_shallow_strings_missing_outer() {
        let source = r"export default { other: {} };";
        let values =
            extract_config_nested_shallow_strings(source, &js_path(), &["test"], "reporters");
        assert!(values.is_empty());
    }

    #[test]
    fn nested_shallow_strings_missing_inner() {
        let source = r#"export default { test: { include: ["**/*.test.ts"] } };"#;
        let values =
            extract_config_nested_shallow_strings(source, &js_path(), &["test"], "reporters");
        assert!(values.is_empty());
    }

    #[test]
    fn string_or_array_missing_path() {
        let source = r"export default {};";
        let result = extract_config_string_or_array(source, &js_path(), &["entry"]);
        assert!(result.is_empty());
    }

    #[test]
    fn string_or_array_non_string_values() {
        let source = r"export default { entry: [42, true] };";
        let result = extract_config_string_or_array(source, &js_path(), &["entry"]);
        assert!(result.is_empty());
    }

    #[test]
    fn array_nested_extraction() {
        let source = r#"
            export default defineConfig({
                test: {
                    projects: [
                        {
                            test: {
                                setupFiles: ["./test/setup-a.ts"]
                            }
                        },
                        {
                            test: {
                                setupFiles: "./test/setup-b.ts"
                            }
                        }
                    ]
                }
            });
        "#;
        let results = extract_config_array_nested_string_or_array(
            source,
            &ts_path(),
            &["test", "projects"],
            &["test", "setupFiles"],
        );
        assert!(results.contains(&"./test/setup-a.ts".to_string()));
        assert!(results.contains(&"./test/setup-b.ts".to_string()));
    }

    #[test]
    fn array_nested_empty_when_no_array() {
        let source = r#"export default { test: { projects: "not-an-array" } };"#;
        let results = extract_config_array_nested_string_or_array(
            source,
            &js_path(),
            &["test", "projects"],
            &["test", "setupFiles"],
        );
        assert!(results.is_empty());
    }

    #[test]
    fn object_nested_extraction() {
        let source = r#"{
            "projects": {
                "app-one": {
                    "architect": {
                        "build": {
                            "options": {
                                "styles": ["src/styles.css"]
                            }
                        }
                    }
                }
            }
        }"#;
        let results = extract_config_object_nested_string_or_array(
            source,
            &json_path(),
            &["projects"],
            &["architect", "build", "options", "styles"],
        );
        assert_eq!(results, vec!["src/styles.css"]);
    }

    #[test]
    fn array_with_object_input_form_extracted() {
        let source = r#"{
            "projects": {
                "app": {
                    "architect": {
                        "build": {
                            "options": {
                                "styles": [
                                    "src/styles.scss",
                                    { "input": "src/theme.scss", "bundleName": "theme", "inject": false },
                                    { "bundleName": "lazy-only" }
                                ]
                            }
                        }
                    }
                }
            }
        }"#;
        let results = extract_config_object_nested_string_or_array(
            source,
            &json_path(),
            &["projects"],
            &["architect", "build", "options", "styles"],
        );
        assert!(
            results.contains(&"src/styles.scss".to_string()),
            "string form must still work: {results:?}"
        );
        assert!(
            results.contains(&"src/theme.scss".to_string()),
            "object form with `input` must be extracted: {results:?}"
        );
        assert!(
            !results.contains(&"lazy-only".to_string()),
            "bundleName must not be misinterpreted as a path: {results:?}"
        );
        assert!(
            !results.contains(&"theme".to_string()),
            "bundleName from full object must not leak: {results:?}"
        );
    }

    #[test]
    fn object_nested_strings_extraction() {
        let source = r#"{
            "targets": {
                "build": {
                    "executor": "@angular/build:application"
                },
                "test": {
                    "executor": "@nx/vite:test"
                }
            }
        }"#;
        let results =
            extract_config_object_nested_strings(source, &json_path(), &["targets"], &["executor"]);
        assert!(results.contains(&"@angular/build:application".to_string()));
        assert!(results.contains(&"@nx/vite:test".to_string()));
    }

    #[test]
    fn require_strings_direct_call() {
        let source = r"module.exports = { adapter: require('@sveltejs/adapter-node') };";
        let deps = extract_config_require_strings(source, &js_path(), "adapter");
        assert_eq!(deps, vec!["@sveltejs/adapter-node"]);
    }

    #[test]
    fn require_strings_no_matching_key() {
        let source = r"module.exports = { other: require('something') };";
        let deps = extract_config_require_strings(source, &js_path(), "plugins");
        assert!(deps.is_empty());
    }

    #[test]
    fn extract_imports_no_imports() {
        let source = r"export default {};";
        let imports = extract_imports(source, &js_path());
        assert!(imports.is_empty());
    }

    #[test]
    fn extract_imports_side_effect_import() {
        let source = r"
            import 'polyfill';
            import './local-setup';
            export default {};
        ";
        let imports = extract_imports(source, &js_path());
        assert_eq!(imports, vec!["polyfill", "./local-setup"]);
    }

    #[test]
    fn extract_imports_mixed_specifiers() {
        let source = r"
            import defaultExport from 'module-a';
            import { named } from 'module-b';
            import * as ns from 'module-c';
            export default {};
        ";
        let imports = extract_imports(source, &js_path());
        assert_eq!(imports, vec!["module-a", "module-b", "module-c"]);
    }

    #[test]
    fn template_literal_in_string_or_array() {
        let source = r"export default { entry: `./src/index.ts` };";
        let result = extract_config_string_or_array(source, &ts_path(), &["entry"]);
        assert_eq!(result, vec!["./src/index.ts"]);
    }

    #[test]
    fn template_literal_in_config_string() {
        let source = r"export default { testDir: `./tests` };";
        let val = extract_config_string(source, &js_path(), &["testDir"]);
        assert_eq!(val, Some("./tests".to_string()));
    }

    #[test]
    fn template_literal_command_recovers_static_command_tokens() {
        let source = r"
            const PORT = 3000;
            export default {
                webServer: {
                    command: `pnpm exec srvx --port ${PORT} --hostname 127.0.0.1`
                }
            };
        ";
        let val = extract_config_command(source, &ts_path(), &["webServer", "command"]);
        assert_eq!(
            val,
            Some("pnpm exec srvx --port   --hostname 127.0.0.1".to_string())
        );
    }

    #[test]
    fn template_literal_command_skips_dynamic_prefix() {
        let source = r"
            export default {
                webServer: { command: `${serverCommand} && pnpm exec srvx` }
            };
        ";
        let val = extract_config_command(source, &ts_path(), &["webServer", "command"]);
        assert!(val.is_none());
    }

    #[test]
    fn template_literal_command_skips_split_static_token() {
        let source = r"
            export default {
                webServer: { command: `pnpm exec sr${part}vx --port 3000` }
            };
        ";
        let val = extract_config_command(source, &ts_path(), &["webServer", "command"]);
        assert!(val.is_none());
    }

    #[test]
    fn array_object_command_pairs_recover_template_command() {
        let source = r"
            const PORT = 3000;
            export default {
                webServer: [
                    {
                        command: `pnpm exec srvx --port ${PORT}`,
                        cwd: 'apps/web'
                    }
                ]
            };
        ";
        let pairs = extract_config_array_object_command_pairs(
            source,
            &ts_path(),
            &["webServer"],
            "command",
            "cwd",
        );
        assert_eq!(
            pairs,
            vec![(
                "pnpm exec srvx --port  ".to_string(),
                Some("apps/web".to_string())
            )]
        );
    }

    #[test]
    fn nested_string_array_empty_path() {
        let source = r#"export default { items: ["a", "b"] };"#;
        let result = extract_config_string_array(source, &js_path(), &[]);
        assert!(result.is_empty());
    }

    #[test]
    fn nested_string_empty_path() {
        let source = r#"export default { key: "val" };"#;
        let result = extract_config_string(source, &js_path(), &[]);
        assert!(result.is_none());
    }

    #[test]
    fn object_keys_empty_path() {
        let source = r"export default { plugins: {} };";
        let result = extract_config_object_keys(source, &js_path(), &[]);
        assert!(result.is_empty());
    }

    #[test]
    fn no_config_object_returns_empty() {
        let source = r"const x = 42;";
        let result = extract_config_string(source, &js_path(), &["key"]);
        assert!(result.is_none());

        let arr = extract_config_string_array(source, &js_path(), &["items"]);
        assert!(arr.is_empty());

        let keys = extract_config_object_keys(source, &js_path(), &["plugins"]);
        assert!(keys.is_empty());
    }

    #[test]
    fn property_with_string_key() {
        let source = r#"export default { "string-key": "value" };"#;
        let val = extract_config_string(source, &js_path(), &["string-key"]);
        assert_eq!(val, Some("value".to_string()));
    }

    #[test]
    fn nested_navigation_through_non_object() {
        let source = r#"export default { level1: "not-an-object" };"#;
        let val = extract_config_string(source, &js_path(), &["level1", "level2"]);
        assert!(val.is_none());
    }

    #[test]
    fn variable_reference_untyped() {
        let source = r#"
            const config = {
                testDir: "./tests"
            };
            export default config;
        "#;
        let val = extract_config_string(source, &js_path(), &["testDir"]);
        assert_eq!(val, Some("./tests".to_string()));
    }

    #[test]
    fn variable_reference_to_an_exported_const() {
        for source in [
            r#"
            export const config = { testDir: "./tests" };
            export default config;
            "#,
            r#"
            export const config = { testDir: "./tests" };
            module.exports = config;
            "#,
        ] {
            let val = extract_config_string(source, &js_path(), &["testDir"]);
            assert_eq!(val, Some("./tests".to_string()), "source: {source}");
        }
    }

    #[test]
    fn variable_reference_with_type_annotation() {
        let source = r#"
            import type { StorybookConfig } from '@storybook/react-vite';
            const config: StorybookConfig = {
                addons: ["@storybook/addon-a11y", "@storybook/addon-docs"],
                framework: "@storybook/react-vite"
            };
            export default config;
        "#;
        let addons = extract_config_shallow_strings(source, &ts_path(), "addons");
        assert_eq!(
            addons,
            vec!["@storybook/addon-a11y", "@storybook/addon-docs"]
        );

        let framework = extract_config_string(source, &ts_path(), &["framework"]);
        assert_eq!(framework, Some("@storybook/react-vite".to_string()));
    }

    #[test]
    fn variable_reference_with_define_config() {
        let source = r#"
            import { defineConfig } from 'vitest/config';
            const config = defineConfig({
                test: {
                    include: ["**/*.test.ts"]
                }
            });
            export default config;
        "#;
        let include = extract_config_string_array(source, &ts_path(), &["test", "include"]);
        assert_eq!(include, vec!["**/*.test.ts"]);
    }

    #[test]
    fn ts_satisfies_direct_export() {
        let source = r#"
            export default {
                testDir: "./tests"
            } satisfies PlaywrightTestConfig;
        "#;
        let val = extract_config_string(source, &ts_path(), &["testDir"]);
        assert_eq!(val, Some("./tests".to_string()));
    }

    #[test]
    fn ts_as_direct_export() {
        let source = r#"
            export default {
                testDir: "./tests"
            } as const;
        "#;
        let val = extract_config_string(source, &ts_path(), &["testDir"]);
        assert_eq!(val, Some("./tests".to_string()));
    }

    // --- issue #811: resolve.alias as imported identifier / spread ---

    fn aliases(source: &str) -> Vec<(String, String)> {
        extract_config_aliases(source, &js_path(), &["resolve", "alias"])
    }

    #[test]
    fn aliases_inline_object_still_extracted() {
        // Regression: the resolver must not change inline-object behavior.
        let source = r#"
            export default defineConfig({
                resolve: { alias: { "@": "./src", utils: "../../utils" } }
            });
        "#;
        let mut got = aliases(source);
        got.sort();
        assert_eq!(
            got,
            vec![
                ("@".to_string(), "./src".to_string()),
                ("utils".to_string(), "../../utils".to_string()),
            ]
        );
    }

    #[test]
    fn aliases_inline_array_still_extracted() {
        let source = r#"
            export default defineConfig({
                resolve: { alias: [{ find: "@", replacement: "./src" }] }
            });
        "#;
        assert_eq!(
            aliases(source),
            vec![("@".to_string(), "./src".to_string())]
        );
    }

    #[test]
    fn aliases_local_const_array_identifier() {
        let source = r#"
            const sharedAliases = [{ find: "@", replacement: "./src" }];
            export default defineConfig({ resolve: { alias: sharedAliases } });
        "#;
        assert_eq!(
            aliases(source),
            vec![("@".to_string(), "./src".to_string())]
        );
    }

    #[test]
    fn aliases_local_const_object_identifier() {
        let source = r#"
            const sharedAliases = { "@": "./src" };
            export default defineConfig({ resolve: { alias: sharedAliases } });
        "#;
        assert_eq!(
            aliases(source),
            vec![("@".to_string(), "./src".to_string())]
        );
    }

    #[test]
    fn aliases_array_spread_of_identifiers_and_inline() {
        let source = r##"
            const a = [{ find: "@", replacement: "./src" }];
            const b = [{ find: "~", replacement: "./lib" }];
            export default defineConfig({
                resolve: { alias: [...a, ...b, { find: "#", replacement: "./test" }] }
            });
        "##;
        let mut got = aliases(source);
        got.sort();
        assert_eq!(
            got,
            vec![
                ("#".to_string(), "./test".to_string()),
                ("@".to_string(), "./src".to_string()),
                ("~".to_string(), "./lib".to_string()),
            ]
        );
    }

    #[test]
    fn aliases_object_spread_of_identifier_and_inline() {
        let source = r#"
            const base = { "@": "./src" };
            export default defineConfig({
                resolve: { alias: { ...base, "~": "./lib" } }
            });
        "#;
        let mut got = aliases(source);
        got.sort();
        assert_eq!(
            got,
            vec![
                ("@".to_string(), "./src".to_string()),
                ("~".to_string(), "./lib".to_string()),
            ]
        );
    }

    #[test]
    fn aliases_local_const_chained_identifier() {
        // `const a = b` indirection resolves through the chain.
        let source = r#"
            const real = [{ find: "@", replacement: "./src" }];
            const alias2 = real;
            export default defineConfig({ resolve: { alias: alias2 } });
        "#;
        assert_eq!(
            aliases(source),
            vec![("@".to_string(), "./src".to_string())]
        );
    }

    #[test]
    fn aliases_imported_named_identifier_from_sibling() {
        let dir = tempfile::tempdir().unwrap();
        std::fs::write(
            dir.path().join("vite.shared.js"),
            r#"export const sharedAliases = [
                { find: "@", replacement: new URL("./src", import.meta.url).pathname },
            ];"#,
        )
        .unwrap();
        let config = dir.path().join("vite.config.js");
        let source = r#"
            import { defineConfig } from "vite";
            import { sharedAliases } from "./vite.shared.js";
            export default defineConfig({ resolve: { alias: sharedAliases } });
        "#;
        let got = extract_config_aliases(source, &config, &["resolve", "alias"]);
        assert_eq!(got, vec![("@".to_string(), "./src".to_string())]);
    }

    #[test]
    fn aliases_imported_extensionless_specifier_probed() {
        let dir = tempfile::tempdir().unwrap();
        std::fs::write(
            dir.path().join("aliases.mjs"),
            r#"export const sharedAliases = { "@": "./src" };"#,
        )
        .unwrap();
        let config = dir.path().join("vite.config.ts");
        let source = r#"
            import { sharedAliases } from "./aliases";
            export default defineConfig({ resolve: { alias: sharedAliases } });
        "#;
        let got = extract_config_aliases(source, &config, &["resolve", "alias"]);
        assert_eq!(got, vec![("@".to_string(), "./src".to_string())]);
    }

    #[test]
    fn aliases_imported_default_export_from_sibling() {
        let dir = tempfile::tempdir().unwrap();
        std::fs::write(
            dir.path().join("aliases.js"),
            r#"export default [{ find: "@", replacement: "./src" }];"#,
        )
        .unwrap();
        let config = dir.path().join("vite.config.js");
        let source = r#"
            import sharedAliases from "./aliases.js";
            export default defineConfig({ resolve: { alias: sharedAliases } });
        "#;
        let got = extract_config_aliases(source, &config, &["resolve", "alias"]);
        assert_eq!(got, vec![("@".to_string(), "./src".to_string())]);
    }

    #[test]
    fn aliases_imported_spread_from_two_siblings() {
        let dir = tempfile::tempdir().unwrap();
        std::fs::write(
            dir.path().join("a.js"),
            r#"export const a = [{ find: "@", replacement: "./src" }];"#,
        )
        .unwrap();
        std::fs::write(
            dir.path().join("b.js"),
            r#"export const b = [{ find: "~", replacement: "./lib" }];"#,
        )
        .unwrap();
        let config = dir.path().join("vite.config.js");
        let source = r#"
            import { a } from "./a.js";
            import { b } from "./b.js";
            export default defineConfig({ resolve: { alias: [...a, ...b] } });
        "#;
        let mut got = extract_config_aliases(source, &config, &["resolve", "alias"]);
        got.sort();
        assert_eq!(
            got,
            vec![
                ("@".to_string(), "./src".to_string()),
                ("~".to_string(), "./lib".to_string()),
            ]
        );
    }

    #[test]
    fn aliases_import_cycle_terminates() {
        // a.js imports from b.js and vice versa; resolution must not hang and
        // should still recover the literal pairs present.
        let dir = tempfile::tempdir().unwrap();
        std::fs::write(
            dir.path().join("a.js"),
            r#"import { b } from "./b.js";
               export const a = [{ find: "@", replacement: "./src" }, ...b];"#,
        )
        .unwrap();
        std::fs::write(
            dir.path().join("b.js"),
            r#"import { a } from "./a.js";
               export const b = [...a];"#,
        )
        .unwrap();
        let config = dir.path().join("vite.config.js");
        let source = r#"
            import { a } from "./a.js";
            export default defineConfig({ resolve: { alias: a } });
        "#;
        let got = extract_config_aliases(source, &config, &["resolve", "alias"]);
        assert_eq!(got, vec![("@".to_string(), "./src".to_string())]);
    }

    #[test]
    fn aliases_non_relative_import_not_followed() {
        // A bare-package import is intentionally out of scope: no node_modules
        // read for an alias literal.
        let source = r#"
            import { sharedAliases } from "some-pkg";
            export default defineConfig({ resolve: { alias: sharedAliases } });
        "#;
        let dir = tempfile::tempdir().unwrap();
        let config = dir.path().join("vite.config.js");
        assert!(extract_config_aliases(source, &config, &["resolve", "alias"]).is_empty());
    }

    #[test]
    fn aliases_object_array_value_takes_first_entry() {
        // tsconfig `compilerOptions.paths` maps each key to an ARRAY of targets;
        // the resolver must take the first, matching the long-standing non-kinded
        // behavior the TypeScript plugin depends on. Regression guard for the
        // array-value case that the kinded unification briefly dropped.
        let source = r#"
            export default {
                compilerOptions: { paths: { "@/*": ["./src/*"], "~/*": ["./lib/*", "./vendor/*"] } }
            };
        "#;
        let mut got = extract_config_aliases(source, &js_path(), &["compilerOptions", "paths"]);
        got.sort();
        assert_eq!(
            got,
            vec![
                ("@/*".to_string(), "./src/*".to_string()),
                ("~/*".to_string(), "./lib/*".to_string()),
            ]
        );
    }

    #[test]
    fn aliases_kinded_preserves_is_bare_through_resolution() {
        // The bare-string vs path discriminator must survive identifier + spread
        // resolution (the test.alias package-to-package gate depends on it).
        let source = r#"
            const a = [{ find: "lodash-es", replacement: "lodash" }];
            export default defineConfig({
                resolve: { alias: [...a, { find: "@", replacement: "./src" }] }
            });
        "#;
        let mut got = extract_config_aliases_kinded(source, &js_path(), &["resolve", "alias"]);
        got.sort();
        assert_eq!(
            got,
            vec![
                ("@".to_string(), "./src".to_string(), false),
                ("lodash-es".to_string(), "lodash".to_string(), true),
            ]
        );
    }

    #[test]
    fn aliases_kinded_preserves_is_bare_through_imported_spread() {
        let dir = tempfile::tempdir().unwrap();
        std::fs::write(
            dir.path().join("aliases.js"),
            r#"export const packageAliases = [{ find: "lodash-es", replacement: "lodash" }];"#,
        )
        .unwrap();
        let config = dir.path().join("vite.config.js");
        let source = r#"
            import { packageAliases } from "./aliases.js";
            export default defineConfig({
                resolve: { alias: [...packageAliases, { find: "@", replacement: "./src" }] }
            });
        "#;
        let mut got = extract_config_aliases_kinded(source, &config, &["resolve", "alias"]);
        got.sort();
        assert_eq!(
            got,
            vec![
                ("@".to_string(), "./src".to_string(), false),
                ("lodash-es".to_string(), "lodash".to_string(), true),
            ]
        );
    }

    // --- extract_config_command ---

    #[test]
    fn extract_command_string_literal() {
        let source = r#"export default { start: "node server.js" };"#;
        let val = extract_config_command(source, &js_path(), &["start"]);
        assert_eq!(val, Some("node server.js".to_string()));
    }

    #[test]
    fn extract_command_nested_path() {
        let source = r#"
            export default {
                scripts: {
                    dev: "vite dev"
                }
            };
        "#;
        let val = extract_config_command(source, &js_path(), &["scripts", "dev"]);
        assert_eq!(val, Some("vite dev".to_string()));
    }

    #[test]
    fn extract_command_missing_key_returns_none() {
        let source = r#"export default { other: "val" };"#;
        let val = extract_config_command(source, &js_path(), &["start"]);
        assert!(val.is_none());
    }

    #[test]
    fn extract_command_ts_as_expression() {
        let source = r#"export default { start: "node server.js" as string };"#;
        let val = extract_config_command(source, &ts_path(), &["start"]);
        assert_eq!(val, Some("node server.js".to_string()));
    }

    #[test]
    fn extract_command_ts_satisfies_expression() {
        let source = r#"export default { start: "node server.js" satisfies string };"#;
        let val = extract_config_command(source, &ts_path(), &["start"]);
        assert_eq!(val, Some("node server.js".to_string()));
    }

    #[test]
    fn extract_command_parenthesized_expression() {
        let source = r#"export default { start: ("node server.js") };"#;
        let val = extract_config_command(source, &js_path(), &["start"]);
        assert_eq!(val, Some("node server.js".to_string()));
    }

    #[test]
    fn extract_command_empty_path_returns_none() {
        let source = r#"export default { start: "node server.js" };"#;
        let val = extract_config_command(source, &js_path(), &[]);
        assert!(val.is_none());
    }

    // --- is_disabled_expression and extract_config_truthy_bool_or_object ---

    #[test]
    fn truthy_bool_or_object_with_true_value() {
        let source = r"export default { typescript: true };";
        let result = extract_config_truthy_bool_or_object(source, &ts_path(), &["typescript"]);
        assert!(result);
    }

    #[test]
    fn truthy_bool_or_object_with_false_value() {
        let source = r"export default { typescript: false };";
        let result = extract_config_truthy_bool_or_object(source, &ts_path(), &["typescript"]);
        assert!(!result);
    }

    #[test]
    fn truthy_bool_or_object_with_object_value() {
        let source = r#"export default { typescript: { reactDocgen: "react-docgen" } };"#;
        let result = extract_config_truthy_bool_or_object(source, &ts_path(), &["typescript"]);
        assert!(result);
    }

    #[test]
    fn truthy_bool_or_object_missing_key_returns_false() {
        let source = r"export default { other: true };";
        let result = extract_config_truthy_bool_or_object(source, &ts_path(), &["typescript"]);
        assert!(!result);
    }

    #[test]
    fn truthy_bool_or_object_with_string_value_returns_false() {
        // A string is neither bool true nor object, so the else arm returns false.
        let source = r#"export default { typescript: "yes" };"#;
        let result = extract_config_truthy_bool_or_object(source, &ts_path(), &["typescript"]);
        assert!(!result);
    }

    #[test]
    fn truthy_bool_or_object_ts_satisfies_wrapper() {
        let source = r"export default { typescript: (true satisfies boolean) };";
        let result = extract_config_truthy_bool_or_object(source, &ts_path(), &["typescript"]);
        assert!(result);
    }

    #[test]
    fn truthy_bool_or_object_ts_as_wrapper() {
        let source = r"export default { typescript: (true as boolean) };";
        let result = extract_config_truthy_bool_or_object(source, &ts_path(), &["typescript"]);
        assert!(result);
    }

    #[test]
    fn truthy_bool_or_object_parenthesized_wrapper() {
        let source = r"export default { typescript: (true) };";
        let result = extract_config_truthy_bool_or_object(source, &ts_path(), &["typescript"]);
        assert!(result);
    }

    // --- object_expression helper: exercises via static dir entries property_string ---
    // property_object calls object_expression; it is also exercised through
    // extract_object_from_expression, which handles TS wrappers at the top-export level.
    // The ts_satisfies_direct_export / ts_as_direct_export tests already cover those arms.

    #[test]
    fn static_dir_entries_object_form_exercises_property_string() {
        // property_string (which calls property_expr then expression_to_string) is used
        // for the `from` and `to` keys in extract_config_static_dir_entries.
        let source = r#"
            export default {
                staticDirs: [
                    { from: "./media", to: "/assets" }
                ]
            };
        "#;
        let entries = extract_config_static_dir_entries(source, &ts_path(), &["staticDirs"]);
        assert_eq!(
            entries,
            vec![("./media".to_string(), Some("/assets".to_string()))]
        );
    }

    // --- expression_to_path_values (array form) ---

    #[test]
    fn expression_to_path_values_array_form_via_config_path() {
        // The extract_config_path helper uses expression_to_path; path_values
        // is exercised when the value is an array via extract_config_string_or_array.
        let source = r#"export default { entries: ["./src/a.ts", "./src/b.ts"] };"#;
        let result = extract_config_string_or_array(source, &js_path(), &["entries"]);
        assert_eq!(result, vec!["./src/a.ts", "./src/b.ts"]);
    }

    // --- extract_config_array_nested_aliases_kinded ---

    #[test]
    fn array_nested_aliases_object_form() {
        let source = r#"
            export default {
                test: {
                    projects: [
                        {
                            resolve: {
                                alias: { "@": "./src" }
                            }
                        }
                    ]
                }
            };
        "#;
        let aliases = extract_config_array_nested_aliases_kinded(
            source,
            &ts_path(),
            &["test", "projects"],
            &["resolve", "alias"],
        );
        assert_eq!(aliases, vec![("@".to_string(), "./src".to_string(), false)]);
    }

    #[test]
    fn array_nested_aliases_empty_when_path_is_not_array() {
        let source = r#"export default { test: { projects: "not-an-array" } };"#;
        let aliases = extract_config_array_nested_aliases_kinded(
            source,
            &ts_path(),
            &["test", "projects"],
            &["resolve", "alias"],
        );
        assert!(aliases.is_empty());
    }

    #[test]
    fn array_nested_aliases_kinded_tracks_is_bare() {
        let source = r#"
            export default {
                projects: [
                    {
                        resolve: {
                            alias: [
                                { find: "lodash-es", replacement: "lodash" },
                                { find: "@", replacement: "./src" }
                            ]
                        }
                    }
                ]
            };
        "#;
        let mut aliases = extract_config_array_nested_aliases_kinded(
            source,
            &ts_path(),
            &["projects"],
            &["resolve", "alias"],
        );
        aliases.sort();
        assert_eq!(
            aliases,
            vec![
                ("@".to_string(), "./src".to_string(), false),
                ("lodash-es".to_string(), "lodash".to_string(), true),
            ]
        );
    }

    // --- extract_default_export_array_aliases_kinded ---

    #[test]
    fn default_export_array_aliases_kinded_extracts_from_workspace_config() {
        let source = r#"
            export default [
                {
                    resolve: {
                        alias: { "@": "./src" }
                    }
                },
                {
                    resolve: {
                        alias: [{ find: "~", replacement: "./lib" }]
                    }
                }
            ];
        "#;
        let mut aliases =
            extract_default_export_array_aliases_kinded(source, &ts_path(), &["resolve", "alias"]);
        aliases.sort();
        assert_eq!(
            aliases,
            vec![
                ("@".to_string(), "./src".to_string(), false),
                ("~".to_string(), "./lib".to_string(), false),
            ]
        );
    }

    #[test]
    fn default_export_array_aliases_kinded_define_workspace_wrapper() {
        let source = r#"
            export default defineWorkspace([
                {
                    resolve: { alias: { "@": "./src" } }
                }
            ]);
        "#;
        let aliases =
            extract_default_export_array_aliases_kinded(source, &ts_path(), &["resolve", "alias"]);
        assert_eq!(aliases, vec![("@".to_string(), "./src".to_string(), false)]);
    }

    #[test]
    fn default_export_array_aliases_kinded_empty_when_no_alias_path() {
        let source = r#"
            export default [
                { test: { include: ["**/*.test.ts"] } }
            ];
        "#;
        let aliases =
            extract_default_export_array_aliases_kinded(source, &ts_path(), &["resolve", "alias"]);
        assert!(aliases.is_empty());
    }

    // --- config_default_export_unreachable ---

    #[test]
    fn config_default_export_unreachable_when_no_export() {
        let source = r"const x = 42;";
        assert!(config_default_export_unreachable(source, &js_path()));
    }

    #[test]
    fn config_default_export_unreachable_false_for_object_export() {
        let source = r#"export default { key: "value" };"#;
        assert!(!config_default_export_unreachable(source, &js_path()));
    }

    #[test]
    fn config_default_export_unreachable_false_for_array_export() {
        let source = r#"export default ["a", "b"];"#;
        assert!(!config_default_export_unreachable(source, &js_path()));
    }

    #[test]
    fn config_default_export_unreachable_true_for_function_without_return_object() {
        // A function that returns a number is unreachable.
        let source = r"export default function config() { return 42; }";
        assert!(config_default_export_unreachable(source, &js_path()));
    }

    // --- extract_config_static_dir_entries ---

    #[test]
    fn static_dir_entries_string_and_object_form() {
        let source = r#"
            export default {
                staticDirs: [
                    "./public",
                    { from: "../assets", to: "/static" }
                ]
            };
        "#;
        let entries = extract_config_static_dir_entries(source, &ts_path(), &["staticDirs"]);
        assert_eq!(
            entries,
            vec![
                ("./public".to_string(), None),
                ("../assets".to_string(), Some("/static".to_string())),
            ]
        );
    }

    #[test]
    fn static_dir_entries_object_without_to() {
        let source = r#"
            export default {
                staticDirs: [
                    { from: "./media" }
                ]
            };
        "#;
        let entries = extract_config_static_dir_entries(source, &ts_path(), &["staticDirs"]);
        assert_eq!(entries, vec![("./media".to_string(), None)]);
    }

    #[test]
    fn static_dir_entries_object_missing_from_skipped() {
        // Objects without a `from` key are silently skipped.
        let source = r#"
            export default {
                staticDirs: [
                    { to: "/target" },
                    "./public"
                ]
            };
        "#;
        let entries = extract_config_static_dir_entries(source, &ts_path(), &["staticDirs"]);
        assert_eq!(entries, vec![("./public".to_string(), None)]);
    }

    #[test]
    fn static_dir_entries_empty_when_not_array() {
        let source = r#"export default { staticDirs: "./public" };"#;
        let entries = extract_config_static_dir_entries(source, &ts_path(), &["staticDirs"]);
        assert!(entries.is_empty());
    }

    // --- alias object and array forms ---

    #[test]
    fn aliases_array_form_missing_find_or_replacement_skipped() {
        // An element missing "find" or "replacement" is silently skipped.
        let source = r#"
            export default {
                resolve: {
                    alias: [
                        { replacement: "./src" },
                        { find: "@" },
                        { find: "~", replacement: "./lib" }
                    ]
                }
            };
        "#;
        let aliases = extract_config_aliases(source, &ts_path(), &["resolve", "alias"]);
        assert_eq!(aliases, vec![("~".to_string(), "./lib".to_string())]);
    }

    #[test]
    fn aliases_object_form_computed_key_skipped() {
        // Computed keys (expression keys) are not statically recoverable.
        let source = r#"
            const k = "@";
            export default {
                resolve: {
                    alias: {
                        [k]: "./src",
                        "~": "./lib"
                    }
                }
            };
        "#;
        let aliases = extract_config_aliases(source, &ts_path(), &["resolve", "alias"]);
        // Only the literal key "~" survives; computed [k] is dropped.
        assert_eq!(aliases, vec![("~".to_string(), "./lib".to_string())]);
    }

    #[test]
    fn aliases_kinded_array_form_path_replacement_is_not_bare() {
        let source = r#"
            export default {
                resolve: {
                    alias: [{ find: "@", replacement: "./src" }]
                }
            };
        "#;
        let aliases = extract_config_aliases_kinded(source, &ts_path(), &["resolve", "alias"]);
        assert_eq!(aliases, vec![("@".to_string(), "./src".to_string(), false)]);
    }

    #[test]
    fn aliases_kinded_object_form_bare_and_path_discrimination() {
        let source = r#"
            export default {
                resolve: {
                    alias: {
                        "lodash-es": "lodash",
                        "@": "./src"
                    }
                }
            };
        "#;
        let mut aliases = extract_config_aliases_kinded(source, &ts_path(), &["resolve", "alias"]);
        aliases.sort();
        assert_eq!(
            aliases,
            vec![
                ("@".to_string(), "./src".to_string(), false),
                ("lodash-es".to_string(), "lodash".to_string(), true),
            ]
        );
    }

    #[test]
    fn aliases_kinded_parent_relative_replacement_is_not_bare() {
        let source = r#"
            export default {
                resolve: { alias: { "@": "../shared/src" } }
            };
        "#;
        let aliases = extract_config_aliases_kinded(source, &ts_path(), &["resolve", "alias"]);
        assert_eq!(
            aliases,
            vec![("@".to_string(), "../shared/src".to_string(), false)]
        );
    }

    #[test]
    fn aliases_kinded_absolute_replacement_is_not_bare() {
        let source = r#"
            export default {
                resolve: { alias: { "@": "/absolute/path" } }
            };
        "#;
        let aliases = extract_config_aliases_kinded(source, &ts_path(), &["resolve", "alias"]);
        assert_eq!(
            aliases,
            vec![("@".to_string(), "/absolute/path".to_string(), false)]
        );
    }

    // --- find_default_export_array / array_from_expression wrappers ---

    #[test]
    fn default_export_array_ts_as_wrapper() {
        // array_from_expression must unwrap TSAsExpression.
        let source = r"export default [] as string[];";
        assert!(!config_default_export_unreachable(source, &js_path()));
    }

    #[test]
    fn default_export_array_ts_satisfies_wrapper() {
        let source = r"export default [] satisfies string[];";
        assert!(!config_default_export_unreachable(source, &ts_path()));
    }

    #[test]
    fn default_export_array_define_config_call_wrapper() {
        let source = r#"export default defineConfig(["**/*.test.ts"]);"#;
        assert!(!config_default_export_unreachable(source, &ts_path()));
    }

    // --- collect_shallow_string_values: object-property branches ---

    #[test]
    fn shallow_strings_object_with_string_values() {
        // The ObjectExpression arm of collect_shallow_string_values emits string values.
        let source = r#"
            export default {
                plugins: {
                    autoprefixer: "autoprefixer",
                    tailwindcss: "tailwindcss"
                }
            };
        "#;
        let vals = extract_config_shallow_strings(source, &js_path(), "plugins");
        assert!(vals.contains(&"autoprefixer".to_string()));
        assert!(vals.contains(&"tailwindcss".to_string()));
    }

    #[test]
    fn shallow_strings_object_with_sub_array_first_element() {
        // An object property whose value is an array emits the first string element.
        let source = r#"
            export default {
                reporters: {
                    main: ["jest-junit", { outputFile: "report.xml" }],
                    alt: ["html-reporter"]
                }
            };
        "#;
        let vals = extract_config_shallow_strings(source, &js_path(), "reporters");
        assert!(vals.contains(&"jest-junit".to_string()));
        assert!(vals.contains(&"html-reporter".to_string()));
    }

    // --- collect_shallow_string_or_object_property_values ---

    #[test]
    fn shallow_strings_or_object_property_non_array_single_string() {
        // When the top-level value is a plain string (not an array), it is returned directly.
        let source = r#"export default { jsPlugins: "eslint-plugin-foo" };"#;
        let vals = extract_config_shallow_strings_or_object_property(
            source,
            &ts_path(),
            "jsPlugins",
            "specifier",
        );
        assert_eq!(vals, vec!["eslint-plugin-foo"]);
    }

    #[test]
    fn shallow_strings_or_object_property_ts_satisfies_array_element() {
        // shallow_string_or_object_property unwraps TSSatisfiesExpression.
        let source = r#"
            export default {
                jsPlugins: [
                    ("eslint-plugin-a" satisfies string)
                ]
            };
        "#;
        let vals = extract_config_shallow_strings_or_object_property(
            source,
            &ts_path(),
            "jsPlugins",
            "specifier",
        );
        assert_eq!(vals, vec!["eslint-plugin-a"]);
    }

    #[test]
    fn shallow_strings_or_object_property_ts_as_array_element() {
        let source = r#"
            export default {
                jsPlugins: [
                    ("eslint-plugin-b" as string)
                ]
            };
        "#;
        let vals = extract_config_shallow_strings_or_object_property(
            source,
            &ts_path(),
            "jsPlugins",
            "specifier",
        );
        assert_eq!(vals, vec!["eslint-plugin-b"]);
    }

    #[test]
    fn shallow_strings_or_object_property_sub_array_first_element_string() {
        // A sub-array in jsPlugins returns the first string element.
        let source = r#"
            export default {
                jsPlugins: [
                    ["eslint-plugin-tuple-pkg", { options: true }]
                ]
            };
        "#;
        let vals = extract_config_shallow_strings_or_object_property(
            source,
            &ts_path(),
            "jsPlugins",
            "specifier",
        );
        assert_eq!(vals, vec!["eslint-plugin-tuple-pkg"]);
    }

    // --- extract_config_array_object_command_pairs ---

    #[test]
    fn array_object_command_pairs_basic() {
        let source = r#"
            export default {
                webServer: [
                    { command: "node server.js", cwd: "packages/api" },
                    { command: "vite dev" }
                ]
            };
        "#;
        let pairs = extract_config_array_object_command_pairs(
            source,
            &ts_path(),
            &["webServer"],
            "command",
            "cwd",
        );
        assert_eq!(
            pairs,
            vec![
                (
                    "node server.js".to_string(),
                    Some("packages/api".to_string())
                ),
                ("vite dev".to_string(), None),
            ]
        );
    }

    #[test]
    fn array_object_command_pairs_skips_missing_command() {
        let source = r#"
            export default {
                webServer: [
                    { cwd: "packages/api" },
                    { command: "vite dev", cwd: "apps/web" }
                ]
            };
        "#;
        let pairs = extract_config_array_object_command_pairs(
            source,
            &ts_path(),
            &["webServer"],
            "command",
            "cwd",
        );
        assert_eq!(
            pairs,
            vec![("vite dev".to_string(), Some("apps/web".to_string()))]
        );
    }

    #[test]
    fn array_object_command_pairs_empty_when_not_array() {
        let source = r#"export default { webServer: { command: "vite dev" } };"#;
        let pairs = extract_config_array_object_command_pairs(
            source,
            &ts_path(),
            &["webServer"],
            "command",
            "cwd",
        );
        assert!(pairs.is_empty());
    }

    // --- normalize_config_path edge cases ---

    #[test]
    fn normalize_config_path_empty_string_returns_none() {
        let config_path = PathBuf::from("/project/vite.config.ts");
        let root = PathBuf::from("/project");
        assert_eq!(normalize_config_path("", &config_path, &root), None);
    }

    #[test]
    fn normalize_config_path_escapes_to_above_root_returns_none() {
        let config_path = PathBuf::from("/project/vite.config.ts");
        let root = PathBuf::from("/project");
        // "../../etc" normalizes to the parent of root, which fails the strip_prefix.
        assert_eq!(
            normalize_config_path("../../etc", &config_path, &root),
            None
        );
    }

    #[test]
    fn normalize_config_path_dot_slash_resolves_relative_to_config_dir() {
        let config_path = PathBuf::from("/project/packages/app/vite.config.ts");
        let root = PathBuf::from("/project");
        assert_eq!(
            normalize_config_path("./src", &config_path, &root),
            Some("packages/app/src".to_string())
        );
    }

    // --- JSON config parsing edge cases ---

    #[test]
    fn json_config_array_of_arrays_via_shallow_strings() {
        // JSON with nested plugin tuples is parsed via the parenthesis-wrap path.
        let source = r#"{"reporters": ["default", ["jest-junit", {}]]}"#;
        let vals = extract_config_shallow_strings(source, &json_path(), "reporters");
        assert_eq!(vals, vec!["default", "jest-junit"]);
    }

    // --- extract_config_path ---

    #[test]
    fn extract_config_path_string_literal() {
        let source = r#"export default { outDir: "./dist" };"#;
        let path = extract_config_path(source, &js_path(), &["outDir"]);
        assert_eq!(
            path.map(|p| p.to_string_lossy().replace('\\', "/")),
            Some("./dist".to_string())
        );
    }

    #[test]
    fn extract_config_path_with_resolve_call() {
        let source = r#"
            import { resolve } from "node:path";
            export default { outDir: resolve(__dirname, "dist") };
        "#;
        let path = extract_config_path(source, &js_path(), &["outDir"]);
        assert_eq!(
            path.map(|p| p.to_string_lossy().replace('\\', "/")),
            Some("dist".to_string())
        );
    }

    #[test]
    fn extract_config_path_missing_key_returns_none() {
        let source = r#"export default { other: "val" };"#;
        let path = extract_config_path(source, &js_path(), &["outDir"]);
        assert!(path.is_none());
    }

    // --- extract_imports_and_requires ---

    #[test]
    fn extract_imports_and_requires_both_forms() {
        let source = r"
            import foo from 'foo-pkg';
            require('bar-pkg');
            export default {};
        ";
        let sources = extract_imports_and_requires(source, &js_path());
        assert!(sources.contains(&"foo-pkg".to_string()));
        assert!(sources.contains(&"bar-pkg".to_string()));
    }

    #[test]
    fn extract_imports_and_requires_skips_non_require_calls() {
        let source = r"
            import foo from 'foo-pkg';
            someOtherCall('bar-pkg');
            export default {};
        ";
        let sources = extract_imports_and_requires(source, &js_path());
        assert_eq!(sources, vec!["foo-pkg"]);
    }

    // --- extract_config_nested_shallow_strings: non-object nested value ---

    #[test]
    fn nested_shallow_strings_non_object_nested_returns_empty() {
        // When the outer path points to a non-object, it returns empty.
        let source = r#"export default { test: "not-an-object" };"#;
        let vals =
            extract_config_nested_shallow_strings(source, &js_path(), &["test"], "reporters");
        assert!(vals.is_empty());
    }

    // --- vite_react_babel_dependencies with namespace import ---

    #[test]
    fn vite_react_babel_dependencies_namespace_import() {
        let source = r#"
            import * as react from "@vitejs/plugin-react";

            export default defineConfig({
                plugins: [
                    react.default({
                        babel: {
                            plugins: ["babel-plugin-ns"],
                        },
                    }),
                ],
            });
        "#;
        let deps = extract_vite_plugin_option_dependencies(source, &ts_path());
        assert_eq!(deps, vec!["babel-plugin-ns".to_string()]);
    }

    // --- collect_all_string_values nested object and array recursion ---

    #[test]
    fn property_strings_deeply_nested_object_values() {
        // collect_all_string_values recurses into nested objects and arrays.
        let source = r#"
            export default {
                settings: {
                    a: "val-a",
                    b: {
                        c: "val-c",
                        d: ["val-d1", "val-d2"]
                    }
                }
            };
        "#;
        let values = extract_config_property_strings(source, &js_path(), "settings");
        assert!(values.contains(&"val-a".to_string()));
        assert!(values.contains(&"val-c".to_string()));
        assert!(values.contains(&"val-d1".to_string()));
        assert!(values.contains(&"val-d2".to_string()));
    }

    // --- find_variable_init_expression: export const form ---

    #[test]
    fn aliases_exported_const_form_resolves() {
        // find_variable_init_expression must handle `export const NAME = ...`.
        let source = r#"
            export const sharedAliases = { "@": "./src" };
            export default defineConfig({ resolve: { alias: sharedAliases } });
        "#;
        let aliases = extract_config_aliases(source, &ts_path(), &["resolve", "alias"]);
        assert_eq!(aliases, vec![("@".to_string(), "./src".to_string())]);
    }

    // --- resolve_sibling_module: index file probe ---

    #[test]
    fn aliases_imported_from_sibling_directory_index_file() {
        // resolve_sibling_module probes <specifier>/index.<ext> when direct
        // path and extension-suffixed paths do not exist.
        let dir = tempfile::tempdir().unwrap();
        let aliases_dir = dir.path().join("aliases");
        std::fs::create_dir_all(&aliases_dir).unwrap();
        std::fs::write(
            aliases_dir.join("index.js"),
            r#"export const aliases = [{ find: "@", replacement: "./src" }];"#,
        )
        .unwrap();
        let config = dir.path().join("vite.config.js");
        let source = r#"
            import { aliases } from "./aliases";
            export default defineConfig({ resolve: { alias: aliases } });
        "#;
        let got = extract_config_aliases(source, &config, &["resolve", "alias"]);
        assert_eq!(got, vec![("@".to_string(), "./src".to_string())]);
    }

    // --- aliases max depth guard ---

    #[test]
    fn aliases_depth_limit_terminates_deep_chain() {
        // A chain of more than MAX_ALIAS_RESOLVE_DEPTH identifiers terminates
        // without panic or infinite loop. We verify it does not crash.
        let source = r#"
            const a9 = [{ find: "@", replacement: "./src" }];
            const a8 = a9;
            const a7 = a8;
            const a6 = a7;
            const a5 = a6;
            const a4 = a5;
            const a3 = a4;
            const a2 = a3;
            const a1 = a2;
            export default defineConfig({ resolve: { alias: a1 } });
        "#;
        // At MAX_ALIAS_RESOLVE_DEPTH (8), resolution stops before reaching the literal.
        let got = extract_config_aliases(source, &js_path(), &["resolve", "alias"]);
        let _ = got; // empty or non-empty; both are valid, no panic is the assertion.
    }

    // --- expression_to_path_string: new URL / fileURLToPath ---

    #[test]
    fn extract_aliases_file_url_to_path_new_url() {
        // expression_to_path_string resolves new URL("./src", import.meta.url).
        let source = r#"
            import { fileURLToPath, URL } from 'node:url';
            export default {
                resolve: {
                    alias: {
                        "@": fileURLToPath(new URL("./src", import.meta.url))
                    }
                }
            };
        "#;
        let aliases = extract_config_aliases(source, &ts_path(), &["resolve", "alias"]);
        assert_eq!(aliases, vec![("@".to_string(), "./src".to_string())]);
    }

    #[test]
    fn extract_path_via_new_url_pathname_member() {
        // The .pathname member of new URL(...) is a path-string form.
        let source = r#"
            export default {
                resolve: {
                    alias: {
                        "@": new URL("./src", import.meta.url).pathname
                    }
                }
            };
        "#;
        let aliases = extract_config_aliases(source, &ts_path(), &["resolve", "alias"]);
        assert_eq!(aliases, vec![("@".to_string(), "./src".to_string())]);
    }

    // --- is_disabled_expression: null literal ---

    #[test]
    fn truthy_bool_or_object_null_literal_returns_false() {
        // null is a disabled expression and therefore not truthy.
        let source = r"export default { typescript: null };";
        let result = extract_config_truthy_bool_or_object(source, &js_path(), &["typescript"]);
        assert!(!result);
    }

    // --- expression_to_string_array: non-array form returns empty ---

    #[test]
    fn string_array_non_array_value_returns_empty() {
        let source = r#"export default { items: "not-an-array" };"#;
        let result = extract_config_string_array(source, &js_path(), &["items"]);
        assert!(result.is_empty());
    }

    // --- extract_config_object_nested edge cases ---

    #[test]
    fn object_nested_empty_when_inner_value_is_not_object() {
        // extract_config_object_nested only processes properties whose value is an object.
        let source = r#"export default { targets: { build: "not-an-object" } };"#;
        let results =
            extract_config_object_nested_strings(source, &json_path(), &["targets"], &["executor"]);
        assert!(results.is_empty());
    }

    // --- extract_config_array_nested_string_or_array: missing inner path ---

    #[test]
    fn array_nested_string_or_array_missing_inner_path_returns_empty() {
        let source = r#"
            export default {
                test: {
                    projects: [
                        { test: { include: ["**/*.test.ts"] } }
                    ]
                }
            };
        "#;
        let results = extract_config_array_nested_string_or_array(
            source,
            &ts_path(),
            &["test", "projects"],
            &["test", "setupFiles"],
        );
        assert!(results.is_empty());
    }

    #[test]
    fn wrapped_named_const_default_export_resolves() {
        // `export default withMDX(nextConfig)` (official @next/mdx idiom): the
        // config is passed as a named const to a wrapper call. Regression #1642.
        let source = r#"
            import createMDX from "@next/mdx";
            const nextConfig = { pageExtensions: ["ts", "tsx", "md", "mdx"] };
            const withMDX = createMDX({});
            export default withMDX(nextConfig);
        "#;
        let exts = extract_config_string_array(source, &ts_path(), &["pageExtensions"]);
        assert_eq!(exts, vec!["ts", "tsx", "md", "mdx"]);
    }

    #[test]
    fn wrapped_named_const_module_exports_resolves() {
        // `module.exports = createJestConfig(customConfig)` (next/jest idiom).
        let source = r#"
            const nextJest = require("next/jest");
            const createJestConfig = nextJest();
            const customConfig = { testMatch: ["**/*.test.ts"] };
            module.exports = createJestConfig(customConfig);
        "#;
        let matches = extract_config_string_array(source, &js_path(), &["testMatch"]);
        assert_eq!(matches, vec!["**/*.test.ts"]);
    }

    #[test]
    fn wrapped_named_const_nested_and_curried_resolve() {
        let nested = r#"
            const nextConfig = { pageExtensions: ["mdx"] };
            const withMDX = (c) => c;
            const withFoo = (c) => c;
            export default withMDX(withFoo(nextConfig));
        "#;
        assert_eq!(
            extract_config_string_array(nested, &js_path(), &["pageExtensions"]),
            vec!["mdx"]
        );

        let curried = r#"
            const nextConfig = { pageExtensions: ["md"] };
            const compose = (..._p) => (c) => c;
            export default compose(a, b)(nextConfig);
        "#;
        assert_eq!(
            extract_config_string_array(curried, &js_path(), &["pageExtensions"]),
            vec!["md"]
        );
    }

    #[test]
    fn wrapped_inline_object_still_resolves() {
        // The pre-existing inline-object form must keep working unchanged.
        let source = r#"
            const withMDX = createMDX({});
            export default withMDX({ pageExtensions: ["mdx"] });
        "#;
        assert_eq!(
            extract_config_string_array(source, &js_path(), &["pageExtensions"]),
            vec!["mdx"]
        );
    }
}