⚡️ Speed up method TreeSitterAnalyzer.find_functions by 28% in PR #1561 (add/support_react)

[codeflash-ai]

⚡️ This pull request contains optimizations for PR #1561

If you approve this dependent PR, these changes will be merged into the original PR branch add/support_react.

This PR will be automatically closed if the original PR is merged.

---

📄 28% (0.28x) speedup for TreeSitterAnalyzer.find_functions in codeflash/languages/javascript/treesitter_utils.py

⏱️ Runtime : 18.2 milliseconds → 14.3 milliseconds (best of 15 runs)

📝 Explanation and details

The optimization achieves a 27% runtime improvement (18.2ms → 14.3ms) by making two key changes to the tree traversal logic:

Primary Optimization: Iterative DFS with Explicit Stack

The original code used Python recursion to traverse the syntax tree, making a recursive call for each child node. This approach incurs significant overhead from:

• Python's function call machinery (stack frame creation, argument passing)
• Repeated keyword argument unpacking on every recursive call
• Deep call stacks for nested code structures

The optimized version replaces recursion with an iterative depth-first search using an explicit stack. Each stack entry stores (node, current_class, current_function) as a tuple, and the traversal loop pops nodes and processes them iteratively. This eliminates function call overhead entirely and reduces memory pressure from deep recursion.

Impact on workloads: The line profiler shows the _walk_tree_for_functions method dropped from 70ms to 42ms (40% improvement). Test results confirm larger speedups for deeply nested code:

• 50 levels of nesting: 37.3% faster (974μs → 709μs)
• 100 functions: 25.4% faster (1.33ms → 1.06ms)
• Large source files with mixed content: 32.6% faster (2.62ms → 1.97ms)

Secondary Optimization: Cached Function Type Sets

The original code reconstructed the function_types set on every node visit (12,665 times in profiling), repeatedly adding "arrow_function" and "method_definition" based on flags. The optimized version caches these sets in _function_types_cache keyed by (include_methods, include_arrow_functions). Since these flags are constant per traversal, the set is built once and reused for all nodes.

Impact: While a smaller contributor than the iterative traversal, this eliminates ~20ms of redundant set operations visible in the line profiler (lines building and modifying function_types accounted for ~15% of original runtime).

Trade-offs

For very small/empty inputs, the optimization shows minor slowdowns (7-10% on empty source, whitespace-only files) due to cache initialization overhead. However, these edge cases are not representative of real-world usage where the function analyzes actual code with multiple functions. All realistic test cases with actual functions show speedups of 8-42%, with the largest gains on complex, deeply nested, or large codebases—exactly the scenarios where this analyzer would be used in production.

The optimization maintains identical behavior and correctness across all 54 test cases while dramatically improving performance for production workloads.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 152 Passed
⏪ Replay Tests	🔘 None Found
🔎 Concolic Coverage Tests	🔘 None Found
📊 Tests Coverage	100.0%

🌀 Click to see Generated Regression Tests

import pytest
from codeflash.languages.javascript.treesitter_utils import (
    FunctionNode, TreeSitterAnalyzer, TreeSitterLanguage)
from tree_sitter import Language, Parser

def test_find_functions_basic_function_declaration():
    """Test finding a basic function declaration."""
    analyzer = TreeSitterAnalyzer("javascript")
    source = "function hello() { return 42; }"
    codeflash_output = analyzer.find_functions(source); functions = codeflash_output # 87.4μs -> 80.9μs (8.09% faster)

def test_find_functions_arrow_function():
    """Test finding arrow functions when include_arrow_functions=True."""
    analyzer = TreeSitterAnalyzer("javascript")
    source = "const foo = () => { return 42; };"
    codeflash_output = analyzer.find_functions(source, include_arrow_functions=True); functions = codeflash_output # 61.3μs -> 56.1μs (9.34% faster)

def test_find_functions_multiple_functions():
    """Test finding multiple function declarations."""
    analyzer = TreeSitterAnalyzer("javascript")
    source = """
    function first() { }
    function second() { }
    function third() { }
    """
    codeflash_output = analyzer.find_functions(source); functions = codeflash_output # 74.3μs -> 66.9μs (11.0% faster)

def test_find_functions_async_function():
    """Test finding async functions."""
    analyzer = TreeSitterAnalyzer("javascript")
    source = "async function fetchData() { }"
    codeflash_output = analyzer.find_functions(source); functions = codeflash_output # 38.5μs -> 36.1μs (6.71% faster)

def test_find_functions_method_in_class():
    """Test finding methods in class definitions."""
    analyzer = TreeSitterAnalyzer("javascript")
    source = """
    class MyClass {
        myMethod() { }
    }
    """
    codeflash_output = analyzer.find_functions(source, include_methods=True); functions = codeflash_output # 53.2μs -> 50.9μs (4.62% faster)

def test_find_functions_exclude_methods():
    """Test that methods are excluded when include_methods=False."""
    analyzer = TreeSitterAnalyzer("javascript")
    source = """
    class MyClass {
        myMethod() { }
    }
    function standalone() { }
    """
    codeflash_output = analyzer.find_functions(source, include_methods=False); functions = codeflash_output # 58.4μs -> 53.9μs (8.28% faster)

def test_find_functions_exclude_arrow_functions():
    """Test that arrow functions are excluded when include_arrow_functions=False."""
    analyzer = TreeSitterAnalyzer("javascript")
    source = """
    const arrow = () => { };
    function regular() { }
    """
    codeflash_output = analyzer.find_functions(source, include_arrow_functions=False); functions = codeflash_output # 56.2μs -> 49.9μs (12.6% faster)

def test_find_functions_returns_list():
    """Test that find_functions returns a list."""
    analyzer = TreeSitterAnalyzer("javascript")
    source = "function test() { }"
    codeflash_output = analyzer.find_functions(source); result = codeflash_output # 33.8μs -> 32.5μs (3.94% faster)

def test_find_functions_function_node_has_name():
    """Test that returned FunctionNode has name attribute."""
    analyzer = TreeSitterAnalyzer("javascript")
    source = "function myFunc() { }"
    codeflash_output = analyzer.find_functions(source); functions = codeflash_output # 32.9μs -> 32.6μs (0.800% faster)

def test_find_functions_function_node_has_line_info():
    """Test that returned FunctionNode has line information."""
    analyzer = TreeSitterAnalyzer("javascript")
    source = "function test() { }"
    codeflash_output = analyzer.find_functions(source); functions = codeflash_output # 32.3μs -> 31.4μs (2.90% faster)

def test_find_functions_generator_function():
    """Test finding generator functions."""
    analyzer = TreeSitterAnalyzer("javascript")
    source = "function* generator() { yield 42; }"
    codeflash_output = analyzer.find_functions(source); functions = codeflash_output # 47.1μs -> 42.3μs (11.3% faster)

def test_find_functions_nested_functions():
    """Test finding nested function declarations."""
    analyzer = TreeSitterAnalyzer("javascript")
    source = """
    function outer() {
        function inner() { }
    }
    """
    codeflash_output = analyzer.find_functions(source); functions = codeflash_output # 52.6μs -> 49.3μs (6.64% faster)

def test_find_functions_empty_source():
    """Test finding functions in empty source code."""
    analyzer = TreeSitterAnalyzer("javascript")
    source = ""
    codeflash_output = analyzer.find_functions(source); functions = codeflash_output # 9.42μs -> 10.2μs (7.83% slower)

def test_find_functions_whitespace_only():
    """Test finding functions in source with only whitespace."""
    analyzer = TreeSitterAnalyzer("javascript")
    source = "   \n\n   \t\t\n"
    codeflash_output = analyzer.find_functions(source); functions = codeflash_output # 9.81μs -> 11.0μs (10.5% slower)

def test_find_functions_comments_only():
    """Test finding functions in source with only comments."""
    analyzer = TreeSitterAnalyzer("javascript")
    source = "// This is a comment\n/* Another comment */"
    codeflash_output = analyzer.find_functions(source); functions = codeflash_output # 14.4μs -> 15.4μs (6.89% slower)

def test_find_functions_anonymous_function_no_name_require():
    """Test anonymous function when require_name=False."""
    analyzer = TreeSitterAnalyzer("javascript")
    source = "const x = function() { };"
    codeflash_output = analyzer.find_functions(source, require_name=False); functions = codeflash_output # 47.2μs -> 43.7μs (7.91% faster)

def test_find_functions_anonymous_function_require_name():
    """Test anonymous function when require_name=True."""
    analyzer = TreeSitterAnalyzer("javascript")
    source = "const x = function() { };"
    codeflash_output = analyzer.find_functions(source, require_name=True); functions = codeflash_output # 41.1μs -> 37.8μs (8.74% faster)

def test_find_functions_function_with_parameters():
    """Test finding functions with parameters."""
    analyzer = TreeSitterAnalyzer("javascript")
    source = "function add(a, b, c) { return a + b + c; }"
    codeflash_output = analyzer.find_functions(source); functions = codeflash_output # 59.8μs -> 55.0μs (8.81% faster)

def test_find_functions_arrow_function_with_params():
    """Test arrow functions with multiple parameters."""
    analyzer = TreeSitterAnalyzer("javascript")
    source = "const multiply = (x, y) => x * y;"
    codeflash_output = analyzer.find_functions(source, include_arrow_functions=True); functions = codeflash_output # 58.0μs -> 53.7μs (8.04% faster)

def test_find_functions_arrow_function_single_param():
    """Test arrow function with single parameter."""
    analyzer = TreeSitterAnalyzer("javascript")
    source = "const square = x => x * x;"
    codeflash_output = analyzer.find_functions(source, include_arrow_functions=True); functions = codeflash_output # 43.5μs -> 39.5μs (10.1% faster)

def test_find_functions_async_arrow_function():
    """Test async arrow functions."""
    analyzer = TreeSitterAnalyzer("javascript")
    source = "const asyncFunc = async () => { await something(); };"
    codeflash_output = analyzer.find_functions(source, include_arrow_functions=True); functions = codeflash_output # 59.7μs -> 53.6μs (11.3% faster)

def test_find_functions_method_with_special_names():
    """Test finding methods with special names like constructor."""
    analyzer = TreeSitterAnalyzer("javascript")
    source = """
    class MyClass {
        constructor() { }
        get property() { }
        set property(val) { }
    }
    """
    codeflash_output = analyzer.find_functions(source, include_methods=True); functions = codeflash_output # 88.4μs -> 78.9μs (12.1% faster)

def test_find_functions_multiple_classes():
    """Test finding methods in multiple classes."""
    analyzer = TreeSitterAnalyzer("javascript")
    source = """
    class ClassA {
        methodA() { }
    }
    class ClassB {
        methodB() { }
    }
    """
    codeflash_output = analyzer.find_functions(source, include_methods=True); functions = codeflash_output # 70.2μs -> 63.7μs (10.2% faster)

def test_find_functions_deeply_nested_functions():
    """Test finding deeply nested functions."""
    analyzer = TreeSitterAnalyzer("javascript")
    source = """
    function level1() {
        function level2() {
            function level3() {
                function level4() { }
            }
        }
    }
    """
    codeflash_output = analyzer.find_functions(source); functions = codeflash_output # 82.2μs -> 72.8μs (12.8% faster)

def test_find_functions_function_expression():
    """Test finding function expressions."""
    analyzer = TreeSitterAnalyzer("javascript")
    source = "const fn = function namedExpression() { };"
    codeflash_output = analyzer.find_functions(source); functions = codeflash_output # 43.1μs -> 40.0μs (7.53% faster)

def test_find_functions_iife_immediately_invoked():
    """Test finding IIFE (Immediately Invoked Function Expression)."""
    analyzer = TreeSitterAnalyzer("javascript")
    source = "(function() { })();"
    codeflash_output = analyzer.find_functions(source, require_name=False); functions = codeflash_output # 47.8μs -> 43.3μs (10.3% faster)

def test_find_functions_unicode_function_names():
    """Test finding functions with unicode characters in names."""
    analyzer = TreeSitterAnalyzer("javascript")
    source = "function café() { }"
    codeflash_output = analyzer.find_functions(source); functions = codeflash_output # 34.9μs -> 34.4μs (1.54% faster)

def test_find_functions_function_with_long_body():
    """Test finding function with very long body."""
    analyzer = TreeSitterAnalyzer("javascript")
    source = "function longFunc() { " + "x = 1;\n" * 500 + "}"
    codeflash_output = analyzer.find_functions(source); functions = codeflash_output # 2.96ms -> 2.09ms (41.6% faster)

def test_find_functions_arrow_in_object_literal_excluded():
    """Test that arrow functions in object literals are excluded."""
    analyzer = TreeSitterAnalyzer("javascript")
    source = """
    const obj = {
        key: () => { }
    };
    """
    codeflash_output = analyzer.find_functions(source, include_arrow_functions=True); functions = codeflash_output # 64.6μs -> 59.9μs (7.87% faster)

def test_find_functions_function_source_text():
    """Test that function source text is captured."""
    analyzer = TreeSitterAnalyzer("javascript")
    source = "function test() { return 42; }"
    codeflash_output = analyzer.find_functions(source); functions = codeflash_output # 41.8μs -> 39.9μs (4.80% faster)

def test_find_functions_line_numbers_correct():
    """Test that line numbers are correct for functions."""
    analyzer = TreeSitterAnalyzer("javascript")
    source = """
function first() { }

function second() { }
"""
    codeflash_output = analyzer.find_functions(source); functions = codeflash_output # 53.3μs -> 50.3μs (5.89% faster)

def test_find_functions_column_info_available():
    """Test that column information is available."""
    analyzer = TreeSitterAnalyzer("javascript")
    source = "function test() { }"
    codeflash_output = analyzer.find_functions(source); functions = codeflash_output # 33.3μs -> 32.6μs (1.93% faster)

def test_find_functions_with_defaults_parameters():
    """Test finding functions with default parameters."""
    analyzer = TreeSitterAnalyzer("javascript")
    source = "function greet(name = 'World') { console.log(name); }"
    codeflash_output = analyzer.find_functions(source); functions = codeflash_output # 66.2μs -> 59.5μs (11.2% faster)

def test_find_functions_with_rest_parameters():
    """Test finding functions with rest parameters."""
    analyzer = TreeSitterAnalyzer("javascript")
    source = "function sum(...numbers) { }"
    codeflash_output = analyzer.find_functions(source); functions = codeflash_output # 39.1μs -> 36.9μs (5.96% faster)

def test_find_functions_with_destructuring_params():
    """Test finding functions with destructured parameters."""
    analyzer = TreeSitterAnalyzer("javascript")
    source = "function process({ x, y }) { }"
    codeflash_output = analyzer.find_functions(source); functions = codeflash_output # 46.0μs -> 44.3μs (3.73% faster)

def test_find_functions_mixed_function_types():
    """Test finding mix of different function types."""
    analyzer = TreeSitterAnalyzer("javascript")
    source = """
    function regular() { }
    const arrow = () => { };
    async function asyncFunc() { }
    function* generator() { }
    """
    codeflash_output = analyzer.find_functions(source, include_arrow_functions=True); functions = codeflash_output # 101μs -> 90.1μs (13.0% faster)

def test_find_functions_return_type_is_function_node():
    """Test that returned items are FunctionNode instances."""
    analyzer = TreeSitterAnalyzer("javascript")
    source = "function test() { }"
    codeflash_output = analyzer.find_functions(source); functions = codeflash_output # 32.4μs -> 32.2μs (0.653% faster)

def test_find_functions_no_mutation_of_input():
    """Test that find_functions doesn't mutate the input."""
    analyzer = TreeSitterAnalyzer("javascript")
    source = "function test() { }"
    original_source = source
    
    analyzer.find_functions(source) # 32.6μs -> 31.3μs (4.12% faster)

def test_find_functions_with_string_language_initialization():
    """Test analyzer initialization with string language."""
    analyzer = TreeSitterAnalyzer("javascript")
    source = "function test() { }"
    codeflash_output = analyzer.find_functions(source); functions = codeflash_output # 31.3μs -> 31.9μs (1.95% slower)

def test_find_functions_many_functions():
    """Test finding 100 functions in a single source."""
    analyzer = TreeSitterAnalyzer("javascript")
    
    # Generate 100 function declarations
    source_lines = [f"function func{i}() {{ }}" for i in range(100)]
    source = "\n".join(source_lines)
    
    codeflash_output = analyzer.find_functions(source); functions = codeflash_output # 1.33ms -> 1.06ms (25.4% faster)
    for i, func in enumerate(functions):
        pass

def test_find_functions_many_nested_levels():
    """Test finding functions with 50 levels of nesting."""
    analyzer = TreeSitterAnalyzer("javascript")
    
    # Build nested functions
    source = "function level0() {"
    for i in range(1, 50):
        source += f"function level{i}() {{"
    source += "}"
    for i in range(49):
        source += "}"
    
    codeflash_output = analyzer.find_functions(source); functions = codeflash_output # 974μs -> 709μs (37.3% faster)

def test_find_functions_many_classes_with_methods():
    """Test finding methods in 50 classes."""
    analyzer = TreeSitterAnalyzer("javascript")
    
    # Generate 50 classes with methods
    source_lines = []
    for i in range(50):
        source_lines.append(f"class Class{i} {{")
        source_lines.append(f"  method{i}() {{ }}")
        source_lines.append("}")
    source = "\n".join(source_lines)
    
    codeflash_output = analyzer.find_functions(source, include_methods=True); functions = codeflash_output # 972μs -> 756μs (28.5% faster)
    for i, func in enumerate(functions):
        pass

def test_find_functions_large_source_file():
    """Test finding functions in large source with mixed content."""
    analyzer = TreeSitterAnalyzer("javascript")
    
    # Create a large source with functions and non-function code
    source_lines = []
    for i in range(100):
        source_lines.append(f"// Comment {i}")
        source_lines.append(f"const var{i} = {i};")
        source_lines.append(f"function func{i}() {{ return {i}; }}")
    source = "\n".join(source_lines)
    
    codeflash_output = analyzer.find_functions(source); functions = codeflash_output # 2.62ms -> 1.97ms (32.6% faster)

def test_find_functions_performance_many_arrow_functions():
    """Test finding 200 arrow functions."""
    analyzer = TreeSitterAnalyzer("javascript")
    
    # Generate 200 arrow functions
    source_lines = [f"const arrow{i} = () => {i};" for i in range(200)]
    source = "\n".join(source_lines)
    
    codeflash_output = analyzer.find_functions(source, include_arrow_functions=True); functions = codeflash_output # 3.60ms -> 2.75ms (31.1% faster)

def test_find_functions_mixed_nesting_large_scale():
    """Test finding functions in complex mixed nesting (classes, regular, arrow)."""
    analyzer = TreeSitterAnalyzer("javascript")
    
    source_lines = []
    count = 0
    
    # Add 20 classes with 5 methods each
    for i in range(20):
        source_lines.append(f"class Class{i} {{")
        for j in range(5):
            source_lines.append(f"  method{j}() {{ }}")
            count += 1
        source_lines.append("}")
    
    # Add 50 standalone functions
    for i in range(50):
        source_lines.append(f"function func{i}() {{ }}")
        count += 1
    
    # Add 30 arrow functions
    for i in range(30):
        source_lines.append(f"const arrow{i} = () => {{}};")
        count += 1
    
    source = "\n".join(source_lines)
    codeflash_output = analyzer.find_functions(
        source,
        include_methods=True,
        include_arrow_functions=True
    ); functions = codeflash_output # 2.59ms -> 2.05ms (26.4% faster)

def test_find_functions_all_flags_combinations():
    """Test all combinations of include_methods and include_arrow_functions."""
    analyzer = TreeSitterAnalyzer("javascript")
    
    source = """
    class MyClass {
        method() { }
    }
    function regular() { }
    const arrow = () => { };
    """
    
    # All included
    codeflash_output = analyzer.find_functions(
        source,
        include_methods=True,
        include_arrow_functions=True
    ); all_funcs = codeflash_output # 92.0μs -> 82.8μs (11.2% faster)
    
    # Only regular and arrow
    codeflash_output = analyzer.find_functions(
        source,
        include_methods=False,
        include_arrow_functions=True
    ); no_methods = codeflash_output # 61.7μs -> 53.5μs (15.2% faster)
    
    # Only regular and methods
    codeflash_output = analyzer.find_functions(
        source,
        include_methods=True,
        include_arrow_functions=False
    ); no_arrow = codeflash_output # 53.3μs -> 45.2μs (17.8% faster)
    
    # Only regular
    codeflash_output = analyzer.find_functions(
        source,
        include_methods=False,
        include_arrow_functions=False
    ); only_regular = codeflash_output # 42.5μs -> 36.8μs (15.6% faster)

def test_find_functions_consistency_across_calls():
    """Test that multiple calls return consistent results."""
    analyzer = TreeSitterAnalyzer("javascript")
    source = """
    function a() { }
    function b() { }
    function c() { }
    """
    
    codeflash_output = analyzer.find_functions(source); result1 = codeflash_output # 66.1μs -> 60.6μs (8.98% faster)
    codeflash_output = analyzer.find_functions(source); result2 = codeflash_output # 45.5μs -> 38.1μs (19.6% faster)
    for r1, r2 in zip(result1, result2):
        pass

def test_find_functions_with_typescript_syntax():
    """Test finding functions with TypeScript-style syntax."""
    analyzer = TreeSitterAnalyzer("javascript")
    
    source = """
    function typed(x: number, y: string): boolean { }
    interface MyInterface { }
    class GenericClass<T> { }
    """
    
    codeflash_output = analyzer.find_functions(source); functions = codeflash_output # 269μs -> 255μs (5.31% faster)

def test_find_functions_empty_class():
    """Test finding methods in empty class."""
    analyzer = TreeSitterAnalyzer("javascript")
    source = "class Empty { }"
    
    codeflash_output = analyzer.find_functions(source, include_methods=True); functions = codeflash_output # 25.6μs -> 26.3μs (2.67% slower)

def test_find_functions_class_with_multiple_methods():
    """Test class with many methods."""
    analyzer = TreeSitterAnalyzer("javascript")
    
    source = "class MyClass {"
    for i in range(30):
        source += f"method{i}() {{ }}"
    source += "}"
    
    codeflash_output = analyzer.find_functions(source, include_methods=True); functions = codeflash_output # 387μs -> 322μs (19.9% faster)

def test_find_functions_alternating_function_types():
    """Test alternating between function types."""
    analyzer = TreeSitterAnalyzer("javascript")
    
    source = """
    function f1() { }
    const a1 = () => { };
    function f2() { }
    const a2 = () => { };
    function f3() { }
    const a3 = () => { };
    """
    
    codeflash_output = analyzer.find_functions(source, include_arrow_functions=True); functions = codeflash_output # 136μs -> 117μs (15.6% faster)

def test_find_functions_parallel_nested_functions():
    """Test multiple nested functions at same level."""
    analyzer = TreeSitterAnalyzer("javascript")
    
    source = """
    function outer1() {
        function inner1() { }
        function inner2() { }
        function inner3() { }
    }
    function outer2() {
        function inner4() { }
        function inner5() { }
    }
    """
    
    codeflash_output = analyzer.find_functions(source); functions = codeflash_output # 122μs -> 108μs (13.6% faster)
    outer_funcs = [f for f in functions if f.parent_function is None]
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

To edit these changes git checkout codeflash/optimize-pr1561-2026-02-20T08.59.35 and push.

[claude]

PR Review Summary

Prek Checks

✅ Fixed — ruff format reformatted codeflash/languages/javascript/treesitter_utils.py (collapsed multi-line set literal to single line). Fix committed and pushed in 10fde7c0.

ruff check passed with no issues. mypy passed with no issues.

Code Review

✅ No critical issues found.

The optimization correctly transforms a recursive DFS tree traversal into an iterative one with an explicit stack:

• Traversal order preserved: Children are pushed in reversed order so they are popped left-to-right, matching the original recursive order.
• Context propagation correct: Class and function context (current_class, current_function) are correctly passed to children based on whether the current node is a function type or class node, matching the original behavior.
• Cache safety: _function_types_cache stores sets that are only used for in membership checks, never mutated after creation.
• No breaking API changes: The public find_functions signature and return type are unchanged.

Test Coverage

File	Stmts	Miss	Coverage	Status
codeflash/languages/javascript/treesitter_utils.py	—	—	Not tracked	⚠️ New file
codeflash/languages/javascript/treesitter.py	845	70	92%	✅
Overall	50698	10788	79%	—

Notes:

• treesitter_utils.py is a new file (does not exist on main) and is not directly imported by the test suite. Tests in test_treesitter_utils.py import TreeSitterAnalyzer from treesitter.py (which has its own copy of the class at 92% coverage), not from treesitter_utils.py.
• The 8 test failures (test_tracer.py) are pre-existing and unrelated to this PR.
• The PR's base branch is add/support_react, not main.

---

Last updated: 2026-02-20