@typecad/cuttlefish 1.0.0-alpha.14 → 1.0.0-alpha.16

package/README.md

@@ -1,79 +1,82 @@
-# `@typecad/cuttlefish`
-
-TypeScript → C++ transpiler for embedded firmware. Targets native (desktop),
-Arduino, and bare-metal MCU builds from a single TypeScript codebase.
-
-`cuttlefish` is the command-line tool at the center of the [TypeCAD](https://cuttlefish.typecad.net)
-toolchain: it loads `cuttlefish.config.ts`, transpiles TypeScript firmware to
-C++, and can chain compile, upload, and serial-monitor steps.
-
-## Quick start
-
-From a project root containing `cuttlefish.config.ts`:
-
-```bash
-npx @typecad/cuttlefish build
-npx @typecad/cuttlefish build --compile --upload --port COM4
-npx @typecad/cuttlefish build --compile --upload --monitor --port COM4 --baud 115200
-```
-
-Scaffold a starter project with the built-in wizard:
-
-```bash
-npx @typecad/cuttlefish create --board arduino:avr:uno --framework arduino
-```
-
-## Commands
-
-| Command | Description |
-| --- | --- |
-| `cuttlefish build` | Transpile the entry file (default). Accepts `--compile`, `--upload`, `--monitor`, `--port`, `--baud`. |
-| `cuttlefish create` | Generate a starter project and `cuttlefish.config.ts`. |
-| `cuttlefish board-add` | Add a new board package via the board-codegen scaffolder. |
-| `cuttlefish preview` | Launch the browser preview server for a UI project. |
-| `cuttlefish map-error <mapFile>` | Map a C++ compiler error back to its TypeScript source location. |
-| `cuttlefish gen-decls` | Generate type declaration stubs. |
-| `cuttlefish gen-libdefs <input.ts>` | Generate library definition stubs for third-party imports. |
-
-### Flags (for `build`)
-
-- `--compile` — transpile, then compile via the active framework's toolchain (`arduino-cli` for Arduino, `g++` for native).
-- `--upload` — flash firmware to the board (implies `--compile`).
-- `--monitor` — open a serial monitor after upload.
-- `--port <port>` — serial port for upload/monitor (e.g. `COM4`, `/dev/ttyUSB0`).
-- `--baud <rate>` — serial monitor baud rate.
-
-## Configuration
-
-The CLI reads `cuttlefish.config.ts` from the current working directory and
-treats it as the source of truth. When no config file is present, command-line
-flags such as `--fqbn` and `--board` supply board and build settings.
-
-```ts
-import type { CuttlefishConfig } from '@typecad/cuttlefish/api';
-
-const config: CuttlefishConfig = {
-  entry: './src/main.ts',
-  target: 'esp32',
-  mcu: '@typecad/mcu-esp32',
-  board: '@typecad/board-esp32-devkit',
-  framework: '@typecad/framework-arduino',
-};
-
-export default config;
-```
-
-## Ecosystem
-
-`@typecad/cuttlefish` is the transpiler core. It pairs with sibling packages:
-
-- [`@typecad/hal`](https://cuttlefish.typecad.net) — hardware abstraction (GPIO, I2C, SPI, UART) as regular TypeScript.
-- [`@typecad/ui`](https://cuttlefish.typecad.net) — HTML/CSS-driven graphics for microcontroller displays.
-- [`@typecad/expect`](https://cuttlefish.typecad.net) — hardware test framework (vitest-style assertions over serial).
-- [`@typecad/framework-arduino`](https://cuttlefish.typecad.net) — Arduino framework code-gen strategy.
-- [`@typecad/framework-native`](https://cuttlefish.typecad.net) — native desktop C++ code-gen strategy.
-- `@typecad/mcu-*` and `@typecad/board-*` — silicon- and board-level pin/peripheral definitions.
-
-## License
-
-MIT
+# `@typecad/cuttlefish`
+
+TypeScript → C++ transpiler for embedded firmware. Targets native (desktop)
+and Zephyr-supported embedded boards from a single TypeScript codebase.
+
+`cuttlefish` is the command-line tool at the center of the [TypeCAD](https://cuttlefish.typecad.net)
+toolchain: it loads `cuttlefish.config.ts`, transpiles TypeScript firmware to
+C++, and can chain compile, upload, and serial-monitor steps.
+
+## Quick start
+
+From a project root containing `cuttlefish.config.ts`:
+
+```bash
+npx @typecad/cuttlefish build
+npx @typecad/cuttlefish build --compile --upload --port COM4
+npx @typecad/cuttlefish build --compile --upload --monitor --port COM4 --baud 115200
+```
+
+Scaffold a starter project with the built-in wizard:
+
+```bash
+npx @typecad/cuttlefish create --board esp32s3
+```
+
+## Commands
+
+| Command | Description |
+| --- | --- |
+| `cuttlefish build` | Transpile the entry file (default). Accepts `--compile`, `--upload`, `--monitor`, `--port`, `--baud`. |
+| `cuttlefish create` | Generate a starter project and `cuttlefish.config.ts`. |
+| `cuttlefish preview` | Launch the browser preview server for a UI project. |
+| `cuttlefish gen-decls <file.h\|file.cpp\|--all <dir>>` | Generate `.d.ts` declaration stubs from C++ headers. |
+| `cuttlefish doctor` | Check the active framework's environment (e.g. toolchain + board support). |
+| `cuttlefish licenses [--all] [--strict]` | Scan this project's libraries for SPDX licenses. |
+| `cuttlefish board sync [zephyr-base]` | Rebuild the local board catalog from your Zephyr tree's board DTS files. The catalog is machine-local — there is no compiled-in board database; builds create and refresh it automatically, this command forces a rebuild. |
+| `cuttlefish board regen` | Regenerate the project-local board module (`.cuttlefish/board.ts` + `board.json`). Builds also regenerate it automatically whenever any input changes (config board, catalog, or Zephyr tree). |
+| `cuttlefish library <search\|install\|init\|validate>` | The cuttlefish library package manager (npm keywords are the catalog). |
+
+### Flags (for `build`)
+
+- `--compile` — transpile, then compile via the active framework's toolchain (`west` for Zephyr, `g++` for native).
+- `--upload` — flash firmware to the board (requires `--compile`).
+- `--monitor` — open a serial monitor after upload.
+- `--port <port>` — serial port for upload/monitor (e.g. `COM4`, `/dev/ttyUSB0`).
+- `--baud <rate>` — serial monitor baud rate.
+
+## Configuration
+
+The CLI reads `cuttlefish.config.ts` from the current working directory and
+treats it as the source of truth. When no config file is present, command-line
+flags such as `--board` and `--build-target` supply board and build settings.
+
+```ts
+import type { CuttlefishConfig } from '@typecad/cuttlefish/api';
+
+const config: CuttlefishConfig = {
+  entry: './src/main.ts',
+  board: 'xiao_ble/nrf52840',
+  framework: '@typecad/framework-zephyr',
+};
+
+export default config;
+```
+
+## Ecosystem
+
+`@typecad/cuttlefish` is the transpiler core. It pairs with sibling packages:
+
+- [`@typecad/hal`](https://cuttlefish.typecad.net) — hardware abstraction (GPIO, I2C, SPI, UART) as regular TypeScript.
+- [`@typecad/ui`](https://cuttlefish.typecad.net) — HTML/CSS-driven graphics for microcontroller displays.
+- [`@typecad/expect`](https://cuttlefish.typecad.net) — hardware test framework (vitest-style assertions over serial).
+- [`@typecad/framework-zephyr`](https://cuttlefish.typecad.net) — Zephyr RTOS framework (build, flashing, and the bundled Zephyr toolchain installer).
+
+Built in, no separate package: the **native** desktop target (`framework:
+'@typecad/framework-native'` resolves inside cuttlefish) and the **safety**
+engine (verified GPIO reads, ISO 26262 analysis — author via
+`@typecad/cuttlefish/safety`).
+
+## License
+
+MIT

package/assets/editor-extensions/typecad-debug/README.md

@@ -57,7 +57,7 @@ Breakpoints are only injected when cuttlefish is run with `--debug`:
 
 ```sh
 cuttlefish build --debug                                    # uses cuttlefish.config.ts entry
-cuttlefish src/index.ts --debug --framework @typecad/framework-arduino --compile --upload --port COM4
+cuttlefish src/index.ts --debug --compile --upload --port COM4
 ```
 
 See `cuttlefish --help` for the full `--debug` description.
@@ -87,17 +87,17 @@ under cuttlefish's basename-matching loader):
 | `logMessage` | string | no | Logpoint with `{variable}` interpolation. When present, the breakpoint logs instead of halting. |
 
 Two source files sharing the same basename in one project will share
-breakpoints — acceptable for typical single-sketch Arduino projects.
+breakpoints — acceptable for typical single-program projects.
 
 ## Native debugging on ESP32-S3
 
 For ESP32-S3, this extension's printf instrumentation is superseded by a
 native GDB path. `cuttlefish build --debug` on `esp32s3` emits `#line`
 directives in the generated C++ and writes `.vscode/launch.json` +
-`tasks.json` (at the git/workspace root, where VS Code reads them) plus
-`openocd.cfg` + `sdkconfig.defaults.debug` next to the build output. Press
-**F5** in VS Code and the generated config attaches GDB to the chip's
-built-in USB-Serial-JTAG — one USB cable, no external probe.
+`tasks.json` (at the cuttlefish project root, where VS Code reads them) plus
+`.cuttlefish/openocd.cfg` next to the build output. Press **F5** in VS Code
+and the generated config attaches GDB to the chip's built-in USB-Serial-JTAG
+— one USB cable, no external probe.
 
 For Zephyr projects (`@typecad/framework-zephyr` on an esp32s3 board),
 `cuttlefish create` writes the same starter artifacts at project creation —
@@ -108,21 +108,22 @@ re-merges the launch entry with the build-cache-resolved gdbPath. (The
 starter gdbPath is probed from `$ZEPHYR_SDK_INSTALL_DIR`, the
 zephyr-installer micromamba layout, or `~/zephyr-sdk-*`.)
 
-`launch.json` ships a single **`gdbtarget`** configuration, provided by the
-ESP-IDF VS Code extension. The extension's gdbtarget adapter manages OpenOCD
-itself (via its OpenOCD Manager, reading `idf.openOcdConfigs` from settings).
-The `preLaunchTask` is just `build + flash` — no competing OpenOCD process.
-Install the ESP-IDF extension (which bundles OpenOCD + the xtensa GDB, and
-requires ESP-IDF itself configured), set the board's serial port in
-`cuttlefish.config.ts` (`console.port`) or pass `--port`. See
-`demos/demo/README.md` for the full F5 flow.
+`launch.json` ships a single **`cortex-debug`** configuration (`servertype:
+"openocd"`, or `"jlink"` when the board's probe method is a JLink runner).
+The cortex-debug extension starts OpenOCD itself as a child process, passing
+the generated `.cuttlefish/openocd.cfg`; the `preLaunchTask` is just
+`build + flash` — no competing OpenOCD process. Install the cortex-debug
+extension (ESP32 targets also need OpenOCD — the framework probes the
+openocd-esp32 install layout or the Zephyr SDK's own openocd), and set the
+serial port through the `CUTTLEFISH_PORT` env var or pass
+`--port`.
 
-The printf instrumentation documented below remains the path for targets that
-don't yet support native debugging (Arduino, other ESP32 variants).
+The printf instrumentation documented below remains the path for targets
+that don't ship a native GDB path yet.
 
 ## Limitations
 
-- This is a `Serial.print`-based instrumentation shim, not a DAP debug
+- This is a printf-based instrumentation shim, not a DAP debug
   adapter. There is no native step/step-in/step-out — each breakpoint halts
   until ENTER (continue) or `s` (skip this breakpoint for the run) is received
   over serial. **On ESP32-S3, use the native GDB path above instead** — it
@@ -131,12 +132,10 @@ don't yet support native debugging (Arduino, other ESP32 variants).
   parameters in the enclosing function. Member access and arbitrary
   expressions are not resolved; `{ value }` in a logpoint emits the literal
   `"{value}"` if `value` is not in scope.
-- Baud rate is hardcoded to `9600` in the injected `Serial.begin` regardless
-  of the CLI `--baud` value.
-- **Target-specific output:** on Arduino/AVR the injected code uses `Serial.*`
-  and blocks on `Serial.available()`. On ESP-IDF (`@typecad/framework-esp32`)
-  it routes through native `printf` and blocks on `getchar()` with the task
-  watchdog fed — so an ESP32 debug build must have `idf.py monitor` (or
-  equivalent) attached, or it will hang at the first breakpoint until power
-  is cycled. This is the ESP-IDF equivalent of "no IDE attached to a
-  breakpoint."
+- Baud rate is fixed by the framework's console shim regardless of the CLI
+  `--baud` value.
+- **Target-specific output:** under @typecad/framework-zephyr the injected
+  code routes through the board console (`printk`/shell backend) and blocks on
+  a getchar-equivalent with the idle thread feeding — so a debug build must
+  have a serial monitor attached (e.g. `cuttlefish build --monitor`), or it
+  will hang at the first breakpoint until power is cycled.

package/dist/api/config.d.ts

@@ -36,6 +36,14 @@ export interface CuttlefishZephyrConfig {
     kconfig?: Record<string, string>;
     /** Extra arguments forwarded to `west build`. */
     cmakeArgs?: string[];
+    /**
+     * Named probe method from the board's supported table (e.g. 'stlink',
+     * 'dfu', 'jlink') — what `--probe` on the CLI also accepts. Serves both
+     * flashing and debugging; resolves to a west runner plus the args the
+     * method needs. The board package is the source of the table. Mutually
+     * exclusive with `runner`.
+     */
+    probe?: string;
     /** Override the west flash runner (e.g. 'nrfjprog', 'jlink', 'openocd'). */
     runner?: string;
     /**
@@ -55,18 +63,22 @@ export interface CuttlefishConfig {
     /** Target architecture identifier (e.g. 'avr', 'esp32', 'rp2040'). */
     target: ArchitectureIdentifier;
     /**
-     * MCU package providing silicon definitions.
-     * Example: '@typecad/mcu-atmega328p'
-     *
-     * Optional for native/host targets — a desktop build has no MCU (the
-     * loader generates a boardless `@typecad/board` shim). Embedded targets
-     * should set this (or the deprecated `board`).
+     * Zephyr board target — the qualified `west build -b` argument (e.g.
+     * 'esp32s3_devkitc/esp32s3/procpu'). The project-local board module
+     * (.cuttlefish/board.ts + board.json) is a derived artifact: every build
+     * regenerates it when any input moves — this field, the local board
+     * catalog, or the Zephyr tree the catalog was generated from. The catalog
+     * itself is always local (`cuttlefish board sync` rebuilds it from your
+     * tree); there is no compiled-in board database.
      */
-    mcu?: string;
+    board?: string;
     /**
-     * Board package to use. (Deprecated — use mcu + contract instead)
+     * Zephyr SoC name for contract-based projects (custom PCBs with no board
+     * target) — e.g. 'stm32f411xe'. Selects the curated soc descriptor whose
+     * pin set the contract narrows against. Required with `contract` on
+     * embedded targets.
      */
-    board?: string;
+    soc?: string;
     /**
      * Path to a TypeCAD contract file (*.contract.json).
      * If provided, the transpiler will generate a narrowed board definition.
@@ -78,7 +90,7 @@ export interface CuttlefishConfig {
     framework?: string;
     /**
      * ESP32 PSRAM type. When set, the framework emits the PSRAM-enabling
-     * Kconfig (Zephyr) / define + FQBN option (Arduino) so large canvas
+     * Kconfig + BOARD_HAS_PSRAM define (Zephyr) so large canvas
      * allocations (scroll viewports, lists) prefer external RAM. No effect
      * on boards without PSRAM.
      */
@@ -101,10 +113,6 @@ export interface CuttlefishConfig {
      * Toolchain configuration for compile/upload operations.
      */
     toolchain?: CuttlefishToolchainConfig;
-    /**
-     * Console output configuration.
-     */
-    console?: CuttlefishConsoleConfig;
     /**
      * Framework-specific configuration.
      */
@@ -131,18 +139,6 @@ interface CuttlefishToolchainConfig {
     /** Framework-specific toolchain options. Each framework reads its own key. */
     frameworkOptions?: Record<string, unknown>;
 }
-/**
- * Console output configuration for the target framework.
- */
-interface CuttlefishConsoleConfig {
-    /** Default baud rate for console output when auto-injected. Default: 9600 */
-    baudRate?: number;
-    /**
-     * Serial port for upload and monitor (e.g. 'COM4', '/dev/ttyACM0').
-     * Can be overridden by the --port CLI flag.
-     */
-    port?: string;
-}
 /**
  * Configuration for the `cuttlefish-test` hardware test runner.
  */

package/dist/api/schema/types.d.ts

@@ -54,8 +54,6 @@ export interface PeripheralFunction {
     instance: number;
     /** Function role (e.g. "sda", "scl", "mosi", "miso"). */
     role: string;
-    /** Timer associated with this PWM function (e.g. "timer0", "timer1"). */
-    timer?: string;
 }
 export interface PinDefinitions {
     /** Offset for analog pin numbers (e.g. A0 = 14 on Uno). */
@@ -93,6 +91,12 @@ export interface PinDefinitions {
     led?: string;
     /** On-board button pin name. */
     button?: string;
+    /**
+     * Additional named board pins (e.g. a PWM-driven onboard LED). Keys should
+     * be snake_case so the flattened `pins.<key>` entry registers the
+     * UPPER_SNAKE identifier in the transpiler's pin alias map.
+     */
+    [key: string]: unknown;
 }
 export interface PeripheralInstance {
     instance: number;
@@ -201,7 +205,7 @@ export interface BuildConfig {
  * Describes the silicon capabilities that are independent of any board.
  */
 export interface MCUDefinition {
-    /** MCU identifier (e.g. "atmega328p"). */
+    /** MCU identifier (e.g. "stm32f411"). */
     id: string;
     /** Human-readable name. */
     name: string;
@@ -217,6 +221,19 @@ export interface MCUDefinition {
     features: FeatureFlags;
     /** MCU-specific build configuration. */
     build: BuildConfig;
+    /**
+     * Silicon-level @typecad/framework-zephyr chip data for this MCU. The lower
+     * layer of the same record boards carry (BoardDefinition.zephyr): SoC
+     * name(s), devicetree includes, GPIO controller split, default console and
+     * clock plan — facts of the chip, not of any PCB. An MCU-only config (no
+     * board package) flattens these into board constants under `zephyr.*` so
+     * framework-zephyr's resolveChipFromBoard() reconstructs its chip descriptor
+     * and the custom-board generator can emit an out-of-tree board for the
+     * chip. Board packages keep board-level Zephyr facts (target name, probe
+     * methods, storage layout, onboard LED/button DT aliases) in their own
+     * zephyr field.
+     */
+    zephyr?: Record<string, unknown>;
 }
 /**
  * Board definition manifest.

package/dist/api/shared/async-runtime-static.d.ts

@@ -6,7 +6,7 @@
  *   Async.sleep / sleepUntil / yield operations.
  * @param waitForPinEdge How `__cuttlefish_wait_pin_edge` (the HAL gpio
  *   waitForRising/waitForFalling lowering target) is implemented:
- *   - "polling" (default): a busy-wait loop using digitalRead/delay/millis +
+ *   - "polling" (default): a busy-wait loop using digitalRead/delay/__tc_now_ms +
  *     the RISING/FALLING/HIGH/LOW symbols. For Arduino-style targets where
  *     those are part of the core API.
  *   - "stub": resolve immediately, emitting NO Arduino symbols in the body.

package/dist/api/shared/async-runtime-static.js

@@ -31,7 +31,7 @@
  *   Async.sleep / sleepUntil / yield operations.
  * @param waitForPinEdge How `__cuttlefish_wait_pin_edge` (the HAL gpio
  *   waitForRising/waitForFalling lowering target) is implemented:
- *   - "polling" (default): a busy-wait loop using digitalRead/delay/millis +
+ *   - "polling" (default): a busy-wait loop using digitalRead/delay/__tc_now_ms +
  *     the RISING/FALLING/HIGH/LOW symbols. For Arduino-style targets where
  *     those are part of the core API.
  *   - "stub": resolve immediately, emitting NO Arduino symbols in the body.
@@ -42,10 +42,10 @@
  *   - "interrupt": omit entirely — the strategy/ISR layer provides the symbol.
  */
 export function generateStaticAsyncRuntime(capacity, waitForPinEdge = "polling", strategy) {
-    // The current-time expression (millis() on Wiring-derived frameworks,
-    // std::chrono on generic). Falling back to millis() preserves the historical
+    // The current-time expression (__tc_now_ms() — the runtime clock contract
+    // every strategy provides). Falling back to the contract symbol keeps the
     // behavior when no strategy is supplied.
-    const now = strategy?.currentTimeMillis?.() ?? "millis()";
+    const now = strategy?.currentTimeMillis?.() ?? "__tc_now_ms()";
     return `
 // TypeCAD static (heap-free) async runtime — for targets without <vector>.
 namespace typecad_async_static {
@@ -199,7 +199,7 @@ ${waitPinEdgeForMode(waitForPinEdge, strategy, now)}
 `;
 }
 /** Emit `__cuttlefish_wait_pin_edge` per the strategy's waitForPinEdge mode. */
-function waitPinEdgeForMode(mode, strategy, now = "millis()") {
+function waitPinEdgeForMode(mode, strategy, now = "__tc_now_ms()") {
     if (mode === "interrupt") {
         // The strategy/ISR layer provides the symbol; emit nothing here.
         return "// __cuttlefish_wait_pin_edge is provided by the strategy (interrupt mode).";

package/dist/api/shared/async-types.d.ts

@@ -30,8 +30,9 @@ export interface AsyncRuntimeConfig {
      */
     hasPromiseRuntime: boolean;
     /**
-     * Whether the platform supports timer-based setTimeout/setInterval
-     * (as opposed to cooperative polling).
+     * Whether the platform provides native timer callbacks for async sleeps
+     * (as opposed to cooperative polling). Zephyr sets this false: periodic
+     * work is a Thread (k_thread) or a Counter, never a timer queue.
      */
     hasTimers: boolean;
     /**

package/dist/api/shared/board-catalog.d.ts

@@ -0,0 +1,2 @@
+export { BOARD_DATA } from '../../create/board-catalog.generated.js';
+export type { BoardDataEntry } from '../../create/board-catalog.generated.js';

package/dist/api/shared/board-catalog.js

@@ -0,0 +1,6 @@
+// Public surface for the generated Zephyr board catalog. The pack itself is
+// generated by scripts/gen-zephyr-board-data.mjs against the pinned Zephyr
+// tree and lives at src/create/board-catalog.generated.ts (shared with the
+// create/scaffold flow). The framework's board generator (boardgen) joins
+// this catalog with its curated soc descriptors.
+export { BOARD_DATA } from '../../create/board-catalog.generated.js';

package/dist/api/shared/board-resolver.d.ts

@@ -1,12 +1,9 @@
 /**
  * Flat map from dot-path key to scalar constant value.
  *
- * Examples (for Arduino Uno):
- *   "id"           → "arduino-uno"
- *   "mcu"          → "ATmega328P"
- *   "clockSpeed"   → 16000000
- *   "memory.flash" → 32768
- *   "memory.sram"  → 2048
- *   "memory.eeprom"→ 1024
+ * Examples (from a generated board.json manifest):
+ *   "name"         → "XIAO BLE"
+ *   "pins.led"     → 13
+ *   "pins.analogOffset" → 14
  */
 export type BoardConstants = Map<string, string | number | boolean>;

package/dist/api/shared/board-resolver.js

@@ -2,6 +2,7 @@
 // Board constant types
 //
 // Types for compile-time constant extraction from board definitions.
-// The implementation (which uses TypeScript compiler API) remains in CLI.
+// The implementation lives in the CLI (ir/board-resolver.ts) and reads the
+// project-local generated board.json manifest.
 // ---------------------------------------------------------------------------
 export {};

package/dist/api/shared/coop-scheduler.d.ts

@@ -21,7 +21,7 @@ export interface CoopSchedOptions {
     timeBudgetMs?: number;
     /**
      * C++ expression yielding the current monotonic time in ms, used for the
-     * budget check (e.g. `millis()`, `k_uptime_get_32()`). Required only when
+     * budget check (`__tc_now_ms()`). Required only when
      * enableTimeBudget is true.
      */
     currentTimeExpr?: string;

package/dist/api/shared/coop-scheduler.js

@@ -31,7 +31,7 @@ export function generateCoopScheduler(options = {}) {
     const priorities = options.priorities ?? 2;
     const enableTimeBudget = options.enableTimeBudget ?? false;
     const timeBudgetMs = options.timeBudgetMs ?? 5;
-    const currentTimeExpr = options.currentTimeExpr ?? "millis()";
+    const currentTimeExpr = options.currentTimeExpr ?? "__tc_now_ms()";
     // Budget check snippet, only included when time-budgeting is enabled.
     const budgetCheck = enableTimeBudget
         ? `      if ((${currentTimeExpr} - _start) >= static_cast<uint32_t>(${timeBudgetMs})) { break; }`

package/dist/api/shared/cpp-type-ir.d.ts

@@ -219,7 +219,7 @@ export declare function parsedIsPlainStructType(cppType: string): boolean;
 /**
  * True for types that own a string buffer and therefore need `.c_str()` when
  * passed to a C variadic (printf/snprintf): `std::string`, `__tc_str_ptr`,
- * and platform string types like Arduino `String`. NOT true for `const char*`
+ * and platform string types like `String`. NOT true for `const char*`
  * / `char*`, which are already C-strings.
  *
  * This is the structured replacement for the

package/dist/api/shared/cpp-type-ir.js

@@ -648,7 +648,7 @@ export function parsedIsPlainStructType(cppType) {
 /**
  * True for types that own a string buffer and therefore need `.c_str()` when
  * passed to a C variadic (printf/snprintf): `std::string`, `__tc_str_ptr`,
- * and platform string types like Arduino `String`. NOT true for `const char*`
+ * and platform string types like `String`. NOT true for `const char*`
  * / `char*`, which are already C-strings.
  *
  * This is the structured replacement for the

package/dist/api/shared/display-profile.d.ts

@@ -121,7 +121,7 @@ export interface ResolvedDisplay extends DisplayProfile {
     _mountBus: string;
     _mountAddress: number;
     _mountReset: number;
-    /** Framework build target string (e.g. an Arduino FQBN like
+    /** Framework build target string (e.g. a Zephyr board target like
      *  "esp32:esp32:esp32s3:PSRAM=opi" or an IDF target). Carried through for
      *  framework-side toolchain/compile use; cuttlefish itself does not parse it.
      *  Optional. */

package/dist/api/shared/display-profile.js

@@ -200,9 +200,7 @@ export function generateTouchAdapter(touch, strategy) {
         };
     }
     throw new Error(`No touch adapter for library "${touch.library}". ` +
-        `The built-in Arduino touch libraries (XPT2046_Touchscreen, Adafruit_TouchScreen, ` +
-        `Adafruit_STMPE610, FT6336U) are provided by @typecad/framework-arduino — pass the ` +
-        `ArduinoStrategy (or another framework strategy that provides touch adapters) so its ` +
-        `resolveTouchAdapter can dispatch to them. Otherwise use the framework-agnostic ` +
-        `"sdl" library, or { adapter: './path' } for a custom touch adapter.`);
+        `Pass a framework strategy whose resolveTouchAdapter dispatches to that driver, ` +
+        `use the framework-agnostic "sdl" library, or pass { adapter: './path' } for a ` +
+        `custom touch adapter.`);
 }

package/dist/api/shared/framework-manifest-registry.d.ts

@@ -1,5 +1,5 @@
 import type { FrameworkManifest } from './framework-manifest.js';
-export declare const KNOWN_FRAMEWORK_PACKAGES: readonly ["@typecad/framework-arduino", "@typecad/framework-zephyr"];
+export declare const KNOWN_FRAMEWORK_PACKAGES: readonly ["@typecad/framework-zephyr"];
 export type KnownFrameworkPackage = typeof KNOWN_FRAMEWORK_PACKAGES[number];
 /**
  * Loads a framework's manifest via its `./framework.manifest` subpath export.

package/dist/api/shared/framework-manifest-registry.js

@@ -10,7 +10,6 @@
 // framework declares in its package.json.
 // ---------------------------------------------------------------------------
 export const KNOWN_FRAMEWORK_PACKAGES = [
-    '@typecad/framework-arduino',
     '@typecad/framework-zephyr',
 ];
 /**

package/dist/api/shared/framework-manifest.d.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-declare const HAL_CATEGORIES: readonly ["gpio", "pwm", "adc", "dac", "interrupts", "tone", "timing", "power", "i2c", "spi", "uart", "pulse", "shift", "board", "wdt", "wifi", "http", "mqtt", "display"];
+declare const HAL_CATEGORIES: readonly ["gpio", "pwm", "adc", "dac", "interrupts", "timing", "i2c", "spi", "uart", "board", "wdt", "wifi", "http", "mqtt", "display"];
 export type HalCategory = typeof HAL_CATEGORIES[number];
 export declare const FrameworkManifestSchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
@@ -19,9 +19,9 @@ export declare const FrameworkManifestSchema: z.ZodObject<{
         entrypointFunctionName: z.ZodString;
         requiresLoopFunction: z.ZodBoolean;
         sourceExtension: z.ZodEnum<{
-            cpp: "cpp";
             ino: "ino";
             cc: "cc";
+            cpp: "cpp";
             h: "h";
         }>;
         overrideBaseName: z.ZodOptional<z.ZodString>;
@@ -40,10 +40,10 @@ export declare const FrameworkManifestSchema: z.ZodObject<{
             unsupportedReason: z.ZodOptional<z.ZodString>;
             ops: z.ZodRecord<z.ZodString, z.ZodEnum<{
                 stub: "stub";
-                polyfill: "polyfill";
                 supported: "supported";
                 unsupported: "unsupported";
                 "probe-inconclusive": "probe-inconclusive";
+                polyfill: "polyfill";
             }>>;
             partialCoverage: z.ZodDefault<z.ZodBoolean>;
         }, z.core.$strip>;
@@ -55,10 +55,10 @@ export declare const FrameworkManifestSchema: z.ZodObject<{
         unsupportedReason: z.ZodOptional<z.ZodString>;
         ops: z.ZodRecord<z.ZodString, z.ZodEnum<{
             stub: "stub";
-            polyfill: "polyfill";
             supported: "supported";
             unsupported: "unsupported";
             "probe-inconclusive": "probe-inconclusive";
+            polyfill: "polyfill";
         }>>;
         partialCoverage: z.ZodDefault<z.ZodBoolean>;
     }, z.core.$strip>>>;
@@ -97,6 +97,7 @@ export declare const FrameworkManifestSchema: z.ZodObject<{
             none: "none";
             "<math.h>": "<math.h>";
             "<Arduino.h>": "<Arduino.h>";
+            "<cmath>": "<cmath>";
         }>;
         needsStdString: z.ZodBoolean;
         needsStdVector: z.ZodBoolean;
@@ -140,8 +141,8 @@ export type FrameworkManifest = z.infer<typeof FrameworkManifestSchema>;
  * polyfill id that backs it.
  *
  * The manifest validator uses this to verify `polyfill`-declared ops: if a
- * manifest declares `timing.set_interval: 'polyfill'`, the framework's
- * `polyfills.emitted` list must include the polyfill id named here.
+ * manifest declares an op as `polyfill`, the framework's `polyfills.emitted`
+ * list must include the polyfill id named here.
  *
  * Keep in sync with the transpiler's lowering routes — when a new op kind
  * starts being routed via a polyfill instead of the HAL resolver, add it