@typecad/framework-zephyr 1.0.0-alpha.13 → 1.0.0-alpha.15

package/src/lowering/spi.ts

@@ -1,124 +1,164 @@
-// ---------------------------------------------------------------------------
-// SPI lowering — spi_transceive_dt against a spi_dt_spec; CS as GPIO
-//
-// Zephyr's `spi_transceive_dt(&spec, tx, rx)` is stateless per-call, so there
-// is no pending-tx-buffer (unlike I2C). The CS pin is driven as a plain GPIO
-// (like ESP32), since the DT spec's CS handling is configured at compile time
-// but the HAL's explicit cs_low/cs_high ops want manual control.
-//
-// The board's SPI node (spi2 on the XIAO) has no pre-declared client device
-// node, so the lowering cannot use SPI_DT_SPEC_GET (which needs a client node).
-// Instead we build a `struct spi_config` at runtime against
-// DEVICE_DT_GET(DT_NODELABEL(spi2)) and call spi_transceive directly.
-// ---------------------------------------------------------------------------
-
-import type { HALOpIR } from '@typecad/cuttlefish/api/shared';
-import type { ZephyrChipDescriptor } from '../chips/types.js';
-import { parseControllerIndex } from './util.js';
-import { controllerNodelabelForPin } from '../chips/controllers.js';
-
-/** The C variable prefix for a controller's state. */
-function prefix(idx: number): string {
-  return `__tc_spi${idx}`;
-}
-
-/**
- * Emit the per-controller SPI state. The bus device resolves at compile time;
- * a static spi_config holds the base operation flags, and mutable runtime fields
- * hold the mode (CPOL/CPHA bits) + bit order (lsb) so set_mode/set_bit_order can
- * rebuild operation at init time (Zephyr's spi_config.operation is the only knob).
- */
-export function spiInitLines(chip: ZephyrChipDescriptor, controllerIndex: number): string[] {
-  const ctrl = chip.spi?.controllers[controllerIndex];
-  if (!ctrl) return [];
-  const p = prefix(controllerIndex);
-  return [
-    '// CUTTLEFISH_SPI_BEGIN',
-    `static const struct device* ${p}_dev = DEVICE_DT_GET(DT_NODELABEL(${ctrl.nodeLabel}));`,
-    `static bool ${p}_ready = false;`,
-    `static uint8_t ${p}_mode = 0;   // bit0=CPOL, bit1=CPHA`,
-    `static bool ${p}_lsb = false;   // false=MSB (default), true=LSB`,
-    `static struct spi_config ${p}_cfg = {`,
-    `    .frequency = 1000000,`,
-    `};`,
-    `static void ${p}_init(void) {`,
-    `    if (!${p}_ready) {`,
-    `        ${p}_cfg.bus = ${p}_dev;`,
-    `        ${p}_cfg.operation = SPI_OP_MODE_MASTER | SPI_WORD_SET(8)`,
-    `            | (${p}_lsb ? SPI_TRANSFER_LSB : SPI_TRANSFER_MSB)`,
-    `            | ((${p}_mode & 0x1) ? SPI_MODE_CPOL : 0)`,
-    `            | ((${p}_mode & 0x2) ? SPI_MODE_CPHA : 0);`,
-    `        ${p}_ready = true;`,
-    `    }`,
-    `}`,
-    '// CUTTLEFISH_SPI_END',
-  ];
-}
-
-/**
- * Resolve a HAL spi.* op to Zephyr C++.
- * Returns `{ code }` for statement ops, `{ expression }` for value-returning ops.
- */
-export function lowerSpi(
-  op: HALOpIR,
-  chip: ZephyrChipDescriptor,
-): { code?: string; expression?: string } {
-  const o = op as any;
-  const idx = parseControllerIndex(o.bus);
-  const p = prefix(idx);
-
-  switch (op.operation) {
-    case 'spi.begin':
-      return { code: `${p}_init();` };
-    case 'spi.end':
-      return { code: `spi_release(${p}_dev, &${p}_cfg);` };
-    case 'spi.begin_transaction':
-      // Config is static; transaction begin is a no-op (frequency/mode baked in).
-      return { code: `${p}_init();` };
-    case 'spi.end_transaction':
-      return { code: `(void)0;` };
-    case 'spi.set_mode':
-      // Apply CPOL/CPHA: store the mode byte then re-init so the next transfer
-      // picks up the rebuilt operation flags. The ready flag is cleared so
-      // _init() rebuilds rather than early-returning.
-      return { code: `{ ${p}_mode = static_cast<uint8_t>(${o.mode}); ${p}_ready = false; ${p}_init(); }` };
-    case 'spi.set_bit_order': {
-      // The HAL payload `order` is a string ("lsb" | "msb"), per SpiSetBitOrderOp.
-      // Normalize here in TS so we emit a boolean literal, not the raw string
-      // (which would be an undeclared C++ identifier).
-      const key = String(o.order).replace(/^["']|["']$/g, '').toLowerCase();
-      const lsb = (key === 'lsb' || key === 'lsbfirst') ? 'true' : 'false';
-      return { code: `{ ${p}_lsb = ${lsb}; ${p}_ready = false; ${p}_init(); }` };
-    }
-    case 'spi.transfer': {
-      // Single-byte full-duplex, returns the received byte (GCC stmt-expr).
-      return {
-        expression: `({ uint8_t __tx = static_cast<uint8_t>(${o.data}); uint8_t __rx = 0; struct spi_buf __tb = { .buf = &__tx, .len = 1 }; struct spi_buf_set __tbs = { .buffers = &__tb, .count = 1 }; struct spi_buf __rb = { .buf = &__rx, .len = 1 }; struct spi_buf_set __rbs = { .buffers = &__rb, .count = 1 }; ${p}_init(); spi_transceive(${p}_dev, &${p}_cfg, &__tbs, &__rbs); __rx; })`,
-      };
-    }
-    case 'spi.read_buffer': {
-      // Read count bytes by sending 0xFF dummy bytes (full-duplex read).
-      const count = o.count;
-      return {
-        code: `{ uint8_t __dummy[${count}] = {0}; for (int __i = 0; __i < (int)(${count}); __i++) __dummy[__i] = 0xFF; struct spi_buf __tb = { .buf = __dummy, .len = ${count} }; struct spi_buf_set __tbs = { .buffers = &__tb, .count = 1 }; struct spi_buf __rb = { .buf = reinterpret_cast<void*>(${o.buffer}), .len = ${count} }; struct spi_buf_set __rbs = { .buffers = &__rb, .count = 1 }; ${p}_init(); spi_transceive(${p}_dev, &${p}_cfg, &__tbs, &__rbs); }`,
-      };
-    }
-    case 'spi.cs_low':
-    case 'spi.cs_high': {
-      // CS driven as a plain GPIO via the owning controller (the CS pin comes
-      // from the op's `pin` field; Zephyr uses gpio_pin_set_raw). Resolve the
-      // controller by pin so a CS on a high-numbered pin (ESP32-S3 gpio1) lands
-      // on the right node.
-      const val = op.operation === 'spi.cs_low' ? 0 : 1;
-      const gpioController = controllerNodelabelForPin(chip, o.pin);
-      return {
-        code: `gpio_pin_set_raw(DEVICE_DT_GET(DT_NODELABEL(${gpioController})), ${o.pin}, ${val});`,
-      };
-    }
-    default:
-      throw new Error(
-        `framework-zephyr does not yet support HAL op \`${op.operation}\`. ` +
-          `Open an issue or use rawCpp() to emit it manually.`,
-      );
-  }
-}
+// ---------------------------------------------------------------------------
+// SPI lowering — spi_transceive_dt against a spi_dt_spec; CS as GPIO
+//
+// Zephyr's `spi_transceive_dt(&spec, tx, rx)` is stateless per-call, so there
+// is no pending-tx-buffer (unlike I2C). The CS pin is driven as a plain GPIO
+// (like ESP32), since the DT spec's CS handling is configured at compile time
+// but the HAL's explicit cs_low/cs_high ops want manual control.
+//
+// The board's SPI node (spi2 on the XIAO) has no pre-declared client device
+// node, so the lowering cannot use SPI_DT_SPEC_GET (which needs a client node).
+// Instead we build a `struct spi_config` at runtime against
+// DEVICE_DT_GET(DT_NODELABEL(spi2)) and call spi_transceive directly.
+// ---------------------------------------------------------------------------
+
+import type { HALOpIR } from '@typecad/cuttlefish/api/shared';
+import type { ZephyrChipDescriptor } from '../chips/types.js';
+import { parseControllerIndex } from './util.js';
+
+/** The C variable prefix for a controller's state. */
+function prefix(idx: number): string {
+  return `__tc_spi${idx}`;
+}
+
+// ── Thin SPI device names — the shared-facts discipline ────────────────────
+//
+// The DT nodelabel (tc_spit_spi<N>_cs<cs>), the shim's spi_dt_spec var, and
+// the overlay scanner's regex all derive from bus index + cs pin here.
+
+export interface SpiTargetNames {
+  dtLabel: string;
+  varName: string;
+  busIndex: number;
+  cs: number;
+}
+
+/** Derive a thin SPI target's names from the op facts. */
+export function spiTargetNames(bus: string, cs: number | string): SpiTargetNames {
+  const busIndex = parseControllerIndex(typeof bus === 'string' ? bus : String(bus));
+  const csNum = typeof cs === 'number' ? cs : parseInt(String(cs), 10);
+  const stem = `spit_spi${busIndex}_cs${csNum}`;
+  return { dtLabel: `tc_${stem}`, varName: `__tc_${stem}_spec`, busIndex, cs: csNum };
+}
+
+/** The per-target state block: one spi_dt_spec against the DT child node the
+ *  overlay emits, plus the tc-spit-cfg comment the overlay scanner reads (the
+ *  tc-sensor-cfg channel). Called from shimLines for each distinct target. */
+export function spiTargetStateLines(bus: string, cs: number | string, hz: number | string = 0, mode: number | string = 0): string[] {
+  const n = spiTargetNames(bus, cs);
+  return [
+    '// CUTTLEFISH_SPIT_BEGIN',
+    // Zephyr 4.4's SPI_DT_SPEC_GET takes the base operation explicitly (mode
+    // bits come from the DT node's spi-cpol/spi-cpha via SPI_CONFIG_DT).
+    `static const struct spi_dt_spec ${n.varName} = SPI_DT_SPEC_GET(DT_NODELABEL(${n.dtLabel}), SPI_OP_MODE_MASTER | SPI_WORD_SET(8), 0);`,
+    `// tc-spit-cfg: ${n.dtLabel} hz=${Number(hz)} mode=${Number(mode)}`,
+    '// CUTTLEFISH_SPIT_END',
+  ];
+}
+
+/** Build the tx buffer declaration + set for a thin SPI op. A literal byte
+ *  array becomes a local array; a single identifier is the user's own buffer
+ *  (its storage + sizeof drive length). spi_buf.buf is void*, and the user's
+ *  buffer may be const-qualified — cast through const void* to stay legal
+ *  under -Werror without mutating anyone's qualifications. */
+function spiTxBuffers(tx: unknown, tag: string): { decl: string; set: string } {
+  const bytes = (Array.isArray(tx) ? tx : []) as unknown[];
+  // Only an identifier-shaped string is a real caller buffer — the resolver
+  // collapses a single-byte literal array to buffer-kind with NUMERIC text
+  // (e.g. "159"), which must take the literal path below.
+  const isIdentifier = bytes.length === 1 && typeof bytes[0] === 'string' && /^[A-Za-z_][A-Za-z0-9_]*$/.test(bytes[0] as string);
+  if (isIdentifier) {
+    const name = bytes[0] as string;
+    return {
+      decl: `const struct spi_buf __tb${tag} = { .buf = const_cast<void*>(static_cast<const void*>(${name})), .len = sizeof(${name}) }; const struct spi_buf_set __txs${tag} = { .buffers = &__tb${tag}, .count = 1 };`,
+      set: `__txs${tag}`,
+    };
+  }
+  return {
+    decl: `uint8_t __tx${tag}[] = { ${bytes.join(', ')} }; const struct spi_buf __tb${tag} = { .buf = __tx${tag}, .len = sizeof(__tx${tag}) }; const struct spi_buf_set __txs${tag} = { .buffers = &__tb${tag}, .count = 1 };`,
+    set: `__txs${tag}`,
+  };
+}
+
+/**
+ * Emit the per-controller SPI state. The bus device resolves at compile time;
+ * a static spi_config holds the base operation flags, and mutable runtime fields
+ * hold the mode (CPOL/CPHA bits) + bit order (lsb) so set_mode/set_bit_order can
+ * rebuild operation at init time (Zephyr's spi_config.operation is the only knob).
+ */
+export function spiInitLines(chip: ZephyrChipDescriptor, controllerIndex: number): string[] {
+  const ctrl = chip.spi?.controllers[controllerIndex];
+  if (!ctrl) return [];
+  const p = prefix(controllerIndex);
+  return [
+    '// CUTTLEFISH_SPI_BEGIN',
+    `static const struct device* ${p}_dev = DEVICE_DT_GET(DT_NODELABEL(${ctrl.nodeLabel}));`,
+    `static bool ${p}_ready = false;`,
+    `static uint8_t ${p}_mode = 0;   // bit0=CPOL, bit1=CPHA`,
+    `static bool ${p}_lsb = false;   // false=MSB (default), true=LSB`,
+    `static struct spi_config ${p}_cfg = {`,
+    `    .frequency = 1000000,`,
+    `};`,
+    `static void ${p}_init(void) {`,
+    `    if (!${p}_ready) {`,
+    // NOTE: no .bus assignment — struct spi_config lost its `bus` member in
+    // Zephyr 4.x (deprecated 3.5, removed 4.0); spi_transceive takes the
+    // device alongside the config, which the ops below already do.
+    `        ${p}_cfg.operation = SPI_OP_MODE_MASTER | SPI_WORD_SET(8)`,
+    `            | (${p}_lsb ? SPI_TRANSFER_LSB : SPI_TRANSFER_MSB)`,
+    `            | ((${p}_mode & 0x1) ? SPI_MODE_CPOL : 0)`,
+    `            | ((${p}_mode & 0x2) ? SPI_MODE_CPHA : 0);`,
+    `        ${p}_ready = true;`,
+    `    }`,
+    `}`,
+    '// CUTTLEFISH_SPI_END',
+  ];
+}
+
+/**
+ * Resolve a HAL spi.* op to Zephyr C++.
+ * Returns `{ code }` for statement ops, `{ expression }` for value-returning ops.
+ */
+export function lowerSpi(
+  op: HALOpIR,
+  chip: ZephyrChipDescriptor,
+): { code?: string; expression?: string } {
+  const o = op as any;
+  const idx = parseControllerIndex(o.bus);
+  const p = prefix(idx);
+
+  switch (op.operation) {
+    case 'spi.transceive': {
+      const v = spiTargetNames(o.bus, o.cs).varName;
+      const tx = spiTxBuffers(o.tx, 't');
+      const rxName = String(o.rx ?? '');
+      const rx = rxName
+        ? `struct spi_buf __rb = { .buf = const_cast<void*>(static_cast<const void*>(${rxName})), .len = sizeof(${rxName}) }; const struct spi_buf_set __rbs = { .buffers = &__rb, .count = 1 };`
+        : `const struct spi_buf_set __rbs = { .buffers = NULL, .count = 0 };`;
+      return {
+        code: `{ ${tx.decl} ${rx} (void)spi_transceive_dt(&${v}, &${tx.set}, &__rbs); }`,
+      };
+    }
+    case 'spi.dev_write': {
+      const v = spiTargetNames(o.bus, o.cs).varName;
+      const tx = spiTxBuffers(o.tx, 'w');
+      return {
+        code: `{ ${tx.decl} (void)spi_write_dt(&${v}, &${tx.set}); }`,
+      };
+    }
+    case 'spi.reg_read': {
+      // One-byte register read against an INTERNAL buffer — no caller array
+      // (sidesteps the file-scope Uint8Array promotion issue; also just the
+      // right shape for ID/status registers).
+      const v = spiTargetNames(o.bus, o.cs).varName;
+      return {
+        expression: `({ uint8_t __txr = static_cast<uint8_t>(${o.reg}); uint8_t __rxr = 0; struct spi_buf __tbr = { .buf = &__txr, .len = 1 }; const struct spi_buf_set __txsr = { .buffers = &__tbr, .count = 1 }; struct spi_buf __rbr = { .buf = &__rxr, .len = 1 }; const struct spi_buf_set __rxsr = { .buffers = &__rbr, .count = 1 }; (void)spi_transceive_dt(&${v}, &__txsr, &__rxsr); __rxr; })`,
+      };
+    }
+    default:
+      throw new Error(
+        `framework-zephyr does not yet support HAL op \`${op.operation}\`. ` +
+          `Open an issue or use rawCpp() to emit it manually.`,
+      );
+  }
+}

package/src/lowering/thread.ts

@@ -0,0 +1,63 @@
+// ---------------------------------------------------------------------------
+// Thread lowering — Zephyr kernel threads (k_thread_create / k_thread_join)
+//
+// One state block per thread identity slot the program STARTS: a static
+// K_THREAD_STACK_DEFINE (sized by the construction stackKb), the k_thread
+// struct, and an entry trampoline bridging Zephyr's (void*, void*, void*)
+// entry signature to the no-argument registered callback. start() creates
+// and schedules (K_NO_WAIT); join() blocks (K_FOREVER).
+//
+// No devicetree, no Kconfig — kernel.h (always included) is the whole
+// dependency. State emission is keyed on thread.start ops only, so a
+// join-only program emits nothing (and its join guards on the same slot).
+// ---------------------------------------------------------------------------
+
+import type { HALOpIR } from '@typecad/cuttlefish/api/shared';
+
+/** Per-instance symbol stem. */
+function stem(instance: number): string {
+  return `__tc_thrd${instance}`;
+}
+
+/**
+ * Emit the per-thread state. Called from shimLines for each distinct thread
+ * the program starts.
+ */
+export function threadStateLines(instance: number, stackBytes: number): string[] {
+  const p = stem(instance);
+  return [
+    '// CUTTLEFISH_THREAD_BEGIN',
+    `K_THREAD_STACK_DEFINE(${p}_stack, ${stackBytes});`,
+    `static struct k_thread ${p}_thread;`,
+    `static void (*${p}_fn)(void) = NULL;`,
+    `static void ${p}_tramp(void* a, void* b, void* c) { (void)a; (void)b; (void)c; if (${p}_fn) { ${p}_fn(); } }`,
+    '// CUTTLEFISH_THREAD_END',
+  ];
+}
+
+/**
+ * Resolve a HAL thread.* op to Zephyr C++.
+ * Returns `{ code }` for statement ops.
+ */
+export function lowerThread(op: HALOpIR): { code?: string; expression?: string } {
+  const o = op as any;
+  const instance = typeof o.instance === 'number' ? o.instance : 0;
+  const p = stem(instance);
+
+  switch (op.operation) {
+    case 'thread.start': {
+      // Store the entry, create + schedule immediately. The stack size comes
+      // from the state block (the construction fact), via K_THREAD_STACK_SIZEOF.
+      return {
+        code: `${p}_fn = (${o.handler}); (void)k_thread_create(&${p}_thread, ${p}_stack, K_THREAD_STACK_SIZEOF(${p}_stack), ${p}_tramp, NULL, NULL, NULL, ${o.priority ?? 5}, 0, K_NO_WAIT);`,
+      };
+    }
+    case 'thread.join':
+      return { code: `(void)k_thread_join(&${p}_thread, K_FOREVER);` };
+    default:
+      throw new Error(
+        `framework-zephyr does not yet support HAL op \`${op.operation}\`. ` +
+          `Open an issue or use rawCpp() to emit it manually.`,
+      );
+  }
+}

package/src/lowering/timing.ts

@@ -1,72 +1,46 @@
-// ---------------------------------------------------------------------------
-// Timing lowering — Zephyr kernel timing
-//
-// delay/millis/delay_microseconds/micros/free_heap lower directly. The four
-// timer ops (set_interval/set_timeout/clear_interval/clear_timeout) call the
-// timer_methods polyfill helpers (k_timer + k_work pool), declared as 'polyfill'
-// status in the manifest — the validator skips the resolver probe for these
-// (they legitimately return polyfill-helper calls, not direct lowering).
-// free_heap has no portable Zephyr query without CONFIG_SYS_HEAP_RUNTIME_STATS;
-// it returns 0 with a comment (honest limitation).
-// ---------------------------------------------------------------------------
-
-import type { HALOpIR } from '@typecad/cuttlefish/api/shared';
-
-/**
- * Resolve a HAL timing.* op to Zephyr C++.
- * Returns `{ code }` for statement ops, `{ expression }` for value-returning ops.
- */
-export function lowerTiming(
-  op: HALOpIR,
-): { code?: string; expression?: string } {
-  const o = op as any;
-
-  switch (op.operation) {
-    case 'timing.delay': {
-      // Milliseconds — k_msleep is the blocking Zephyr call. Because
-      // isRtosTarget() returns true, the transpiler does not warn about
-      // blocking delays inside loop().
-      const ms = o.ms;
-      return { code: `k_msleep(${ms});` };
-    }
-    case 'timing.delay_microseconds': {
-      // k_busy_wait spins (does not yield); for cooperative μs delays.
-      return { code: `k_busy_wait(${o.us});` };
-    }
-    case 'timing.millis':
-      // k_uptime_get_32() returns int64_t milliseconds since boot. Cast to the
-      // Arduino-millis() return type (uint32_t) so overflow wraps identically.
-      return { expression: 'static_cast<uint32_t>(k_uptime_get_32())' };
-    case 'timing.micros': {
-      // Convert hardware cycles to microseconds. k_cycle_get_32 + the cycles/sec
-      // macro (note: sys_clock_hw_cycles_per_sec is a MACRO — needs parens).
-      return {
-        expression: '(uint32_t)(((uint64_t)k_cycle_get_32() * 1000000ULL) / sys_clock_hw_cycles_per_sec())',
-      };
-    }
-    case 'timing.free_heap':
-      // No portable free-heap query without CONFIG_SYS_HEAP_RUNTIME_STATS.
-      // Return 0 with a comment so callers don't get a link error.
-      return { expression: '(0 /* free_heap: enable CONFIG_SYS_HEAP_RUNTIME_STATS for real value */)' };
-    case 'timing.set_interval':
-      // Backed by the timer_methods polyfill (k_timer + k_work). The handler is
-      // the resolved C++ callback name; timeout is the repeat period (ms).
-      // NOTE: these ops are declared 'polyfill' in the manifest, so setInterval
-      // is rewritten to __tc_setInterval before reaching the lowering — these
-      // cases are a fallback/defense and use the real op fields (handler/timeout).
-      return { expression: `__tc_setInterval(${o.handler}, ${o.timeout})` };
-    case 'timing.set_timeout':
-      // One-shot: k_timer with K_FOREVER period.
-      return { expression: `__tc_setTimeout(${o.handler}, ${o.timeout})` };
-    case 'timing.clear_interval':
-      return { code: `__tc_clearInterval(${o.id});` };
-    case 'timing.clear_timeout':
-      return { code: `__tc_clearTimeout(${o.id});` };
-    default:
-      throw new Error(
-        `framework-zephyr does not yet support HAL op \`${op.operation}\`. ` +
-          `Open an issue or use rawCpp() to emit it manually.`,
-      );
-  }
-}
-
+// ---------------------------------------------------------------------------
+// Timing lowering — Zephyr kernel timing
+//
+// sleep/now/now_us/busy_wait_us lower directly to kernel calls. Periodic or
+// deferred work is NOT a timing op: it is a Thread (k_thread) or a Counter
+// (hardware timer), each with its own lowering.
+// ---------------------------------------------------------------------------
+
+import type { HALOpIR } from '@typecad/cuttlefish/api/shared';
+
+/**
+ * Resolve a HAL timing.* op to Zephyr C++.
+ * Returns `{ code }` for statement ops, `{ expression }` for value-returning ops.
+ */
+export function lowerTiming(
+  op: HALOpIR,
+): { code?: string; expression?: string } {
+  const o = op as any;
+
+  switch (op.operation) {
+    case 'timing.sleep':
+      // Time.sleep — yielding ms sleep (k_msleep), delay()'s replacement.
+      return { code: `k_msleep(${o.ms});` };
+    case 'timing.now':
+      // Time.now — ms since boot as a double (k_uptime_get is int64_t ms).
+      return { expression: 'static_cast<double>(k_uptime_get())' };
+    case 'timing.now_us':
+      // Time.nowUs — µs since boot, uptime-derived for EVERY board: the
+      // cycle-counter form (k_cyc_to_us_floor64(k_cycle_get_64())) reads a
+      // constant on SoCs without a free-running 64-bit counter, so the one
+      // uniform expression that is monotonic and advancing everywhere is
+      // the kernel uptime scaled to µs. Resolution is therefore the uptime
+      // tick (millisecond), uniformly. A double holds µs exactly for ~285
+      // years.
+      return { expression: 'static_cast<double>(k_uptime_get() * 1000)' };
+    case 'timing.busy_wait_us':
+      // Time.busyWaitUs — spin, no yield; delayMicroseconds's honest name.
+      return { code: `k_busy_wait(${o.us});` };
+    default:
+      throw new Error(
+        `framework-zephyr does not yet support HAL op \`${op.operation}\`. ` +
+          `Open an issue or use rawCpp() to emit it manually.`,
+      );
+  }
+}
+