@typecad/framework-zephyr 1.0.0-alpha.10 → 1.0.0-alpha.11

package/src/toolchain/compat.ts

@@ -1,145 +1,154 @@
-// Zephyr version compatibility + board-target normalization.
-//
-// Two mechanisms absorb Zephyr version churn:
-//  1. checkZephyrCompat() — compare the installed Zephyr version against the
-//     declared range (manifest.compat.zephyr) so an incompatible Zephyr fails
-//     fast with a clear message instead of a cryptic west/CMake board error.
-//  2. resolveBoardTarget() — normalize the board target for the installed
-//     Zephyr version. Zephyr 4.3+ rejects bare multi-core board names
-//     (esp32s3_devkitc) and requires a qualified target
-//     (esp32s3_devkitc/esp32s3/procpu). This rewrites stale configs at build
-//     time so users don't have to regenerate them after a Zephyr upgrade.
-//
-// This module is intentionally pure (no chalk/ui/console) so it unit-tests
-// cleanly; the doctor and the toolchain decide how to present results.
-
-import { readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import manifest from '../framework.manifest.js';
-
-// ── minimal semver ──────────────────────────────────────────────────────────
-
-/** Parse "4.3.99" / "v4.3" / "4.3.99-rc1" → [4, 3, 99]. Undefined if unparseable. */
-export function parseVersion(v: string | undefined): [number, number, number] | undefined {
-  if (!v) return undefined;
-  const m = v.replace(/^v/i, '').match(/^(\d+)(?:\.(\d+))?(?:\.(\d+))?/);
-  if (!m) return undefined;
-  return [Number(m[1]), Number(m[2] ?? 0), Number(m[3] ?? 0)];
-}
-
-/** Compare two version strings: -1 if a<b, 0 if equal, 1 if a>b. */
-export function compareVersion(a: string, b: string): number {
-  const pa = parseVersion(a) ?? [0, 0, 0];
-  const pb = parseVersion(b) ?? [0, 0, 0];
-  for (let i = 0; i < 3; i++) {
-    if (pa[i]! < pb[i]!) return -1;
-    if (pa[i]! > pb[i]!) return 1;
-  }
-  return 0;
-}
-
-/**
- * Evaluate a simple range of space-separated comparators against a version.
- * Supported operators: >= <= > < =. Each comparator glues the operator to its
- * version (">=4.3", "<5.0"); spaces between comparators are AND.
- *   satisfiesRange("4.3.99", ">=4.3 <5.0") === true
- */
-export function satisfiesRange(version: string, range: string): boolean {
-  return range
-    .trim()
-    .split(/\s+/)
-    .every((clause) => {
-      const m = clause.replace(/\s+/g, '').match(/^(>=|<=|>|<|=)(.+)$/);
-      if (!m) return true; // ignore anything that isn't a comparator
-      const cmp = compareVersion(version, m[2]!);
-      switch (m[1]) {
-        case '>=': return cmp >= 0;
-        case '<=': return cmp <= 0;
-        case '>': return cmp > 0;
-        case '<': return cmp < 0;
-        case '=': return cmp === 0;
-        default: return true;
-      }
-    });
-}
-
-// ── Zephyr version detection ────────────────────────────────────────────────
-
-/**
- * Detect the installed Zephyr version from ZEPHYR_BASE/VERSION. Returns
- * undefined when ZEPHYR_BASE is unset or VERSION can't be read/parsed. Handles
- * the CMake-style file (VERSION_MAJOR = 4 / VERSION_MINOR = 3 / PATCHLEVEL = 99)
- * and a bare "4.3.99".
- */
-export function detectZephyrVersion(): string | undefined {
-  const base = process.env.ZEPHYR_BASE;
-  if (!base) return undefined;
-  let content: string;
-  try {
-    content = readFileSync(join(base, 'VERSION'), 'utf-8');
-  } catch {
-    return undefined;
-  }
-  const field = (key: string): string | undefined => {
-    const m = content.match(new RegExp(`^\\s*${key}\\s*=\\s*(\\d+)`, 'm'));
-    return m ? m[1] : undefined;
-  };
-  const major = field('VERSION_MAJOR');
-  if (major !== undefined) {
-    return `${major}.${field('VERSION_MINOR') ?? 0}.${field('PATCHLEVEL') ?? 0}`;
-  }
-  const m = content.match(/(\d+\.\d+(?:\.\d+)?)/);
-  return m ? m[1] : undefined;
-}
-
-// ── compat check ────────────────────────────────────────────────────────────
-
-export type CompatStatus = 'ok' | 'undetectable' | 'out-of-range';
-
-export interface CompatResult {
-  version: string | undefined;
-  /** Declared supported range (manifest.compat.zephyr), if any. */
-  range: string | undefined;
-  status: CompatStatus;
-}
-
-/**
- * Compare the detected Zephyr version against the declared compat range. Pure:
- * returns a status; the caller decides whether to throw/warn. 'ok' covers both
- * "in range" and "no range declared".
- */
-export function checkZephyrCompat(version: string | undefined): CompatResult {
-  const range = manifest.compat?.zephyr;
-  if (!range) return { version, range, status: 'ok' };
-  if (version === undefined) return { version, range, status: 'undetectable' };
-  return { version, range, status: satisfiesRange(version, range) ? 'ok' : 'out-of-range' };
-}
-
-// ── board-target normalization ──────────────────────────────────────────────
-
-/**
- * For Zephyr >=4.3, multi-core ESP32 boards require a qualified board target
- * (board/<soc>/<core>) — the bare id is rejected with "Board qualifiers … not
- * found". Map each known multi-core board id to its procpu (main app core)
- * qualified form. procpu is the core that runs application firmware; appcpu is
- * the secondary core (selected explicitly only when offloading to it).
- */
-const QUALIFIED_TARGETS_GE_4_3: Record<string, string> = {
-  esp32_devkitc: 'esp32_devkitc/esp32/procpu',
-  esp32s3_devkitc: 'esp32s3_devkitc/esp32s3/procpu',
-};
-
-/**
- * Normalize a board target for the installed Zephyr version. Rewrites a stale
- * bare id (esp32s3_devkitc) to the qualified form on Zephyr >=4.3; idempotent
- * if the target is already qualified. Older Zephyr, single-core boards
- * (xiao_ble), and unknown boards pass through unchanged.
- */
-export function resolveBoardTarget(boardTarget: string, version: string | undefined): string {
-  const boardId = boardTarget.split('/')[0]!;
-  if (version !== undefined && satisfiesRange(version, '>=4.3')) {
-    const qualified = QUALIFIED_TARGETS_GE_4_3[boardId];
-    if (qualified) return qualified;
-  }
-  return boardTarget;
-}
+// Zephyr version compatibility + board-target normalization.
+//
+// Two mechanisms absorb Zephyr version churn:
+//  1. checkZephyrCompat() — compare the installed Zephyr version against the
+//     declared range (manifest.compat.zephyr) so an incompatible Zephyr fails
+//     fast with a clear message instead of a cryptic west/CMake board error.
+//  2. resolveBoardTarget() — normalize the board target for the installed
+//     Zephyr version. Zephyr 4.3+ rejects bare multi-core board names
+//     (esp32s3_devkitc) and requires a qualified target
+//     (esp32s3_devkitc/esp32s3/procpu). This rewrites stale configs at build
+//     time so users don't have to regenerate them after a Zephyr upgrade.
+//
+// This module is intentionally pure (no chalk/ui/console) so it unit-tests
+// cleanly; the doctor and the toolchain decide how to present results.
+
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import manifest from '../framework.manifest.js';
+import { discoverWest } from './west-discover.js';
+
+// ── minimal semver ──────────────────────────────────────────────────────────
+
+/** Parse "4.3.99" / "v4.3" / "4.3.99-rc1" → [4, 3, 99]. Undefined if unparseable. */
+export function parseVersion(v: string | undefined): [number, number, number] | undefined {
+  if (!v) return undefined;
+  const m = v.replace(/^v/i, '').match(/^(\d+)(?:\.(\d+))?(?:\.(\d+))?/);
+  if (!m) return undefined;
+  return [Number(m[1]), Number(m[2] ?? 0), Number(m[3] ?? 0)];
+}
+
+/** Compare two version strings: -1 if a<b, 0 if equal, 1 if a>b. */
+export function compareVersion(a: string, b: string): number {
+  const pa = parseVersion(a) ?? [0, 0, 0];
+  const pb = parseVersion(b) ?? [0, 0, 0];
+  for (let i = 0; i < 3; i++) {
+    if (pa[i]! < pb[i]!) return -1;
+    if (pa[i]! > pb[i]!) return 1;
+  }
+  return 0;
+}
+
+/**
+ * Evaluate a simple range of space-separated comparators against a version.
+ * Supported operators: >= <= > < =. Each comparator glues the operator to its
+ * version (">=4.3", "<5.0"); spaces between comparators are AND.
+ *   satisfiesRange("4.3.99", ">=4.3 <5.0") === true
+ */
+export function satisfiesRange(version: string, range: string): boolean {
+  return range
+    .trim()
+    .split(/\s+/)
+    .every((clause) => {
+      const m = clause.replace(/\s+/g, '').match(/^(>=|<=|>|<|=)(.+)$/);
+      if (!m) return true; // ignore anything that isn't a comparator
+      const cmp = compareVersion(version, m[2]!);
+      switch (m[1]) {
+        case '>=': return cmp >= 0;
+        case '<=': return cmp <= 0;
+        case '>': return cmp > 0;
+        case '<': return cmp < 0;
+        case '=': return cmp === 0;
+        default: return true;
+      }
+    });
+}
+
+// ── Zephyr version detection ────────────────────────────────────────────────
+
+/**
+ * Detect the installed Zephyr version from ZEPHYR_BASE/VERSION. Returns
+ * undefined when ZEPHYR_BASE is unset or VERSION can't be read/parsed. Handles
+ * the CMake-style file (VERSION_MAJOR = 4 / VERSION_MINOR = 3 / PATCHLEVEL = 99)
+ * and a bare "4.3.99".
+ */
+export function detectZephyrVersion(): string | undefined {
+  let base = process.env.ZEPHYR_BASE;
+  if (!base) {
+    // Fall back to the discovered west install's zephyrBase — covers the
+    // micromamba env from @typecad/zephyr-installer WITHOUT activation.
+    // (micromamba run sets ZEPHYR_BASE only inside the west subprocess; this
+    // makes the compat check work in the parent cuttlefish process too.)
+    const install = discoverWest();
+    base = install?.zephyrBase;
+  }
+  if (!base) return undefined;
+  let content: string;
+  try {
+    content = readFileSync(join(base, 'VERSION'), 'utf-8');
+  } catch {
+    return undefined;
+  }
+  const field = (key: string): string | undefined => {
+    const m = content.match(new RegExp(`^\\s*${key}\\s*=\\s*(\\d+)`, 'm'));
+    return m ? m[1] : undefined;
+  };
+  const major = field('VERSION_MAJOR');
+  if (major !== undefined) {
+    return `${major}.${field('VERSION_MINOR') ?? 0}.${field('PATCHLEVEL') ?? 0}`;
+  }
+  const m = content.match(/(\d+\.\d+(?:\.\d+)?)/);
+  return m ? m[1] : undefined;
+}
+
+// ── compat check ────────────────────────────────────────────────────────────
+
+export type CompatStatus = 'ok' | 'undetectable' | 'out-of-range';
+
+export interface CompatResult {
+  version: string | undefined;
+  /** Declared supported range (manifest.compat.zephyr), if any. */
+  range: string | undefined;
+  status: CompatStatus;
+}
+
+/**
+ * Compare the detected Zephyr version against the declared compat range. Pure:
+ * returns a status; the caller decides whether to throw/warn. 'ok' covers both
+ * "in range" and "no range declared".
+ */
+export function checkZephyrCompat(version: string | undefined): CompatResult {
+  const range = manifest.compat?.zephyr;
+  if (!range) return { version, range, status: 'ok' };
+  if (version === undefined) return { version, range, status: 'undetectable' };
+  return { version, range, status: satisfiesRange(version, range) ? 'ok' : 'out-of-range' };
+}
+
+// ── board-target normalization ──────────────────────────────────────────────
+
+/**
+ * For Zephyr >=4.3, multi-core ESP32 boards require a qualified board target
+ * (board/<soc>/<core>) — the bare id is rejected with "Board qualifiers … not
+ * found". Map each known multi-core board id to its procpu (main app core)
+ * qualified form. procpu is the core that runs application firmware; appcpu is
+ * the secondary core (selected explicitly only when offloading to it).
+ */
+const QUALIFIED_TARGETS_GE_4_3: Record<string, string> = {
+  esp32_devkitc: 'esp32_devkitc/esp32/procpu',
+  esp32s3_devkitc: 'esp32s3_devkitc/esp32s3/procpu',
+};
+
+/**
+ * Normalize a board target for the installed Zephyr version. Rewrites a stale
+ * bare id (esp32s3_devkitc) to the qualified form on Zephyr >=4.3; idempotent
+ * if the target is already qualified. Older Zephyr, single-core boards
+ * (xiao_ble), and unknown boards pass through unchanged.
+ */
+export function resolveBoardTarget(boardTarget: string, version: string | undefined): string {
+  const boardId = boardTarget.split('/')[0]!;
+  if (version !== undefined && satisfiesRange(version, '>=4.3')) {
+    const qualified = QUALIFIED_TARGETS_GE_4_3[boardId];
+    if (qualified) return qualified;
+  }
+  return boardTarget;
+}

package/src/toolchain/env-check.ts

@@ -0,0 +1,285 @@
+// ---------------------------------------------------------------------------
+// Zephyr environment check — the shared detection behind `cuttlefish doctor`.
+//
+// Mirrors @typecad/arduino-cli's checkArduinoEnv(): gather the impure
+// environment facts once (west presence + version, Zephyr version, board
+// existence), then reduce them to a structured result the doctor (and, later,
+// the build/test gates) can present uniformly. The check is side-effect-free
+// and never throws — it never installs or mutates anything.
+//
+// Two parity checks vs. framework-arduino's doctor:
+//  1. west (the Zephyr build tool) is discoverable + responsive — the direct
+//     analog of "arduino-cli is installed". discoverWest() already confirms
+//     responsiveness via `west --version`; we additionally capture the version
+//     string to report it.
+//  2. the configured board target exists in the Zephyr checkout
+//     ($ZEPHYR_BASE/boards/) — the analog of "the required core is installed".
+//
+// The existing compat-range check (compat.ts) is folded in as a third check so
+// the doctor reports everything through one entry point.
+// ---------------------------------------------------------------------------
+
+import { spawnSync } from 'node:child_process';
+import { existsSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+
+import { type WestInstall, discoverWest, resetWestDiscoveryCache } from './west-discover.js';
+import { westSpawn } from './west-spawn.js';
+import {
+  detectZephyrVersion,
+  checkZephyrCompat,
+  resolveBoardTarget,
+  type CompatStatus,
+} from './compat.js';
+
+// ---- probe data (impure facts, injectable for tests) -----------------------
+
+/**
+ * Raw west facts gathered from discovery + a `west --version` probe. Mirrors
+ * ArduinoCliProbeData: `westFound` is true when a usable west install was
+ * discovered (discovery itself probes responsiveness).
+ */
+export interface WestProbeData {
+  /** A usable west install was discovered. */
+  westFound: boolean;
+  /** west version string if the `--version` probe parsed one, e.g. "1.3.0". */
+  westVersion: string | undefined;
+  /** Which discovery strategy found west, for surfacing to the user. */
+  source: WestInstall['source'] | undefined;
+  /** Effective ZEPHYR_BASE (env var, else a base discovery surfaced). */
+  zephyrBase: string | undefined;
+}
+
+/**
+ * Test-injection seam for checkZephyrEnv. Mirrors Arduino's
+ * CheckArduinoEnvOptions.fakeProbe so tests never spawn a real west/python.
+ */
+export interface CheckZephyrEnvOptions {
+  /** FOR TESTS ONLY: skip the real probe and use this data directly. */
+  fakeWestProbe?: WestProbeData;
+  /** FOR TESTS ONLY: override the board-existence lookup. */
+  fakeBoardExists?: (boardId: string, zephyrBase: string | undefined) => boolean | undefined;
+}
+
+// ---- result types (mirror ArduinoEnvResult's shape) ------------------------
+
+export interface ZephyrEnvCheck {
+  /** west (the Zephyr build tool) was discovered and responsive. */
+  westFound: boolean;
+  /** west version string if known, e.g. "1.3.0". */
+  westVersion: string | undefined;
+  /** Discovery strategy that found west, for display. */
+  westSource: WestInstall['source'] | undefined;
+  /** Effective ZEPHYR_BASE (env var, else a discovered base). */
+  zephyrBase: string | undefined;
+  /** Detected Zephyr RTOS version from $ZEPHYR_BASE/VERSION, if readable. */
+  zephyrVersion: string | undefined;
+  /** Declared supported range (manifest.compat.zephyr), if any. */
+  compatRange: string | undefined;
+  /** Result of the compat-range check against the detected version. */
+  compatStatus: CompatStatus;
+  /** Raw board target from cuttlefish.config.ts, if configured. */
+  buildTarget: string | undefined;
+  /** buildTarget normalized for the installed Zephyr version (may equal it). */
+  resolvedBoardTarget: string | undefined;
+  /** Does the resolved board exist in the checkout? undefined = undetermined. */
+  boardTargetSupported: boolean | undefined;
+}
+
+export type ZephyrEnvOk = { ok: true; check: ZephyrEnvCheck };
+
+export type ZephyrEnvFailure = {
+  ok: false;
+  reason: 'west-not-found' | 'zephyr-out-of-range' | 'board-not-supported';
+  check: ZephyrEnvCheck;
+  /** Human-readable lines ready to print. */
+  messages: string[];
+  /** Exact remediation hint, when applicable. */
+  fixCommand: string | undefined;
+};
+
+export type ZephyrEnvResult = ZephyrEnvOk | ZephyrEnvFailure;
+
+// ---- west probe (impure; isolated + cached + overridable) ------------------
+
+let cachedProbe: WestProbeData | undefined;
+
+/** Clear the west-probe cache (for tests). Also resets discovery cache. */
+export function resetWestProbeCacheForTest(): void {
+  cachedProbe = undefined;
+  resetWestDiscoveryCache();
+}
+
+/**
+ * Gather west facts: discover a usable install, then run `west --version`
+ * through it to capture the version. Memoized for the process lifetime (west
+ * installs don't move). Never throws — returns westFound:false on any failure.
+ */
+export function probeWestEnv(): WestProbeData {
+  if (cachedProbe) return cachedProbe;
+
+  const install = discoverWest();
+  const envBase = process.env.ZEPHYR_BASE || undefined;
+  if (!install) {
+    const data: WestProbeData = {
+      westFound: false,
+      westVersion: undefined,
+      source: undefined,
+      zephyrBase: envBase,
+    };
+    cachedProbe = data;
+    return data;
+  }
+
+  // Run `west --version` through the discovered install to capture the version.
+  // discoverWest() already confirmed responsiveness, so a parse failure here is
+  // not "unresponsive" — it just means we couldn't read a version token.
+  let westVersion: string | undefined;
+  try {
+    const inv = westSpawn(['--version'], {
+      encoding: 'utf8',
+      timeout: 15_000,
+      windowsHide: true,
+    });
+    const r = spawnSync(inv.command, inv.args, inv.options);
+    if (r.status === 0) {
+      // inv.options is a generic SpawnSyncOptions (no encoding literal), so
+      // coerce stdout to a string before matching.
+      const out = typeof r.stdout === 'string' ? r.stdout : '';
+      const m = out.match(/v?(\d+\.\d+\.\d+)/);
+      westVersion = m ? m[1] : undefined;
+    }
+  } catch {
+    // westSpawn throws only when discovery fails — but discovery already
+    // succeeded (install is non-null). Defensive: treat as no version read.
+    westVersion = undefined;
+  }
+
+  const data: WestProbeData = {
+    westFound: true,
+    westVersion,
+    source: install.source,
+    zephyrBase: envBase ?? install.zephyrBase,
+  };
+  cachedProbe = data;
+  return data;
+}
+
+// ---- board existence (pure-ish fs probe) -----------------------------------
+
+/**
+ * Does `boardId` exist as a board directory in the Zephyr checkout? Checks the
+ * HWMv2 vendor layout used by Zephyr 4.x: $ZEPHYR_BASE/boards/<vendor>/<boardId>.
+ * Returns true/false when determinable; undefined when the base is unknown or
+ * the boards/ tree can't be read (so callers never fail on an inconclusive
+ * lookup — they just skip the board check).
+ */
+export function boardExistsInCheckout(
+  boardId: string,
+  zephyrBase: string | undefined,
+): boolean | undefined {
+  if (!zephyrBase) return undefined;
+  const boards = join(zephyrBase, 'boards');
+  try {
+    const entries = readdirSync(boards, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory() && existsSync(join(boards, entry.name, boardId))) {
+        return true;
+      }
+    }
+    return false;
+  } catch {
+    return undefined;
+  }
+}
+
+// ---- main entry point -------------------------------------------------------
+
+/**
+ * Verify the environment can build for `buildTarget`. Cheap and
+ * side-effect-free: discovers west, reads the Zephyr version, checks the compat
+ * range, and — when a target is configured — verifies the board exists in the
+ * checkout. Reports what (if anything) is wrong.
+ *
+ * - If `buildTarget` is undefined/empty, the board check is skipped (not a
+ *   failure), mirroring Arduino's no-FQBN path.
+ * - Never installs anything. Never mutates the user environment.
+ * - Never throws — always returns a result. Callers decide how to react.
+ *
+ * `options` is for-test only (injects fake probe data / board lookup).
+ */
+export function checkZephyrEnv(
+  buildTarget?: string,
+  options?: CheckZephyrEnvOptions,
+): ZephyrEnvResult {
+  const probe = options?.fakeWestProbe ?? probeWestEnv();
+  const boardLookup = options?.fakeBoardExists ?? boardExistsInCheckout;
+
+  const zephyrVersion = detectZephyrVersion();
+  const compat = checkZephyrCompat(zephyrVersion);
+  const resolvedBoardTarget = buildTarget ? resolveBoardTarget(buildTarget, zephyrVersion) : undefined;
+  const boardId = resolvedBoardTarget ? resolvedBoardTarget.split('/')[0]! : undefined;
+  const boardTargetSupported =
+    boardId !== undefined ? boardLookup(boardId, probe.zephyrBase) : undefined;
+
+  const check: ZephyrEnvCheck = {
+    westFound: probe.westFound,
+    westVersion: probe.westVersion,
+    westSource: probe.source,
+    zephyrBase: probe.zephyrBase,
+    zephyrVersion,
+    compatRange: compat.range,
+    compatStatus: compat.status,
+    buildTarget,
+    resolvedBoardTarget,
+    boardTargetSupported,
+  };
+
+  // 1. west (the build tool) missing entirely — nothing else can run.
+  if (!probe.westFound) {
+    return {
+      ok: false,
+      reason: 'west-not-found',
+      check,
+      messages: [
+        "west (the Zephyr build tool) was not found.",
+        "  Run the typeCAD Zephyr installer, activate an existing Zephyr venv,",
+        "  set ZEPHYR_BASE to a Zephyr SDK root, or `pip install west`.",
+      ],
+      fixCommand: undefined,
+    };
+  }
+
+  // 2. west healthy but the Zephyr RTOS is outside the supported range.
+  if (compat.status === 'out-of-range') {
+    return {
+      ok: false,
+      reason: 'zephyr-out-of-range',
+      check,
+      messages: [
+        `Zephyr ${zephyrVersion} is outside the supported range (${compat.range}) for @typecad/framework-zephyr.`,
+        "  Set ZEPHYR_BASE to a compatible Zephyr checkout, or install one via '@typecad/zephyr-installer'.",
+      ],
+      fixCommand: undefined,
+    };
+  }
+
+  // 3. west + version OK — only check the board when a target is configured and
+  // the lookup was able to answer. A missing/absent target is not a board
+  // problem; an inconclusive lookup (no base) is reported as a skip, not a fail.
+  if (buildTarget && boardTargetSupported === false) {
+    return {
+      ok: false,
+      reason: 'board-not-supported',
+      check,
+      messages: [
+        `Board target '${resolvedBoardTarget}' was not found in this Zephyr checkout` +
+          (probe.zephyrBase ? ` (${join(probe.zephyrBase, 'boards')}).` : '.'),
+        "  Check the board id, or run `west boards` to list boards in this checkout.",
+      ],
+      fixCommand: 'west boards',
+    };
+  }
+
+  return { ok: true, check };
+}

package/src/toolchain/scaffold.ts

@@ -85,6 +85,9 @@ export function scaffoldZephyrProject(projectRoot: string, debug = false, userKc
   const usage: KconfigUsage = {
     usesAdc: uses('adc_'),
     usesPwm: uses('pwm_'),
+    usesDac: uses('dac_') || uses('__tc_dac'),
+    usesFS: uses('__tc_fs'),
+    usesHwtimer: uses('counter_') || uses('__tc_hw'),
     usesI2c: uses('i2c_'),
     usesSpi: uses('spi_'),
     usesUart: uses('uart_'),