@typecad/framework-zephyr 1.0.0-alpha.16 → 1.0.0-alpha.19

package/src/toolchain/west-discover.ts

@@ -11,7 +11,7 @@
 //   1. `west` already on PATH (env already activated / global install).
 //   2. $ZEPHYR_BASE venv: ${ZEPHYR_BASE}/../.venv/<python> -m west.
 //   3. micromamba env from @typecad/zephyr-installer (invoked via `micromamba run`,
-//      so cuttlefish builds work with NO manual activation).
+//      so typecad-hal builds work with NO manual activation).
 //   4. Well-known workspace layouts: ~/zephyrproject/.venv, /opt/zephyrproject/.
 //      venv, etc.
 //   5. System pythons (`python`, `python3`, `py`) via `-m west`.
@@ -142,6 +142,33 @@ export function discoverFromZephyrBase(): WestInstall | null {
   };
 }
 
+/** The installer-written SDK dir for the default micromamba env, when the
+ *  installer has run on this machine. Read WITHOUT requiring micromamba
+ *  mode — a PATH/venv west install is enriched with it so builds spawned
+ *  through it still pin the installer's SDK (otherwise Zephyr's CMake
+ *  searches $HOME and can pick up a stray, older SDK). */
+export function installerSdkDir(): string | undefined {
+  const mm = findMicromamba();
+  if (!mm) return undefined;
+  const envName = process.env.TYPECAD_ZEPHYR_ENV || 'zephyr';
+  const envDir = join(mm.rootPrefix, 'envs', envName);
+  if (!existsSync(envDir)) return undefined;
+  const sdk = readMicromambaEnvVar(envDir, 'TYPECAD_ZEPHYR_SDK_INSTALL_DIR');
+  return sdk && existsSync(sdk) ? sdk : undefined;
+}
+
+/**
+ * The micromamba env created by `@typecad/zephyr-installer`. The env's west
+ * lives at envs/<name>/bin/west (POSIX) or Scripts/west.exe (Windows). Found
+ * installs are invoked via `micromamba run -n <name> west …` (see
+ * west-spawn.ts), which sets up the env's full PATH (cmake/ninja/dtc) AND runs
+ * the activation hook (ZEPHYR_BASE / ZEPHYR_SDK_INSTALL_DIR) — so builds work
+ * with NO manual `micromamba activate`. This is what makes a fresh
+ * `typecad-hal build` succeed in any project without the user activating.
+ *
+ * Env name defaults to "zephyr"; override via TYPECAD_ZEPHYR_ENV. File-check
+ * based (no spawn) so it's cheap to run on every invocation.
+ */
 // ── Strategy 3: micromamba env (the @typecad/zephyr-installer install) ─────
 
 // Locate the micromamba binary + root prefix. The installer downloads
@@ -156,18 +183,6 @@ function findMicromamba(): { exe: string; rootPrefix: string } | null {
   return existsSync(exe) ? { exe, rootPrefix: root } : null;
 }
 
-/**
- * The micromamba env created by `@typecad/zephyr-installer`. The env's west
- * lives at envs/<name>/bin/west (POSIX) or Scripts/west.exe (Windows). Found
- * installs are invoked via `micromamba run -n <name> west …` (see
- * west-spawn.ts), which sets up the env's full PATH (cmake/ninja/dtc) AND runs
- * the activation hook (ZEPHYR_BASE / ZEPHYR_SDK_INSTALL_DIR) — so cuttlefish
- * builds work with NO manual `micromamba activate`. This is what makes a fresh
- * `cuttlefish build` succeed in any project without the user activating.
- *
- * Env name defaults to "zephyr"; override via TYPECAD_ZEPHYR_ENV. File-check
- * based (no spawn) so it's cheap to run on every cuttlefish invocation.
- */
 /** Read a TYPECAD_ZEPHYR_* value from the installer-written env-vars file in
  *  a micromamba env. Handles .sh (export VAR="val"), .bat (set "VAR=val"),
  *  and .ps1 ($env:VAR = "val"). Returns undefined if absent/unreadable. */
@@ -325,6 +340,13 @@ export function discoverWest(): WestInstall | null {
       install = null;
     }
     if (install) {
+      // A PATH/venv west install knows nothing about the installer's SDK.
+      // Enrich it: west-spawn pins the child's ZEPHYR_SDK_INSTALL_DIR to the
+      // installer dir, so Zephyr's CMake cannot pick up a stray SDK from
+      // $HOME (a version mismatch that only surfaces at configure time).
+      if (!install.sdkInstallDir) {
+        install.sdkInstallDir = installerSdkDir();
+      }
       cachedDiscover = install;
       return install;
     }

package/src/toolchain/west-spawn.ts

@@ -1,168 +1,174 @@
-// ---------------------------------------------------------------------------
-// west spawn helper — build a spawnSync invocation for `west <args>`
-//
-// Mirrors framework-esp32's idfSpawn(): given the discovered WestInstall,
-// produce {command, args, env} that the toolchain destructures into spawnSync.
-//
-// Two modes:
-//   - 'launcher': spawn the `west` launcher directly (mode 'launcher').
-//   - 'module'  : spawn `<python> -m west ...` (mode 'module'). This is the
-//                 robust cross-platform form — it activates the venv's
-//                 interpreter for the one process without sourcing anything.
-//
-// ZEPHYR_BASE is injected into the spawn env when a SDK root was discovered
-// (find_package(Zephyr) needs it). west's prj.conf/CMakeLists are found via
-// the project dir regardless.
-// ---------------------------------------------------------------------------
-
-import type { SpawnSyncOptions } from 'node:child_process';
-import { dirname, join } from 'node:path';
-import { existsSync } from 'node:fs';
-import { type WestInstall, discoverWest } from './west-discover.js';
-
-export interface WestInvocation {
-  /** The command to spawnSync: a `west` launcher or a Python interpreter. */
-  command: string;
-  /** Args for the command (includes `-m west` when in module mode). */
-  args: string[];
-  /** Base spawn options with cwd/timeout/encoding/stdio, plus the env carrying
-   *  ZEPHYR_BASE when discovered. */
-  options: SpawnSyncOptions;
-  /** The install the invocation was built from, for surfacing to the user. */
-  install: WestInstall;
-}
-
-/**
- * The Scripts/ (Windows) or bin/ (POSIX) directory of the venv the discovered
- * west runs under. `pythonExecutable` lives in that directory, so it is its
- * dirname. Returns undefined for launcher-mode installs where no venv is known.
- */
-function venvBinDir(install: WestInstall): string | undefined {
-  return install.pythonExecutable ? dirname(install.pythonExecutable) : undefined;
-}
-
-/**
- * The env to pass to the west spawn: the process env, with ZEPHYR_BASE injected
- * when a SDK root was discovered, AND the venv's bin/Scripts dir prepended to
- * PATH when west was found via a venv Python.
- *
- * The PATH prepend matters: `west flash` shells out to bare runner tools
- * (`esptool`, `openocd`, `nrfjprog`, …) via check_call, so they resolve from
- * PATH. Without the prepend, the user's PATH may surface a *different* tool
- * ahead of the venv's — e.g. an older esptool whose argument spelling is
- * incompatible with the runner. Putting the venv's bin first makes west's
- * delegated subprocesses resolve to the same versions west itself runs under.
- */
-export function buildEnv(install: WestInstall): NodeJS.ProcessEnv {
-  const env = { ...process.env };
-  if (install.zephyrBase && !env.ZEPHYR_BASE) {
-    env.ZEPHYR_BASE = install.zephyrBase;
-  }
-  // SWD flashing (`zephyr.runner: 'openocd'`): west's openocd runner resolves
-  // a bare `openocd` from PATH. The Zephyr SDK ships it under
-  // hosttools/openocd/bin (the SDK's own setup.cmd puts that dir on PATH for
-  // activated terminals) — do the same for spawned west processes so ST-Link
-  // flashing works without activation. $ZEPHYR_SDK_INSTALL_DIR (set by an
-  // activated env) wins over the discovered install dir.
-  const sdkRoot = env.ZEPHYR_SDK_INSTALL_DIR || install.sdkInstallDir;
-  const openocdBin = sdkRoot ? join(sdkRoot, 'hosttools', 'openocd', 'bin') : undefined;
-  const prepend = [
-    openocdBin !== undefined && existsSync(openocdBin) ? openocdBin : undefined,
-    venvBinDir(install),
-  ].filter((d): d is string => d !== undefined);
-  if (prepend.length > 0) {
-    const sep = process.platform === 'win32' ? ';' : ':';
-    // On Windows the PATH environment variable may be cased as `Path` (the
-    // registry-native form, the only one populated when node is launched from
-    // PowerShell/cmd) or `PATH` (POSIX form, set by Git Bash). Writing only one
-    // casing can leave the other stale/empty, which under PowerShell would drop
-    // the user's real PATH (cmake, ninja, …) — breaking `west` configure. Read
-    // whichever casing is populated and write that same casing back, preserving
-    // the full existing value with the discovered dirs prepended.
-    const existing = env.Path ?? env.PATH ?? '';
-    const updated = prepend.join(sep) + sep + existing;
-    if (env.Path !== undefined || (env.PATH === undefined && process.platform === 'win32')) {
-      env.Path = updated;
-    } else {
-      env.PATH = updated;
-    }
-  }
-  return env;
-}
-
-/**
- * Build a spawn invocation that runs `west <westArgs>`.
- *
- * `baseOptions` carries the cwd/timeout/stdio settings the caller wants;
- * westSpawn preserves them and injects the discovery env. The returned object
- * destructures directly into spawnSync:
- *
- *   const inv = westSpawn(['build', '-b', 'xiao_ble', projectRoot], { cwd, timeout });
- *   spawnSync(inv.command, inv.args, inv.options);
- *
- * Throws a clear, actionable error when no usable west install is discovered.
- */
-export function westSpawn(
-  westArgs: string[],
-  baseOptions: SpawnSyncOptions,
-): WestInvocation {
-  const install = discoverWest();
-  if (!install) {
-    throw new Error(
-      [
-        'west (the Zephyr build tool) was not found.',
-        '',
-        'cuttlefish looked for it on PATH, in $ZEPHYR_BASE/.venv, in common',
-        'Zephyr workspace dirs (~/zephyrproject/.venv), and as a system',
-        "Python module (`python -m west`). To fix:",
-        '',
-        '  • Run the typeCAD Zephyr installer (one command, any OS — needs Node ≥18):',
-        '      node packages/zephyr-installer/install.mjs',
-        '    then `micromamba activate zephyr` and retry.',
-        '  • Or activate an existing Zephyr venv in this shell, or',
-        '  • Or set ZEPHYR_BASE to your Zephyr SDK root (the venv at $ZEPHYR_BASE/../.venv is then used), or',
-        '  • Or install west into a discoverable Python: pip install west',
-        '',
-        'See https://docs.zephyrproject.org/latest/develop/getting_started/index.html',
-      ].join('\n'),
-    );
-  }
-
-  const env = buildEnv(install);
-  // Strip `shell` if present — we pass absolute paths / known commands, and
-  // an explicit shell changes arg-quoting semantics on Windows.
-  const { shell: _drop, ...optsWithoutShell } = baseOptions as any;
-
-  if (install.mode === 'micromamba' && install.micromambaExe) {
-    // `micromamba run -n <env> west …` sets up the env's full PATH
-    // (cmake/ninja/dtc) and runs the activation hook (ZEPHYR_BASE /
-    // ZEPHYR_SDK_INSTALL_DIR), so cuttlefish builds work WITHOUT the user
-    // activating the env. Inject MAMBA_ROOT_PREFIX so micromamba finds envs.
-    const mmEnv = { ...env };
-    if (install.mambaRootPrefix) mmEnv.MAMBA_ROOT_PREFIX = install.mambaRootPrefix;
-    return {
-      command: install.micromambaExe,
-      args: ['run', '-n', install.envName ?? 'zephyr', 'west', ...westArgs],
-      options: { ...optsWithoutShell, env: mmEnv },
-      install,
-    };
-  }
-
-  if (install.mode === 'launcher' && install.westExecutable) {
-    return {
-      command: install.westExecutable,
-      args: westArgs,
-      options: { ...optsWithoutShell, env },
-      install,
-    };
-  }
-
-  // module mode: <python> -m west <args>
-  const py = install.pythonExecutable!;
-  return {
-    command: py,
-    args: ['-m', 'west', ...westArgs],
-    options: { ...optsWithoutShell, env },
-    install,
-  };
-}
+// ---------------------------------------------------------------------------
+// west spawn helper — build a spawnSync invocation for `west <args>`
+//
+// Mirrors framework-esp32's idfSpawn(): given the discovered WestInstall,
+// produce {command, args, env} that the toolchain destructures into spawnSync.
+//
+// Two modes:
+//   - 'launcher': spawn the `west` launcher directly (mode 'launcher').
+//   - 'module'  : spawn `<python> -m west ...` (mode 'module'). This is the
+//                 robust cross-platform form — it activates the venv's
+//                 interpreter for the one process without sourcing anything.
+//
+// ZEPHYR_BASE is injected into the spawn env when a SDK root was discovered
+// (find_package(Zephyr) needs it). west's prj.conf/CMakeLists are found via
+// the project dir regardless.
+// ---------------------------------------------------------------------------
+
+import type { SpawnSyncOptions } from 'node:child_process';
+import { dirname, join } from 'node:path';
+import { existsSync } from 'node:fs';
+import { type WestInstall, discoverWest } from './west-discover.js';
+
+export interface WestInvocation {
+  /** The command to spawnSync: a `west` launcher or a Python interpreter. */
+  command: string;
+  /** Args for the command (includes `-m west` when in module mode). */
+  args: string[];
+  /** Base spawn options with cwd/timeout/encoding/stdio, plus the env carrying
+   *  ZEPHYR_BASE when discovered. */
+  options: SpawnSyncOptions;
+  /** The install the invocation was built from, for surfacing to the user. */
+  install: WestInstall;
+}
+
+/**
+ * The Scripts/ (Windows) or bin/ (POSIX) directory of the venv the discovered
+ * west runs under. `pythonExecutable` lives in that directory, so it is its
+ * dirname. Returns undefined for launcher-mode installs where no venv is known.
+ */
+function venvBinDir(install: WestInstall): string | undefined {
+  return install.pythonExecutable ? dirname(install.pythonExecutable) : undefined;
+}
+
+/**
+ * The env to pass to the west spawn: the process env, with ZEPHYR_BASE injected
+ * when a SDK root was discovered, AND the venv's bin/Scripts dir prepended to
+ * PATH when west was found via a venv Python.
+ *
+ * The PATH prepend matters: `west flash` shells out to bare runner tools
+ * (`esptool`, `openocd`, `nrfjprog`, …) via check_call, so they resolve from
+ * PATH. Without the prepend, the user's PATH may surface a *different* tool
+ * ahead of the venv's — e.g. an older esptool whose argument spelling is
+ * incompatible with the runner. Putting the venv's bin first makes west's
+ * delegated subprocesses resolve to the same versions west itself runs under.
+ */
+export function buildEnv(install: WestInstall): NodeJS.ProcessEnv {
+  const env = { ...process.env };
+  if (install.zephyrBase && !env.ZEPHYR_BASE) {
+    env.ZEPHYR_BASE = install.zephyrBase;
+  }
+  // SWD flashing (`zephyr.runner: 'openocd'`): west's openocd runner resolves
+  // a bare `openocd` from PATH. The Zephyr SDK ships it under
+  // hosttools/openocd/bin (the SDK's own setup.cmd puts that dir on PATH for
+  // activated terminals) — do the same for spawned west processes so ST-Link
+  // flashing works without activation. $ZEPHYR_SDK_INSTALL_DIR (set by an
+  // activated env) wins over the discovered install dir.
+  const sdkRoot = env.ZEPHYR_SDK_INSTALL_DIR || install.sdkInstallDir;
+  // Pin the west/cmake child to the discovered SDK: without this, Zephyr's
+  // FindZephyr-sdk searches $HOME and can latch onto a stray, older SDK —
+  // a configure-time version failure that only surfaces in the build log.
+  if (!env.ZEPHYR_SDK_INSTALL_DIR && install.sdkInstallDir) {
+    env.ZEPHYR_SDK_INSTALL_DIR = install.sdkInstallDir;
+  }
+  const openocdBin = sdkRoot ? join(sdkRoot, 'hosttools', 'openocd', 'bin') : undefined;
+  const prepend = [
+    openocdBin !== undefined && existsSync(openocdBin) ? openocdBin : undefined,
+    venvBinDir(install),
+  ].filter((d): d is string => d !== undefined);
+  if (prepend.length > 0) {
+    const sep = process.platform === 'win32' ? ';' : ':';
+    // On Windows the PATH environment variable may be cased as `Path` (the
+    // registry-native form, the only one populated when node is launched from
+    // PowerShell/cmd) or `PATH` (POSIX form, set by Git Bash). Writing only one
+    // casing can leave the other stale/empty, which under PowerShell would drop
+    // the user's real PATH (cmake, ninja, …) — breaking `west` configure. Read
+    // whichever casing is populated and write that same casing back, preserving
+    // the full existing value with the discovered dirs prepended.
+    const existing = env.Path ?? env.PATH ?? '';
+    const updated = prepend.join(sep) + sep + existing;
+    if (env.Path !== undefined || (env.PATH === undefined && process.platform === 'win32')) {
+      env.Path = updated;
+    } else {
+      env.PATH = updated;
+    }
+  }
+  return env;
+}
+
+/**
+ * Build a spawn invocation that runs `west <westArgs>`.
+ *
+ * `baseOptions` carries the cwd/timeout/stdio settings the caller wants;
+ * westSpawn preserves them and injects the discovery env. The returned object
+ * destructures directly into spawnSync:
+ *
+ *   const inv = westSpawn(['build', '-b', 'xiao_ble', projectRoot], { cwd, timeout });
+ *   spawnSync(inv.command, inv.args, inv.options);
+ *
+ * Throws a clear, actionable error when no usable west install is discovered.
+ */
+export function westSpawn(
+  westArgs: string[],
+  baseOptions: SpawnSyncOptions,
+): WestInvocation {
+  const install = discoverWest();
+  if (!install) {
+    throw new Error(
+      [
+        'west (the Zephyr build tool) was not found.',
+        '',
+        'typecad-hal looked for it on PATH, in $ZEPHYR_BASE/.venv, in common',
+        'Zephyr workspace dirs (~/zephyrproject/.venv), and as a system',
+        "Python module (`python -m west`). To fix:",
+        '',
+        '  • Run the typeCAD Zephyr installer (one command, any OS — needs Node ≥18):',
+        '      node packages/zephyr-installer/install.mjs',
+        '    then `micromamba activate zephyr` and retry.',
+        '  • Or activate an existing Zephyr venv in this shell, or',
+        '  • Or set ZEPHYR_BASE to your Zephyr SDK root (the venv at $ZEPHYR_BASE/../.venv is then used), or',
+        '  • Or install west into a discoverable Python: pip install west',
+        '',
+        'See https://docs.zephyrproject.org/latest/develop/getting_started/index.html',
+      ].join('\n'),
+    );
+  }
+
+  const env = buildEnv(install);
+  // Strip `shell` if present — we pass absolute paths / known commands, and
+  // an explicit shell changes arg-quoting semantics on Windows.
+  const { shell: _drop, ...optsWithoutShell } = baseOptions as any;
+
+  if (install.mode === 'micromamba' && install.micromambaExe) {
+    // `micromamba run -n <env> west …` sets up the env's full PATH
+    // (cmake/ninja/dtc) and runs the activation hook (ZEPHYR_BASE /
+    // ZEPHYR_SDK_INSTALL_DIR), so typecad-hal builds work WITHOUT the user
+    // activating the env. Inject MAMBA_ROOT_PREFIX so micromamba finds envs.
+    const mmEnv = { ...env };
+    if (install.mambaRootPrefix) mmEnv.MAMBA_ROOT_PREFIX = install.mambaRootPrefix;
+    return {
+      command: install.micromambaExe,
+      args: ['run', '-n', install.envName ?? 'zephyr', 'west', ...westArgs],
+      options: { ...optsWithoutShell, env: mmEnv },
+      install,
+    };
+  }
+
+  if (install.mode === 'launcher' && install.westExecutable) {
+    return {
+      command: install.westExecutable,
+      args: westArgs,
+      options: { ...optsWithoutShell, env },
+      install,
+    };
+  }
+
+  // module mode: <python> -m west <args>
+  const py = install.pythonExecutable!;
+  return {
+    command: py,
+    args: ['-m', 'west', ...westArgs],
+    options: { ...optsWithoutShell, env },
+    install,
+  };
+}

package/src/west-inventory.ts

@@ -0,0 +1,102 @@
+// ---------------------------------------------------------------------------
+// @typecad/framework-zephyr — shared west workspace ground truth
+//
+// The as-built inventory both `typecad-hal licenses` and `typecad-hal sbom`
+// report from: which west manifest modules the last build ACTUALLY compiled
+// (linked-module filtering via the build's compile_commands.json), plus the
+// build-directory discovery that locates it. A west manifest carries every
+// vendor HAL/library; almost none are linked by a single project — both the
+// license table and the SBOM scope to the linked set by default, so they stay
+// honest about what is actually inside the firmware.
+//
+// Moved out of licenses.ts when the sbom command grew a second consumer; the
+// behavior (case-insensitive, separator-agnostic path matching; degrade to
+// "no filtering" on unparseable build data) is unchanged.
+// ---------------------------------------------------------------------------
+
+import * as path from 'node:path';
+import type { ReadDir, ReadFile } from '@typecad/cuttlefish/api/shared';
+
+/** Normalize a path for case-insensitive, separator-agnostic comparison. */
+export function norm(p: string): string {
+  return p.split('\\').join('/').toLowerCase();
+}
+
+/**
+ * Filter the west manifest to the modules whose sources were compiled in the
+ * last build. A module is "linked" iff some compiled translation unit lives
+ * under its abspath. If the build data is unparseable, no filtering is applied
+ * (degrade to listing all modules rather than reporting nothing).
+ */
+export function filterLinkedModules(
+  ccText: string,
+  modules: { name: string; abspath: string }[],
+): { name: string; abspath: string }[] {
+  let arr: unknown;
+  try {
+    arr = JSON.parse(ccText);
+  } catch {
+    return modules;
+  }
+  if (!Array.isArray(arr)) return modules;
+  // One normalized blob of every compiled source path; membership is then a
+  // substring check per module (O(modules) after an O(TUs) join).
+  const blob = arr
+    .map((e) => norm(typeof (e as { file?: unknown })?.file === 'string' ? (e as { file: string }).file : ''))
+    .join('\n');
+  return modules.filter((m) => blob.includes(norm(m.abspath) + '/'));
+}
+
+/**
+ * Find the build's compile_commands.json path under `cwd`. Cuttlefish's Zephyr
+ * project root is the transpile output dir (e.g. `<cwd>/src/out`), so the
+ * build dir is `<root>/build` — not necessarily `<cwd>/build`. Check the
+ * common layouts, then fall back to a bounded search (skipping
+ * node_modules/.git/dist and dot-directories). Returns the PATH (the caller
+ * decides whether to read it); undefined when no build exists.
+ */
+export function findCompileCommandsPath(
+  readFile: ReadFile,
+  readdir: ReadDir,
+  cwd = process.cwd(),
+): string | undefined {
+  const direct = [
+    path.join(cwd, 'build', 'compile_commands.json'),
+    path.join(cwd, 'out', 'build', 'compile_commands.json'),
+    path.join(cwd, 'src', 'out', 'build', 'compile_commands.json'),
+  ];
+  for (const c of direct) {
+    if (readFile(c)) return c;
+  }
+  // Bounded recursive search for a build/compile_commands.json.
+  const isCc = (p: string) => {
+    const n = norm(p);
+    return n.endsWith('/build/compile_commands.json') || n.endsWith('\\build\\compile_commands.json');
+  };
+  let found: string | undefined;
+  const seen = new Set<string>();
+  const walk = (dir: string, depth: number): void => {
+    if (found || depth > 4 || seen.has(dir)) return;
+    seen.add(dir);
+    let entries: string[];
+    try {
+      entries = readdir(dir);
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      const full = path.join(dir, e);
+      if (e === 'compile_commands.json' && isCc(full)) {
+        found = full;
+        return;
+      }
+    }
+    for (const e of entries) {
+      if (found) return;
+      if (e === 'node_modules' || e === '.git' || e === 'dist' || e.startsWith('.')) continue;
+      walk(path.join(dir, e), depth + 1);
+    }
+  };
+  walk(cwd, 0);
+  return found;
+}

package/dist/async/timer-polyfill.d.ts

@@ -1,10 +0,0 @@
-import type { RuntimePolyfillIR } from '@typecad/cuttlefish/api/shared';
-export interface TimerPolyfillIR extends RuntimePolyfillIR {
-    /** The clamped pool size the C++ was generated with. */
-    maxTimers: number;
-}
-/**
- * Build the timer_methods polyfill IR. `requestedTimers` is sized from
- * ctx.analysis.timerCallCount; it is clamped to [1, 16].
- */
-export declare function buildTimerPolyfill(requestedTimers: number): TimerPolyfillIR;

package/dist/async/timer-polyfill.js

@@ -1,95 +0,0 @@
-// ---------------------------------------------------------------------------
-// Timer methods polyfill — Zephyr k_timer + k_work (heap-free)
-//
-// setInterval / setTimeout / clearInterval / clearTimeout backed by a fixed
-// pool of k_timer + k_work pairs. The timer's expiry function (ISR context)
-// submits a k_work item to the system workqueue; the work handler runs the
-// user callback in thread context. This split keeps the ISR cheap and lets the
-// callback run on a real thread (so it can do real work — but must not block,
-// since the system workqueue is shared).
-//
-// EMIT BOUNDARY: emitted bytes land in user firmware. Covered by the TypeCAD
-// Runtime Exception (RUNTIME_EXCEPTION.md at the repo root).
-// ---------------------------------------------------------------------------
-const MIN_TIMERS = 1;
-const MAX_TIMERS_CAP = 16;
-/**
- * Build the timer_methods polyfill IR. `requestedTimers` is sized from
- * ctx.analysis.timerCallCount; it is clamped to [1, 16].
- */
-export function buildTimerPolyfill(requestedTimers) {
-    const maxTimers = Math.min(MAX_TIMERS_CAP, Math.max(MIN_TIMERS, requestedTimers));
-    const helperStructs = [`
-// cuttlefish timer runtime — k_timer + k_work pool (heap-free).
-struct __tc_TimerSlot {
-    struct k_timer timer;
-    struct k_work work;
-    void (*callback)(void);
-    bool active;
-};
-
-static struct __tc_TimerSlot __tc_timer_slots[${maxTimers}];
-
-static void __tc_timer_work_handler(struct k_work* w) {
-    // Runs on the system workqueue thread (NOT ISR). Find the owning slot by
-    // address and invoke the callback. Must not block.
-    for (int32_t i = 0; i < ${maxTimers}; i++) {
-        if (&__tc_timer_slots[i].work == w) {
-            if (__tc_timer_slots[i].callback != nullptr) { __tc_timer_slots[i].callback(); }
-            return;
-        }
-    }
-}
-
-static void __tc_timer_expiry_fn(struct k_timer* t) {
-    // ISR context: submit the work item, do NOT run the callback here.
-    for (int32_t i = 0; i < ${maxTimers}; i++) {
-        if (&__tc_timer_slots[i].timer == t) {
-            (void)k_work_submit(&__tc_timer_slots[i].work);
-            return;
-        }
-    }
-}
-
-static int32_t __tc_timer_add(void (*cb)(void), int32_t ms, bool repeat) {
-    for (int32_t i = 0; i < ${maxTimers}; i++) {
-        if (!__tc_timer_slots[i].active) {
-            __tc_timer_slots[i].callback = cb;
-            __tc_timer_slots[i].active = true;
-            k_timer_init(&__tc_timer_slots[i].timer, __tc_timer_expiry_fn, nullptr);
-            k_work_init(&__tc_timer_slots[i].work, __tc_timer_work_handler);
-            k_timer_start(&__tc_timer_slots[i].timer, K_MSEC(ms), repeat ? K_MSEC(ms) : K_FOREVER);
-            return i + 1;  // 1-based id
-        }
-    }
-    return 0;  // pool full
-}
-
-static void __tc_timer_clear(int32_t id) {
-    if (id > 0 && id <= ${maxTimers}) {
-        int32_t i = id - 1;
-        k_timer_stop(&__tc_timer_slots[i].timer);
-        __tc_timer_slots[i].active = false;
-        __tc_timer_slots[i].callback = nullptr;
-    }
-}
-`];
-    const helperFunctions = [`
-int32_t __tc_setInterval(void (*cb)(), int32_t ms) { return __tc_timer_add(cb, ms, true); }
-int32_t __tc_setTimeout(void (*cb)(), int32_t ms) { return __tc_timer_add(cb, ms, false); }
-void __tc_clearInterval(int32_t id) { __tc_timer_clear(id); }
-void __tc_clearTimeout(int32_t id) { __tc_timer_clear(id); }
-`];
-    return {
-        kind: 'polyfill',
-        id: 'timer_methods',
-        domain: 'embedded',
-        requiredIncludes: [],
-        forwardDeclarations: [],
-        helperStructs,
-        helperFunctions,
-        shimMacros: [],
-        dependencies: [],
-        maxTimers,
-    };
-}

package/dist/chips/board-overrides.d.ts

@@ -1,7 +0,0 @@
-export interface BoardOverride {
-    /** LED pin name for boards whose user LED is not a gpio-leds node (the
-     *  ESP32-S3 DevKitC's addressable RGB on GPIO48 — driven as plain GPIO,
-     *  same as the deleted board package did). */
-    readonly led?: string;
-}
-export declare const BOARD_OVERRIDES: Readonly<Record<string, BoardOverride>>;