fix(samd): fall back to cores/arduino when build.core dir is missing (#320)

* fix(lint): annotate Python daemon Command::new sites for subprocess-spawn lint

After f86817a (refactor lib.rs → submodules) the four
std::process::Command::new sites in fbuild-python/daemon.rs ended up
inside `match` arms two lines below their `allow-direct-spawn:`
comment. The detector in ci/find_direct_subprocess.py only looks at
"same line or the line immediately above", so the annotation no longer
covered the actual call sites and CI started reporting:

  NEW direct spawns without an `allow-direct-spawn: <reason>` marker:
    crates/fbuild-python/src/daemon.rs:96
    crates/fbuild-python/src/daemon.rs:97
    crates/fbuild-python/src/daemon.rs:247
    crates/fbuild-python/src/daemon.rs:248

This blocks every PR's "Lint subprocess spawns" check (e.g. #306 for
fbuild#304, which is the actual FastLED-vs-PIO size regression we
need to land).

Fix: add an inline `// allow-direct-spawn:` annotation immediately
above each of the four arms. Behavior unchanged.

* fix(boards): catch up tinyuf2 partition rename + esp_sr drift; whitelist cmsis_dsp_lib

`Validate Board Definitions` workflow has been failing 39 boards
drifted from PlatformIO. The two largest categories are pure schema
drift that this PR resolves; the remaining ~14 are configuration-
choice differences that need maintainer review.

## Fixed: tinyuf2 partition CSV rename (18 boards)

Upstream Adafruit (and the espressif32 platform's Adafruit board
defs) renamed `tinyuf2-partitions-<size>.csv` ->
`partitions-<size>-tinyuf2.csv`. Our bundled board JSONs still pointed
to the old name. Renamed in:

  adafruit_feather_esp32s2{,_reversetft,_tft}
  adafruit_feather_esp32s3{,_nopsram,_reversetft,_tft}
  adafruit_funhouse_esp32s2
  adafruit_magtag29_esp32s2
  adafruit_matrixportal_esp32s3
  adafruit_metro_esp32s2
  adafruit_metro_esp32s3
  adafruit_qtpy_esp32s2
  adafruit_qtpy_esp32s3_n4r2
  adafruit_qtpy_esp32s3_nopsram
  adafruit_qualia_s3_rgb666
  featheresp32-s2
  wt32-sc01-plus

All swaps are mechanical s/tinyuf2-partitions-<N>MB.csv/partitions-<N>MB-tinyuf2.csv/.

## Fixed: 4d_systems_esp32s3_gen4_r8n16 partitions

`esp_sr_16.csv` -> `default_16MB.csv` per upstream.

## Fixed: validator whitelist for cmsis_dsp_lib (8 teensy boards)

`build.cmsis_dsp_lib` was added by fbuild#300 (PR#313) as an
intentional fbuild-only schema extension — Teensyduino's makefile
picks the matching `arm_cortexM*_math` archive at link time, but
fbuild needs it declared statically. The validator was flagging all
8 teensy variants because the diff treats every extra key in the
actual asset as drift.

Added `FBUILD_EXTENSION_BUILD_FIELDS` whitelist (currently just
`cmsis_dsp_lib`) and strip those from the actual side before diffing.
Documented in-place so future fbuild-only extensions have a place to
land with a one-line note.

## Not in scope

Remaining ~14 boards have configuration-choice drift (UM boards
`-DARDUINO_USB_MODE=1` difference, m5stack variant rename, seeed_
xiao_esp32c6 USB defines, arduino_nano_esp32 BOARD_USES_HW_GPIO_NUMBERS
vs BOARD_HAS_PIN_REMAP, um_tinys2 extras). Each requires a real
decision about which value is correct for fbuild's compile path —
not auto-resolvable by a snapshot rebase. Leaving those for a
separate maintainer-driven sweep.

* fix(samd): fall back to cores/arduino when build.core dir is missing (#319)

Every `Build SAMD51J` workflow run on main fails at:

    fatal error: WVariant.h: No such file or directory
    variants/feather_m4/variant.h:43:10
        43 | #include "WVariant.h"

Root cause: Adafruit's ArduinoCore-samd v1.7.16 (the SAMD framework
fbuild installs) ships only `cores/arduino/` — verified via GitHub
API. Every Adafruit SAMD board declares `build.core = "adafruit"` in
its board JSON (matching PlatformIO upstream, so the board-validator
is happy). fbuild's `SamdCores::get_core_dir(core_name)` literally
joined `cores/<core_name>`, so it asked for `cores/adafruit/`, which
doesn't exist. The variant compile's include-path then pointed at a
phantom directory and `WVariant.h` (which lives in `cores/arduino/`)
was unreachable.

PlatformIO's atmelsam builder handles this by treating `build.core`
as a vendor brand label rather than a literal subdirectory name.
Mirror that behavior: if `cores/<core_name>/` doesn't exist, fall
back to `cores/arduino/` (the canonical Arduino-compatible cores
directory name).

Refactored the fallback into a small `resolve_core_dir_with_arduino_
fallback` helper that's straightforwardly unit-testable. Three new
tests cover the three branches (literal name wins, fallback when
named dir absent, return literal when both absent so the eventual
file-open error has a meaningful path).

Local test results: 9/9 samd_core tests pass, 412/412 fbuild-packages
test suite passes.

Fixes #319.

* fix(samd): inject resolved core_dir into compile include path (#319 follow-up)

The get_core_dir fallback in the previous commit is necessary but not
sufficient. `BoardConfig::get_include_paths(framework_root)` builds
the compile-time include list using the LITERAL `build.core` value
from the board JSON — for Adafruit SAMD boards that's "adafruit",
which produces a `-I.../cores/adafruit` path that doesn't exist.

The variant compile's `#include "WVariant.h"` then misses because:
  - same-dir lookup (variants/feather_m4/) — not there
  - `-I.../cores/adafruit` (phantom) — directory doesn't exist
  - other -I entries (system includes, variant dir) — no WVariant.h

`install_samd_core` already has a resolved `core_dir` (from
`SamdCores::get_core_dir`, which falls back to cores/arduino/ per the
previous commit). Inject it into the system_includes vector returned
by `install_samd_core` so the orchestrator's eventual compile sees
`-I.../cores/arduino` and the headers resolve.

Inserted at position 0 to make the active core dir the first search
hit, matching what PlatformIO's atmelsam builder does.

Refs #319.

Author: zackees

crates/fbuild-build/src/sam/orchestrator.rs

@@ -365,6 +365,20 @@ fn install_samd_core(
     ];
     // Also include the variant dir for variant.h
     includes.push(variant_dir.clone());
+    // And the resolved core dir for Arduino.h / WVariant.h.
+    //
+    // `BoardConfig::get_include_paths` already emits
+    // `framework_root/cores/<board.core>`, which for Adafruit SAMD boards is
+    // a vendor-brand label (e.g. "adafruit") that the framework doesn't
+    // actually ship as a directory — only `cores/arduino/` exists. That
+    // literal path becomes a phantom `-I` and `#include "Arduino.h"` /
+    // `#include "WVariant.h"` lookups miss. `core_dir` here was produced by
+    // `SamdCores::get_core_dir` which falls back to `cores/arduino/` when the
+    // literal subdir is absent (FastLED/fbuild#319), so injecting it into the
+    // compile include path is what actually resolves the headers. Putting
+    // it BEFORE the phantom is a no-op but makes the active dir the first
+    // hit during search, matching what PlatformIO's atmelsam builder does.
+    includes.insert(0, core_dir.clone());
 
     Ok((
         framework_dir,

crates/fbuild-packages/src/library/samd_core.rs

@@ -73,8 +73,17 @@ impl SamdCores {
     }
 
     /// Get the core source directory for a specific core name.
+    ///
+    /// PlatformIO's `build.core` field is a vendor-branding label more than
+    /// a real subdirectory name — Adafruit's ArduinoCore-samd (the SAMD
+    /// framework we install) ships only `cores/arduino/`, but every Adafruit
+    /// SAMD board declares `build.core = "adafruit"` so the literal
+    /// `cores/adafruit/` lookup misses. Mirror PlatformIO's atmelsam builder
+    /// fallback: if `cores/<core_name>/` doesn't exist on disk, fall back to
+    /// `cores/arduino/` (the canonical name for Arduino-compatible cores).
+    /// See FastLED/fbuild#319.
     pub fn get_core_dir(&self, core_name: &str) -> PathBuf {
-        self.get_cores_dir().join(core_name)
+        resolve_core_dir_with_arduino_fallback(&self.get_cores_dir(), core_name)
     }
 
     /// Get the variant directory for a specific variant name.
@@ -194,6 +203,25 @@ fn collect_sources(dir: &Path) -> Vec<PathBuf> {
     sources
 }
 
+/// Resolve a core source dir under `cores_dir`, falling back to
+/// `cores/arduino/` when the literal `<core_name>` subdirectory is missing.
+///
+/// Adafruit (and some other vendor) Arduino-compatible cores set
+/// `build.core = "<vendor>"` in their board JSON for branding even though
+/// the actual sources live in `cores/arduino/`. PlatformIO's atmelsam
+/// builder handles this transparently; fbuild needs to do the same.
+fn resolve_core_dir_with_arduino_fallback(cores_dir: &Path, core_name: &str) -> PathBuf {
+    let primary = cores_dir.join(core_name);
+    if primary.is_dir() {
+        return primary;
+    }
+    let fallback = cores_dir.join("arduino");
+    if fallback.is_dir() {
+        return fallback;
+    }
+    primary
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -249,4 +277,46 @@ mod tests {
         let result = SamdCores::validate(tmp.path());
         assert!(result.is_err());
     }
+
+    /// FastLED/fbuild#319: Adafruit SAMD boards declare `build.core = "adafruit"`
+    /// (a vendor brand label) but the framework only ships `cores/arduino/`.
+    /// The resolver must fall back to `cores/arduino/` when the literal
+    /// `cores/<core_name>/` doesn't exist on disk, mirroring PIO's atmelsam
+    /// builder behavior.
+    #[test]
+    fn resolve_falls_back_to_arduino_when_named_dir_missing() {
+        let tmp = tempfile::TempDir::new().unwrap();
+        let cores_dir = tmp.path().join("cores");
+        std::fs::create_dir_all(cores_dir.join("arduino")).unwrap();
+        // No `cores/adafruit/` exists.
+
+        let resolved = resolve_core_dir_with_arduino_fallback(&cores_dir, "adafruit");
+        assert_eq!(resolved, cores_dir.join("arduino"));
+    }
+
+    /// Sanity: when the named core dir *does* exist, the fallback must not
+    /// kick in — honor the literal name.
+    #[test]
+    fn resolve_uses_literal_name_when_present() {
+        let tmp = tempfile::TempDir::new().unwrap();
+        let cores_dir = tmp.path().join("cores");
+        std::fs::create_dir_all(cores_dir.join("custom_vendor")).unwrap();
+        std::fs::create_dir_all(cores_dir.join("arduino")).unwrap();
+
+        let resolved = resolve_core_dir_with_arduino_fallback(&cores_dir, "custom_vendor");
+        assert_eq!(resolved, cores_dir.join("custom_vendor"));
+    }
+
+    /// When neither the named dir nor `cores/arduino/` exists, return the
+    /// literal `cores/<name>/` so the eventual file-open error surfaces with
+    /// a meaningful path (don't synthesize a nonexistent fallback).
+    #[test]
+    fn resolve_returns_literal_when_no_fallback_available() {
+        let tmp = tempfile::TempDir::new().unwrap();
+        let cores_dir = tmp.path().join("cores");
+        // No cores subdirs at all.
+
+        let resolved = resolve_core_dir_with_arduino_fallback(&cores_dir, "vendor");
+        assert_eq!(resolved, cores_dir.join("vendor"));
+    }
 }