fix(ci): green every red badge — dylint pin, macOS zed assertion, CH32V006 sysclk, nightly reusable-workflow cap

.gitignore

@@ -43,6 +43,18 @@ tests/platform/*/build_info*.json
 .cargo/git/
 .cargo/registry/
 
+# Same caches, at any depth. The patterns above contain a slash, so git
+# anchors them to the repo root and they do NOT cover nested crates.
+# Running any cargo command inside `dylints/<lint>/` (each is its own
+# workspace with its own `.cargo/config.toml`) materializes a full registry
+# cache there — thousands of vendored files that a `git add -A` will happily
+# stage.
+**/.cargo/.global-cache
+**/.cargo/.package-cache
+**/.cargo/.package-cache-mutate
+**/.cargo/git/
+**/.cargo/registry/
+
 # Cargo lock is checked in for binaries
 # (workspace contains binary crates)
 .loop

ci/render_workflows.py

@@ -150,22 +150,55 @@ def _job_id(workflow: str) -> str:
 def render_nightly(boards: list[dict]) -> str:
  """Render .github/workflows/nightly-platforms.yml from the SOT.
 
- Fan-out: one `uses:` job per board. A single guard job decides
- whether the matrix runs at all -- if no commits landed in the last
- 24h, every downstream job is skipped via `if:`. workflow_dispatch
- exposes a `force` boolean to bypass the guard for manual reruns.
+ Fan-out: ONE matrix job that calls `template_build.yml` directly, once
+ per board. A single guard job decides whether the sweep runs at all --
+ if no commits landed in the last 24h, the build job is skipped via
+ `if:`. workflow_dispatch exposes a `force` boolean to bypass the guard
+ for manual reruns.
+
+ This deliberately does NOT do the obvious thing of emitting one
+ `uses: ./.github/workflows/build-<board>.yml` job per board. GitHub caps
+ a single workflow file at **20 unique reusable workflows**, counting the
+ whole nested tree. Referencing all ~79 per-board workflows blew straight
+ past that cap, and the failure mode gives you nothing to debug: the run
+ is created, immediately reports "This run likely failed because of a
+ workflow file issue", and produces **zero jobs** and no logs. The YAML is
+ perfectly valid, so neither a linter nor `yaml.safe_load` flags it.
+
+ Calling the shared template with a matrix keeps the unique-reusable count
+ at 1 no matter how many boards the SOT grows to.
+
+ Matrix keys use underscores, not hyphens, on purpose: `matrix.test-dir`
+ parses as a subtraction in a GitHub expression, silently yielding an
+ empty value rather than an error. The hyphenated names are reintroduced
+ only in the `with:` block, where they are input keys rather than
+ expressions.
  """
-job_blocks: list[str] = []
+matrix_entries: list[str] = []
  for b in boards:
- jid = _job_id(b["workflow"])
- job_blocks.append(
- f" {jid}:\n"
- f" name: {b['workflow_name']}\n"
- f" needs: guard\n"
- f" if: needs.guard.outputs.should_run == 'true'\n"
- f" uses: ./.github/workflows/{b['workflow']}\n"
+ matrix_entries.append(
+ f" - workflow_name: {json.dumps(b['workflow_name'])}\n"
+ f" test_dir: {json.dumps(b['test_dir'])}\n"
+ f" env_name: {json.dumps(b['env_name'])}\n"
+ f" firmware_ext: {json.dumps(b['firmware_ext'])}\n"
  )
- jobs_yaml = "\n".join(job_blocks)
+ jobs_yaml = (
+ " build:\n"
+ " name: ${{ matrix.workflow_name }}\n"
+ " needs: guard\n"
+ " if: needs.guard.outputs.should_run == 'true'\n"
+ " strategy:\n"
+ # One broken board must not cancel the other 78 -- the whole point of
+ # a nightly sweep is a complete picture of what is red.
+ " fail-fast: false\n"
+ " matrix:\n"
+ " include:\n" + "".join(matrix_entries) + " uses: ./.github/workflows/template_build.yml\n"
+ " with:\n"
+ " workflow-name: ${{ matrix.workflow_name }}\n"
+ " test-dir: ${{ matrix.test_dir }}\n"
+ " env-name: ${{ matrix.env_name }}\n"
+ " firmware-ext: ${{ matrix.firmware_ext }}\n"
+ )
  header = (
  "# Daily safety-net sweep of every per-board build workflow.\n"
  "# See FastLED/fbuild#835.\n"

crates/fbuild-build-mcu/src/ch32v/orchestrator.rs

@@ -304,7 +304,27 @@ fn sysclk_define(
  )));
  }
  };
- let unit = if matches!(series, "ch32v003" | "ch32v006") && source == "HSI" {
+ // Spelling is per-series because the vendor headers are not self-consistent.
+ //
+ // `system/CH32V00x/USER/system_ch32v00x.c` (ch32v003) tests the uppercase
+ // `SYSCLK_FREQ_<n>MHZ_HSI` where it dispatches, so that series keeps `MHZ`.
+ //
+ // ch32v006 (`system/CH32VM00X/USER/system_ch32v00X.c`) is a *different*
+ // file with a typo: it declares and defines `SetSysClockTo_48MHz_HSI`
+ // under the lowercase `SYSCLK_FREQ_48MHz_HSI`, but its `SetSysClock()`
+ // dispatcher tests the uppercase `SYSCLK_FREQ_48MHZ_HSI` and calls
+ // `SetSysClockTo_48MHZ_HSI()` -- an identifier that exists nowhere in the
+ // tree. Defining the uppercase spelling therefore takes a branch whose
+ // callee was never declared:
+ //
+ // error: implicit declaration of function 'SetSysClockTo_48MHZ_HSI'
+ //
+ // Emitting the lowercase spelling leaves that broken branch unselected, so
+ // the file compiles and the part runs on the reset-default HSI clock --
+ // the same outcome the vendor core produces for any unrecognized setting.
+ // Actually applying 48 MHz on ch32v006 needs a vendor-side fix to that
+ // dispatcher; it cannot be reached from a `-D` flag.
+ let unit = if series == "ch32v003" && source == "HSI" {
  "MHZ"
  } else {
  "MHz"
@@ -502,6 +522,23 @@ mod tests {
  );
  }
 
+ /// ch32v006 must NOT get ch32v003's uppercase spelling. Its vendor file
+ /// declares the setter under `SYSCLK_FREQ_48MHz_HSI` but dispatches on
+ /// `SYSCLK_FREQ_48MHZ_HSI`, so the uppercase form selects a call to an
+ /// undeclared `SetSysClockTo_48MHZ_HSI` and the core fails to compile.
+ #[test]
+ fn test_sysclk_define_ch32v006_uses_lowercase_mhz() {
+ assert_eq!(
+ sysclk_define("ch32v006", "48000000L", "hsi+pll").unwrap(),
+ ("SYSCLK_FREQ_48MHz_HSI".to_string(), "48000000".to_string())
+ );
+ // HSE was never part of the uppercase carve-out; keep it lowercase too.
+ assert_eq!(
+ sysclk_define("ch32v006", "24000000L", "hse").unwrap(),
+ ("SYSCLK_FREQ_24MHz_HSE".to_string(), "24000000".to_string())
+ );
+ }
+
  #[test]
  fn test_sysclk_define_rejects_unsupported_frequency() {
  let error = sysclk_define("ch32v203", "8000000L", "hsi").unwrap_err();

crates/fbuild-cli/src/cli/clangd_config/mod.rs

@@ -36,6 +36,8 @@
 mod vscode;
 mod zed;
 
+use fbuild_core::path::NormalizedPath;
+
 use crate::output;
 
 use super::build::{normalize_path, run_build};
@@ -158,8 +160,8 @@ pub(crate) async fn ensure_compile_db(
  env_name: &str,
  verbose: bool,
  refresh: bool,
-) -> fbuild_core::Result<std::path::PathBuf> {
- let db_path = project_path.join("compile_commands.json");
+) -> fbuild_core::Result<NormalizedPath> {
+ let db_path = NormalizedPath::from(project_path.join("compile_commands.json"));
  if !refresh && db_path.exists() {
  output::progress("Using existing compile_commands.json");
  return Ok(db_path);
@@ -195,8 +197,8 @@ pub(crate) async fn ensure_compile_db(
 /// future `fbuild ide` module can reuse it directly.
 pub(crate) fn emit_clangd_file(
  project_path: &std::path::Path,
-) -> fbuild_core::Result<std::path::PathBuf> {
- let clangd_path = project_path.join(".clangd");
+) -> fbuild_core::Result<NormalizedPath> {
+ let clangd_path = NormalizedPath::from(project_path.join(".clangd"));
  std::fs::write(&clangd_path, render_clangd_yaml()).map_err(|e| {
  fbuild_core::FbuildError::Other(format!("failed to write {}: {}", clangd_path.display(), e))
  })?;
@@ -239,7 +241,7 @@ pub(crate) fn shared_clangd_arguments() -> Vec<String> {
 pub(crate) fn emit_editor_config(
  editor: Editor,
  project_path: &std::path::Path,
-) -> fbuild_core::Result<Vec<(std::path::PathBuf, bool)>> {
+) -> fbuild_core::Result<Vec<(NormalizedPath, bool)>> {
  match editor {
  Editor::VsCode => vscode::emit(project_path),
  Editor::Zed => zed::emit(project_path),

crates/fbuild-cli/src/cli/clangd_config/vscode.rs

@@ -1,17 +1,19 @@
 //! VS Code emitter: `.vscode/settings.json` (merge-don't-clobber) and
 //! `.vscode/extensions.json` (write-once).
 
-use std::path::{Path, PathBuf};
+use std::path::Path;
+
+use fbuild_core::path::NormalizedPath;
 
 /// Write/merge `.vscode/settings.json` and (if absent) `.vscode/extensions.json`.
 /// Returns `(path, was_written)` pairs for the caller's summary output.
-pub(super) fn emit(project_path: &Path) -> fbuild_core::Result<Vec<(PathBuf, bool)>> {
+pub(super) fn emit(project_path: &Path) -> fbuild_core::Result<Vec<(NormalizedPath, bool)>> {
  let vscode_dir = project_path.join(".vscode");
  std::fs::create_dir_all(&vscode_dir).map_err(|e| {
  fbuild_core::FbuildError::Other(format!("failed to create {}: {}", vscode_dir.display(), e))
  })?;
 
- let settings_path = vscode_dir.join("settings.json");
+ let settings_path = NormalizedPath::from(vscode_dir.join("settings.json"));
  let merged_settings = merge_vscode_settings(&settings_path)?;
  std::fs::write(&settings_path, merged_settings).map_err(|e| {
  fbuild_core::FbuildError::Other(format!(
@@ -22,7 +24,7 @@ pub(super) fn emit(project_path: &Path) -> fbuild_core::Result<Vec<(PathBuf, boo
  })?;
 
  // Atomic write — FastLED/fbuild#844 bridge pair 6 (state-file write).
- let extensions_path = vscode_dir.join("extensions.json");
+ let extensions_path = NormalizedPath::from(vscode_dir.join("extensions.json"));
  let wrote_extensions = if extensions_path.exists() {
  false
  } else {

crates/fbuild-cli/src/cli/clangd_config/zed.rs

@@ -8,19 +8,21 @@
 //! relative to wherever clangd's working directory is (the project root
 //! Zed launches it from).
 
-use std::path::{Path, PathBuf};
+use std::path::Path;
+
+use fbuild_core::path::NormalizedPath;
 
 /// Write/merge `.zed/settings.json`. Returns `(path, was_written)` pairs
 /// for the caller's summary output — always `true` here since the merge
 /// itself is the "write" (there is no separate write-once file like VS
 /// Code's `extensions.json`).
-pub(super) fn emit(project_path: &Path) -> fbuild_core::Result<Vec<(PathBuf, bool)>> {
+pub(super) fn emit(project_path: &Path) -> fbuild_core::Result<Vec<(NormalizedPath, bool)>> {
  let zed_dir = project_path.join(".zed");
  std::fs::create_dir_all(&zed_dir).map_err(|e| {
  fbuild_core::FbuildError::Other(format!("failed to create {}: {}", zed_dir.display(), e))
  })?;
 
- let settings_path = zed_dir.join("settings.json");
+ let settings_path = NormalizedPath::from(zed_dir.join("settings.json"));
  let merged = merge_zed_settings(&settings_path)?;
  std::fs::write(&settings_path, merged).map_err(|e| {
  fbuild_core::FbuildError::Other(format!(