Merge branch 'ci/fixes'

Author: lucasssvaz

.github/CODEOWNERS

@@ -59,6 +59,7 @@
 /libraries/ESP_SR/ @me-no-dev
 /libraries/ESPmDNS/ @me-no-dev
 /libraries/Ethernet/ @me-no-dev
+/libraries/Hash/ @lucasssvaz
 /libraries/Matter/ @SuGlider
 /libraries/NetBIOS/ @me-no-dev
 /libraries/Network/ @me-no-dev
@@ -72,9 +73,9 @@
 /libraries/Wire/ @me-no-dev
 /libraries/Zigbee/ @P-R-O-C-H-Y
 
-# CI JSON
+# CI YAML
 # Keep this after other libraries and tests to avoid being overridden.
-**/ci.json @lucasssvaz
+**/ci.yml @lucasssvaz
 
 # The CODEOWNERS file should be owned by the developers of the ESP32 Arduino Core.
 # Leave this entry as the last one to avoid being overridden.

.github/scripts/get_affected.py

@@ -63,7 +63,7 @@
 Build file patterns
 --------------------
 - **build_files**: Core Arduino build system files (platform.txt, variants/**, etc.)
-- **sketch_build_files**: Sketch-specific files (ci.json, *.csv in example directories)
+- **sketch_build_files**: Sketch-specific files (ci.yml, *.csv in example directories)
 - **idf_build_files**: Core IDF build system files (CMakeLists.txt, idf_component.yml, etc.)
 - **idf_project_files**: Project-specific IDF files (per-example CMakeLists.txt, sdkconfig, etc.)
 
@@ -128,7 +128,7 @@
 # Files that are used by the sketch build system.
 # If any of these files change, the sketch should be recompiled.
 sketch_build_files = [
-    "libraries/*/examples/**/ci.json",
+    "libraries/*/examples/**/ci.yml",
     "libraries/*/examples/**/*.csv",
 ]
 
@@ -150,7 +150,7 @@
 # If any of these files change, the example that uses them should be recompiled.
 idf_project_files = [
     "idf_component_examples/*/CMakeLists.txt",
-    "idf_component_examples/*/ci.json",
+    "idf_component_examples/*/ci.yml",
     "idf_component_examples/*/*.csv",
     "idf_component_examples/*/sdkconfig*",
     "idf_component_examples/*/main/*",
@@ -358,6 +358,59 @@ def build_qname_from_tag(tag: dict) -> str:
     qname = "::".join([p for p in qparts if p])
     return f"{qname}{signature}"
 
+def find_impl_files_for_qname(qname: str, defs_by_qname: dict[str, set[str]], header_path: str = None) -> set[str]:
+    """
+    Find implementation files for a qualified name, handling namespace mismatches.
+
+    Ctags may capture different namespace scopes in headers vs implementations.
+    For example:
+    - Header: fs::SDFS::begin(...)
+    - Implementation: SDFS::begin(...)
+
+    This happens when implementations use "using namespace" directives.
+
+    Strategy:
+    1. Try exact match first
+    2. If no match and qname has namespaces, try stripping ONLY outer namespace prefixes
+       (keep at least Class::method structure intact)
+    3. If header_path provided, prefer implementations from same directory
+    """
+    # Try exact match first
+    impl_files = defs_by_qname.get(qname, set())
+    if impl_files:
+        return impl_files
+
+    # If no exact match and the qname contains namespaces (::), try stripping them
+    if "::" in qname:
+        parts = qname.split("::")
+        # Only strip outer namespaces, not the class/method structure
+        # For "ns1::ns2::Class::method(...)", we want to try:
+        # - "ns2::Class::method(...)"  (strip 1 level)
+        # - "Class::method(...)"       (strip 2 levels)
+        # But NOT "method(...)" alone (too ambiguous)
+
+        # Only allow stripping if we have more than 2 parts (namespace::Class::method)
+        # If we only have 2 parts (Class::method), don't strip as it would leave just "method"
+        if len(parts) > 2:
+            # Keep at least 2 parts (Class::method) to avoid false positives
+            max_strip = len(parts) - 2
+
+            for i in range(1, max_strip + 1):
+                shorter_qname = "::".join(parts[i:])
+                impl_files = defs_by_qname.get(shorter_qname, set())
+
+                if impl_files:
+                    # If we have the header path, prefer implementations from same directory
+                    if header_path:
+                        header_dir = os.path.dirname(header_path)
+                        same_dir_files = {f for f in impl_files if os.path.dirname(f) == header_dir}
+                        if same_dir_files:
+                            return same_dir_files
+
+                    return impl_files
+
+    return set()
+
 def run_ctags_and_index(paths: list[str]) -> tuple[dict[str, set[str]], dict[str, set[str]], str]:
     """
     Run Universal Ctags over given paths (relative to project_root) and build:
@@ -582,8 +635,10 @@ def build_dependencies_graph() -> None:
                         if qnames:
                             impl_files = set()
                             for qn in qnames:
-                                # For each qualified name, get the implementation files
-                                impl_files |= ctags_defs_by_qname.get(qn, set())
+                                # For each qualified name, find implementation files
+                                # This handles namespace mismatches (e.g., fs::SDFS vs SDFS)
+                                # Pass header_path to prefer implementations from same directory
+                                impl_files |= find_impl_files_for_qname(qn, ctags_defs_by_qname, header_path)
                             for impl in impl_files:
                                 # Skip .ino files - they should never be dependencies of other files
                                 if impl.endswith('.ino'):

.github/scripts/on-push-idf.sh

@@ -17,9 +17,9 @@ fi
 
 for example in $affected_examples; do
     example_path="$PWD/components/arduino-esp32/$example"
-    if [ -f "$example_path/ci.json" ]; then
+    if [ -f "$example_path/ci.yml" ]; then
         # If the target is listed as false, skip the sketch. Otherwise, include it.
-        is_target=$(jq -r --arg target "$IDF_TARGET" '.targets[$target]' "$example_path/ci.json")
+        is_target=$(yq eval ".targets.${IDF_TARGET}" "$example_path/ci.yml" 2>/dev/null)
         if [[ "$is_target" == "false" ]]; then
             printf "\n\033[93mSkipping %s for target %s\033[0m\n\n" "$example" "$IDF_TARGET"
             continue

.github/scripts/sketch_utils.sh

@@ -15,13 +15,13 @@ function check_requirements { # check_requirements <sketchdir> <sdkconfig_path>
     local requirements
     local requirements_or
 
-    if [ ! -f "$sdkconfig_path" ] || [ ! -f "$sketchdir/ci.json" ]; then
-        echo "WARNING: sdkconfig or ci.json not found. Assuming requirements are met." 1>&2
+    if [ ! -f "$sdkconfig_path" ] || [ ! -f "$sketchdir/ci.yml" ]; then
+        echo "WARNING: sdkconfig or ci.yml not found. Assuming requirements are met." 1>&2
         # Return 1 on error to force the sketch to be built and fail. This way the
         # CI will fail and the user will know that the sketch has a problem.
     else
         # Check if the sketch requires any configuration options (AND)
-        requirements=$(jq -r '.requires[]? // empty' "$sketchdir/ci.json")
+        requirements=$(yq eval '.requires[]' "$sketchdir/ci.yml" 2>/dev/null)
         if [[ "$requirements" != "null" && "$requirements" != "" ]]; then
             for requirement in $requirements; do
                 requirement=$(echo "$requirement" | xargs)
@@ -33,7 +33,7 @@ function check_requirements { # check_requirements <sketchdir> <sdkconfig_path>
         fi
 
         # Check if the sketch requires any configuration options (OR)
-        requirements_or=$(jq -r '.requires_any[]? // empty' "$sketchdir/ci.json")
+        requirements_or=$(yq eval '.requires_any[]' "$sketchdir/ci.yml" 2>/dev/null)
         if [[ "$requirements_or" != "null" && "$requirements_or" != "" ]]; then
             local found=false
             for requirement in $requirements_or; do
@@ -122,13 +122,13 @@ function build_sketch { # build_sketch <ide_path> <user_path> <path-to-ino> [ext
         # precedence.  Note that the following logic also falls to the default
         # parameters if no arguments were passed and no file was found.
 
-        if [ -z "$options" ] && [ -f "$sketchdir"/ci.json ]; then
+        if [ -z "$options" ] && [ -f "$sketchdir"/ci.yml ]; then
             # The config file could contain multiple FQBNs for one chip.  If
             # that's the case we build one time for every FQBN.
 
-            len=$(jq -r --arg target "$target" '.fqbn[$target] | length' "$sketchdir"/ci.json)
+            len=$(yq eval ".fqbn.${target} | length" "$sketchdir"/ci.yml 2>/dev/null || echo 0)
             if [ "$len" -gt 0 ]; then
-                fqbn=$(jq -r --arg target "$target" '.fqbn[$target] | sort' "$sketchdir"/ci.json)
+                fqbn=$(yq eval ".fqbn.${target} | sort | @json" "$sketchdir"/ci.yml)
             fi
         fi
 
@@ -138,8 +138,8 @@ function build_sketch { # build_sketch <ide_path> <user_path> <path-to-ino> [ext
 
             len=1
 
-            if [ -f "$sketchdir"/ci.json ]; then
-                fqbn_append=$(jq -r '.fqbn_append' "$sketchdir"/ci.json)
+            if [ -f "$sketchdir"/ci.yml ]; then
+                fqbn_append=$(yq eval '.fqbn_append' "$sketchdir"/ci.yml 2>/dev/null)
                 if [ "$fqbn_append" == "null" ]; then
                     fqbn_append=""
                 fi
@@ -229,9 +229,9 @@ function build_sketch { # build_sketch <ide_path> <user_path> <path-to-ino> [ext
     sketchname=$(basename "$sketchdir")
     local has_requirements
 
-    if [ -f "$sketchdir"/ci.json ]; then
+    if [ -f "$sketchdir"/ci.yml ]; then
         # If the target is listed as false, skip the sketch. Otherwise, include it.
-        is_target=$(jq -r --arg target "$target" '.targets[$target]' "$sketchdir"/ci.json)
+        is_target=$(yq eval ".targets.${target}" "$sketchdir"/ci.yml 2>/dev/null)
         if [[ "$is_target" == "false" ]]; then
             echo "Skipping $sketchname for target $target"
             exit 0
@@ -244,7 +244,7 @@ function build_sketch { # build_sketch <ide_path> <user_path> <path-to-ino> [ext
         fi
     fi
 
-    # Install libraries from ci.json if they exist
+    # Install libraries from ci.yml if they exist
     install_libs -ai "$ide_path" -s "$sketchdir"
     install_result=$?
     if [ $install_result -ne 0 ]; then
@@ -394,9 +394,9 @@ function count_sketches { # count_sketches <path> [target] [ignore-requirements]
 
         if [[ "$sketchdirname.ino" != "$sketchname" ]]; then
             continue
-        elif [[ -n $target ]] && [[ -f $sketchdir/ci.json ]]; then
+        elif [[ -n $target ]] && [[ -f $sketchdir/ci.yml ]]; then
             # If the target is listed as false, skip the sketch. Otherwise, include it.
-            is_target=$(jq -r --arg target "$target" '.targets[$target]' "$sketchdir"/ci.json)
+            is_target=$(yq eval ".targets.${target}" "$sketchdir"/ci.yml 2>/dev/null)
             if [[ "$is_target" == "false" ]]; then
                 continue
             fi
@@ -637,38 +637,38 @@ function install_libs { # install_libs <ide_path> <sketchdir> [-v]
         return 1
     fi
 
-    if [ ! -f "$sketchdir/ci.json" ]; then
-        [ "$verbose" = true ] && echo "No ci.json found in $sketchdir, skipping library installation"
+    if [ ! -f "$sketchdir/ci.yml" ]; then
+        [ "$verbose" = true ] && echo "No ci.yml found in $sketchdir, skipping library installation"
         return 0
     fi
-    if ! jq -e . "$sketchdir/ci.json" >/dev/null 2>&1; then
-        echo "ERROR: $sketchdir/ci.json is not valid JSON" >&2
+    if ! yq eval '.' "$sketchdir/ci.yml" >/dev/null 2>&1; then
+        echo "ERROR: $sketchdir/ci.yml is not valid YAML" >&2
         return 1
     fi
 
     local libs_type
-    libs_type=$(jq -r '.libs | type' "$sketchdir/ci.json" 2>/dev/null)
+    libs_type=$(yq eval '.libs | type' "$sketchdir/ci.yml" 2>/dev/null)
     if [ -z "$libs_type" ] || [ "$libs_type" = "null" ]; then
-        [ "$verbose" = true ] && echo "No libs field found in ci.json, skipping library installation"
+        [ "$verbose" = true ] && echo "No libs field found in ci.yml, skipping library installation"
         return 0
-    elif [ "$libs_type" != "array" ]; then
-        echo "ERROR: libs field in ci.json must be an array, found: $libs_type" >&2
+    elif [ "$libs_type" != "!!seq" ]; then
+        echo "ERROR: libs field in ci.yml must be an array, found: $libs_type" >&2
         return 1
     fi
 
     local libs_count
-    libs_count=$(jq -r '.libs | length' "$sketchdir/ci.json" 2>/dev/null)
+    libs_count=$(yq eval '.libs | length' "$sketchdir/ci.yml" 2>/dev/null)
     if [ "$libs_count" -eq 0 ]; then
-        [ "$verbose" = true ] && echo "libs array is empty in ci.json, skipping library installation"
+        [ "$verbose" = true ] && echo "libs array is empty in ci.yml, skipping library installation"
         return 0
     fi
 
-    echo "Installing $libs_count libraries from $sketchdir/ci.json"
+    echo "Installing $libs_count libraries from $sketchdir/ci.yml"
 
     local needs_unsafe=false
     local original_unsafe_setting=""
     local libs
-    libs=$(jq -r '.libs[]? // empty' "$sketchdir/ci.json")
+    libs=$(yq eval '.libs[]' "$sketchdir/ci.yml" 2>/dev/null)
 
     # Detect any git-like URL (GitHub/GitLab/Bitbucket/self-hosted/ssh)
     for lib in $libs; do
@@ -749,7 +749,7 @@ Available commands:
     build: Build a sketch.
     chunk_build: Build a chunk of sketches.
     check_requirements: Check if target meets sketch requirements.
-    install_libs: Install libraries from ci.json file.
+    install_libs: Install libraries from ci.yml file.
 "
 
 cmd=$1

.github/scripts/tests_matrix.sh

@@ -12,18 +12,25 @@ if [[ $IS_PR != 'true' ]] || [[ $PERFORMANCE_ENABLED == 'true' ]]; then
     #qemu_types+=",'performance'"
 fi
 
-targets="'esp32','esp32s2','esp32s3','esp32c3','esp32c6','esp32h2','esp32p4'"
+hw_targets="'esp32','esp32s2','esp32s3','esp32c3','esp32c5','esp32c6','esp32h2','esp32p4'"
+wokwi_targets="'esp32','esp32s2','esp32s3','esp32c3','esp32c6','esp32h2','esp32p4'"
+qemu_targets="'esp32','esp32c3'"
 
 mkdir -p info
 
-echo "[$wokwi_types]" > info/wokwi_types.txt
+echo "[$hw_targets]" > info/hw_targets.txt
 echo "[$hw_types]" > info/hw_types.txt
-echo "[$targets]" > info/targets.txt
+echo "[$wokwi_targets]" > info/wokwi_targets.txt
+echo "[$wokwi_types]" > info/wokwi_types.txt
+echo "[$qemu_targets]" > info/qemu_targets.txt
+echo "[$qemu_types]" > info/qemu_types.txt
 
 {
     echo "build-types=[$build_types]"
+    echo "hw_targets=[$hw_targets]"
     echo "hw-types=[$hw_types]"
+    echo "wokwi_targets=[$wokwi_targets]"
     echo "wokwi-types=[$wokwi_types]"
+    echo "qemu_targets=[$qemu_targets]"
     echo "qemu-types=[$qemu_types]"
-    echo "targets=[$targets]"
 } >> "$GITHUB_OUTPUT"

.github/scripts/tests_run.sh

@@ -17,8 +17,8 @@ function run_test {
     sketchname=$(basename "$sketchdir")
     test_type=$(basename "$(dirname "$sketchdir")")
 
-    if [ "$options" -eq 0 ] && [ -f "$sketchdir"/ci.json ]; then
-        len=$(jq -r --arg target "$target" '.fqbn[$target] | length' "$sketchdir"/ci.json)
+    if [ "$options" -eq 0 ] && [ -f "$sketchdir"/ci.yml ]; then
+        len=$(yq eval ".fqbn.${target} | length" "$sketchdir"/ci.yml 2>/dev/null || echo 0)
         if [ "$len" -eq 0 ]; then
             len=1
         fi
@@ -32,10 +32,10 @@ function run_test {
         sdkconfig_path="$HOME/.arduino/tests/$target/$sketchname/build0.tmp/sdkconfig"
     fi
 
-    if [ -f "$sketchdir"/ci.json ]; then
+    if [ -f "$sketchdir"/ci.yml ]; then
         # If the target or platform is listed as false, skip the sketch. Otherwise, include it.
-        is_target=$(jq -r --arg target "$target" '.targets[$target]' "$sketchdir"/ci.json)
-        selected_platform=$(jq -r --arg platform "$platform" '.platforms[$platform]' "$sketchdir"/ci.json)
+        is_target=$(yq eval ".targets.${target}" "$sketchdir"/ci.yml 2>/dev/null)
+        selected_platform=$(yq eval ".platforms.${platform}" "$sketchdir"/ci.yml 2>/dev/null)
 
         if [[ $is_target == "false" ]] || [[ $selected_platform == "false" ]]; then
             printf "\033[93mSkipping %s test for %s, platform: %s\033[0m\n" "$sketchname" "$target" "$platform"
@@ -68,11 +68,11 @@ function run_test {
         fqbn="Default"
 
         if [ "$len" -ne 1 ]; then
-            fqbn=$(jq -r --arg target "$target" --argjson i "$i" '.fqbn[$target] | sort | .[$i]' "$sketchdir"/ci.json)
-        elif [ -f "$sketchdir"/ci.json ]; then
-            has_fqbn=$(jq -r --arg target "$target" '.fqbn[$target]' "$sketchdir"/ci.json)
+            fqbn=$(yq eval ".fqbn.${target} | sort | .[${i}]" "$sketchdir"/ci.yml 2>/dev/null)
+        elif [ -f "$sketchdir"/ci.yml ]; then
+            has_fqbn=$(yq eval ".fqbn.${target}" "$sketchdir"/ci.yml 2>/dev/null)
             if [ "$has_fqbn" != "null" ]; then
-                fqbn=$(jq -r --arg target "$target" '.fqbn[$target] | .[0]' "$sketchdir"/ci.json)
+                fqbn=$(yq eval ".fqbn.${target} | .[0]" "$sketchdir"/ci.yml 2>/dev/null)
             fi
         fi
 

.github/workflows/docs_deploy.yml

@@ -19,6 +19,7 @@ permissions:
 jobs:
   deploy-prod-docs:
     name: Deploy Documentation on Production
+    if: github.repository == 'espressif/arduino-esp32'
     runs-on: ubuntu-22.04
     defaults:
       run:

.github/workflows/push.yml

@@ -29,7 +29,7 @@ on:
       - "libraries/**/*.c"
       - "libraries/**/*.h"
       - "libraries/**/*.ino"
-      - "libraries/**/ci.json"
+      - "libraries/**/ci.yml"
       - "package/**"
       - "tools/get.*"
       - "platform.txt"

.github/workflows/tests.yml

@@ -54,10 +54,9 @@ jobs:
     runs-on: ubuntu-latest
     outputs:
       build-types: ${{ steps.set-matrix.outputs.build-types }}
-      hw-types: ${{ steps.set-matrix.outputs.hw-types }}
-      wokwi-types: ${{ steps.set-matrix.outputs.wokwi-types }}
+      hw-targets: ${{ steps.set-matrix.outputs.hw-targets }}
       qemu-types: ${{ steps.set-matrix.outputs.qemu-types }}
-      targets: ${{ steps.set-matrix.outputs.targets }}
+      qemu-targets: ${{ steps.set-matrix.outputs.qemu-targets }}
     env:
       IS_PR: ${{ github.event.pull_request.number != null }}
       PERFORMANCE_ENABLED: ${{ contains(github.event.pull_request.labels.*.name, 'perf_test') }}
@@ -84,7 +83,7 @@ jobs:
     strategy:
       matrix:
         type: ${{ fromJson(needs.gen-matrix.outputs.build-types) }}
-        chip: ${{ fromJson(needs.gen-matrix.outputs.targets) }}
+        chip: ${{ fromJson(needs.gen-matrix.outputs.hw-targets) }}
     with:
       type: ${{ matrix.type }}
       chip: ${{ matrix.chip }}
@@ -99,7 +98,7 @@ jobs:
       fail-fast: false
       matrix:
         type: ${{ fromJson(needs.gen-matrix.outputs.qemu-types) }}
-        chip: ["esp32", "esp32c3"]
+        chip: ${{ fromJson(needs.gen-matrix.outputs.qemu-targets) }}
     with:
       type: ${{ matrix.type }}
       chip: ${{ matrix.chip }}