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

package/src/lowering/can.ts

@@ -0,0 +1,140 @@
+// ---------------------------------------------------------------------------
+// CAN lowering — Zephyr's can API over the harvested controller node
+//
+// The controller is addressed by its DT nodelabel (chip.can, the harvested
+// can@ node — ESP32 TWAI, STM32 bxCAN, NXP FlexCAN…). begin() applies
+// mode + bitrate + start in the required order (mode and bitrate need a
+// stopped controller); send() builds one can_frame and submits it with a
+// bounded timeout and no tx callback (blocking-send form); onReceive()
+// installs the accept-all filter whose trampoline carries the frame as
+// ten scalars — the Matrix discipline (ISR context, set-a-variable work).
+// ----------------------------------------------------------------------------
+
+import type { HALOpIR } from '@typecad/cuttlefish/api/shared';
+import type { ZephyrChipDescriptor } from '../chips/types.js';
+
+/** The C variable names for a CAN controller's state. */
+function prefix(idx: number): string {
+  return `__tc_can${idx}`;
+}
+
+/** Which can.* verbs the program actually uses on a controller — the
+ *  init block emits only the state those verbs reference (Zephyr's -Werror
+ *  turns an unreferenced static function/variable into a build failure:
+ *  a send-only program must not carry the rx trampoline). */
+export interface CanUsage {
+  begin: boolean;
+  send: boolean;
+  onReceive: boolean;
+}
+
+/**
+ * Emit the per-controller CAN state: device handle, rx trampoline +
+ * handler slot, and the accept-all filters. Called from shimLines when the
+ * program uses can.* on this controller and the chip declares it.
+ */
+export function canInitLines(chip: ZephyrChipDescriptor, controllerIndex: number, usage: CanUsage): string[] {
+  const ctrl = chip.can?.controllers[controllerIndex];
+  if (!ctrl) return [];
+  const p = prefix(controllerIndex);
+  const lines: string[] = [
+    '// CUTTLEFISH_CAN_BEGIN',
+    `static const struct device* ${p}_dev = DEVICE_DT_GET(DT_NODELABEL(${ctrl.nodeLabel}));`,
+  ];
+  if (usage.begin) {
+    // Shim-scoped (not per call site): a second begin() anywhere in the
+    // program must not re-fire can_start on a started controller.
+    lines.push(`static bool ${p}_started = false;`);
+  }
+  if (usage.onReceive) {
+    lines.push(
+      `static void (*${p}_rx)(double, double, double, double, double, double, double, double, double, double) = NULL;`,
+      // dlc-bounded: drivers fill only data[0..dlc-1] — copy into a zeroed
+      // local so the handler's b0..b7 tail is zero, as the class documents.
+      'static void __tc_can_rx_trampoline(const struct device* dev, struct can_frame* frame, void* user_data) {',
+      '    (void)dev;',
+      '    (void)user_data;',
+      `    if (${p}_rx != NULL) {`,
+      '        uint8_t __tc_d[8] = { 0U, 0U, 0U, 0U, 0U, 0U, 0U, 0U };',
+      '        for (uint32_t __tc_i = 0U; (__tc_i < 8U) && (__tc_i < static_cast<uint32_t>(frame->dlc)); ++__tc_i) { __tc_d[__tc_i] = frame->data[__tc_i]; }',
+      `        ${p}_rx(static_cast<double>(frame->id), static_cast<double>(frame->dlc),`,
+      `                          static_cast<double>(__tc_d[0]), static_cast<double>(__tc_d[1]),`,
+      `                          static_cast<double>(__tc_d[2]), static_cast<double>(__tc_d[3]),`,
+      `                          static_cast<double>(__tc_d[4]), static_cast<double>(__tc_d[5]),`,
+      `                          static_cast<double>(__tc_d[6]), static_cast<double>(__tc_d[7]));`,
+      '    }',
+      '}',
+      // Two accept-all filters: can_filter_matches_filter never delivers an
+      // IDE (29-bit) frame to a filter without CAN_FILTER_IDE — one filter
+      // per frame format, so extended sends are receivable too.
+      `static const struct can_filter ${p}_filter = { .id = 0U, .mask = 0U, .flags = 0U };`,
+      `static const struct can_filter ${p}_filter_ext = { .id = 0U, .mask = 0U, .flags = CAN_FILTER_IDE };`,
+      `static bool ${p}_filter_added = false;`,
+    );
+  }
+  if (usage.send) {
+    lines.push(
+      `static void __tc_can_tx_done(const struct device* dev, int error, void* user_data) {`,
+      '    (void)dev; (void)error; (void)user_data;',
+      '}',
+    );
+  }
+  lines.push('// CUTTLEFISH_CAN_END');
+  return lines;
+}
+
+/**
+ * Resolve a HAL can.* op to Zephyr C++.
+ * Returns `{ code }` for statement ops.
+ */
+export function lowerCan(
+  op: HALOpIR,
+  chip: ZephyrChipDescriptor,
+): { code?: string; expression?: string } {
+  const o = op as any;
+  // DAC discipline: a board with no harvested can@ node lowers to a comment
+  // naming the constraint (the board gate already refuses the CAN import;
+  // this keeps the manifest probe and direct-lowering paths honest).
+  if (!chip.can || chip.can.controllers.length === 0) {
+    return { code: `/* ${op.operation}: this board's chip data declares no CAN controller (no harvested can@ node) */` };
+  }
+  const idx = Math.min(Number(o.instance ?? 0), chip.can.controllers.length - 1);
+  const p = prefix(idx);
+  const started = `${p}_started`;
+
+  switch (op.operation) {
+    case 'can.begin': {
+      // Mode and bitrate require a STOPPED controller — apply them before
+      // the start, and start exactly once. Failures printk (the loud-
+      // diagnostics policy): a CAN bus that never comes up is otherwise a
+      // silent hang at the first send.
+      return {
+        code: `{ int __tc_err; if (${o.loopback}) { __tc_err = can_set_mode(${p}_dev, CAN_MODE_LOOPBACK); if (__tc_err != 0) { printk("typecad-hal can: set_mode failed: %d\\n", __tc_err); } } __tc_err = can_set_bitrate(${p}_dev, ${o.hz}); if (__tc_err != 0) { printk("typecad-hal can: bitrate failed: %d\\n", __tc_err); } if (!${started}) { ${started} = true; __tc_err = can_start(${p}_dev); if (__tc_err != 0) { printk("typecad-hal can: start failed: %d\\n", __tc_err); } } }`,
+      };
+    }
+    case 'can.send': {
+      const bytes = (o.data ?? []) as (number | string)[];
+      if (bytes.length > 8) {
+        throw new Error(
+          `CAN send: classic frames carry at most 8 bytes — got ${bytes.length}.`,
+        );
+      }
+      const assigns = bytes
+        .map((b, i) => `__tc_frame.data[${i}] = static_cast<uint8_t>(${b});`)
+        .join(' ');
+      return {
+        code: `{ struct can_frame __tc_frame = { 0 }; __tc_frame.id = static_cast<uint32_t>(${o.id}); __tc_frame.dlc = ${bytes.length}U; __tc_frame.flags = ${o.extended ? 'CAN_FRAME_IDE' : '0U'}; ${assigns} int __tc_err = can_send(${p}_dev, &__tc_frame, K_MSEC(100), __tc_can_tx_done, NULL); if (__tc_err != 0) { printk("typecad-hal can: send failed: %d\\n", __tc_err); } }`,
+      };
+    }
+    case 'can.on_receive': {
+      return {
+        code: `{ ${p}_rx = ${o.handler}; if (!${p}_filter_added) { ${p}_filter_added = true; (void)can_add_rx_filter(${p}_dev, __tc_can_rx_trampoline, NULL, &${p}_filter); (void)can_add_rx_filter(${p}_dev, __tc_can_rx_trampoline, NULL, &${p}_filter_ext); } }`,
+      };
+    }
+    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/clock.ts

@@ -0,0 +1,91 @@
+// ---------------------------------------------------------------------------
+// Clock lowering — rtc_set_time / rtc_get_time on the `rtc` DT alias
+//
+// The alias is Zephyr's own discovery convention. Boards with a hardware
+// calendar RTC alias it themselves; the overlay generator synthesizes a
+// zephyr,rtc-counter shim (a child of the board's first free counter — the
+// counter driver keeps the parent, so Counter and Clock coexist) when they
+// do not.
+//
+// Epoch ↔ civil conversion is Howard Hinnant's days_from_civil pair —
+// pure int64 arithmetic, no libc timezone machinery, valid over the whole
+// Unix range. The helpers live in the shim block so both ops share them.
+// ----------------------------------------------------------------------------
+
+import type { HALOpIR } from '@typecad/cuttlefish/api/shared';
+
+const RTC_DEV = 'DEVICE_DT_GET(DT_ALIAS(rtc))';
+
+/** The conversion helpers + device handle. Called from shimLines when the
+ *  program uses clock.* — each helper only when its consuming op appears
+ *  (a now()-only program must not carry the unused set() helper: -Werror
+ *  fails the build on unreferenced static functions). */
+export function clockInitLines(usage: { set: boolean; now: boolean }): string[] {
+  const lines: string[] = [
+    '// CUTTLEFISH_CLOCK_BEGIN',
+    `static const struct device* __tc_rtc = ${RTC_DEV};`,
+  ];
+  if (usage.now) {
+    lines.push(
+      'static int64_t __tc_days_from_civil(int32_t yy, int32_t mm, int32_t dd) {',
+      '    yy -= (mm <= 2) ? 1 : 0;',
+      '    const int32_t era = (yy >= 0 ? yy : yy - 399) / 400;',
+      '    const int32_t yoe = yy - era * 400;',
+      '    const int32_t doy = (153 * (mm + (mm > 2 ? -3 : 9)) + 2) / 5 + dd - 1;',
+      '    const int32_t doe = yoe * 365 + yoe / 4 - yoe / 100 + doy;',
+      '    return (static_cast<int64_t>(era) * 146097) + static_cast<int64_t>(doe) - 719468;',
+      '}',
+    );
+  }
+  if (usage.set) {
+    lines.push(
+      'static void __tc_civil_from_days(int64_t z, int32_t* yy, int32_t* mm, int32_t* dd) {',
+      '    z += 719468;',
+      '    const int64_t era = (z >= 0 ? z : z - 146096) / 146097;',
+      '    const int64_t doe = z - (era * 146097);',
+      '    const int64_t yoe = (doe - (doe / 1460) + (doe / 36524) - (doe / 146096)) / 365;',
+      '    const int64_t y = yoe + (era * 400);',
+      '    const int64_t doy = doe - ((365 * yoe) + (yoe / 4) - (yoe / 100));',
+      '    const int64_t mp = ((5 * doy) + 2) / 153;',
+      '    const int64_t d = doy - (((153 * mp) + 2) / 5) + 1;',
+      '    const int64_t m = mp + (mp < 10 ? 3 : -9);',
+      '    *yy = static_cast<int32_t>(y + (m <= 2 ? 1 : 0));',
+      '    *mm = static_cast<int32_t>(m);',
+      '    *dd = static_cast<int32_t>(d);',
+      '}',
+    );
+  }
+  lines.push('// CUTTLEFISH_CLOCK_END');
+  return lines;
+}
+
+/** The all-zero/unknown rtc_time initializer (wday/yday unknown per the
+ * struct's contract). */
+const TM_INIT = 'struct rtc_time __tc_tm = { 0, 0, 0, 0, 0, 0, -1, -1, -1, 0 }';
+
+/**
+ * Resolve a HAL clock.* op to Zephyr C++.
+ * Returns `{ code }` for set, `{ expression }` for now.
+ */
+export function lowerClock(op: HALOpIR): { code?: string; expression?: string } {
+  const o = op as any;
+
+  switch (op.operation) {
+    case 'clock.set': {
+      // epoch (runtime text) → civil date → rtc_set_time.
+      return {
+        code: `{ int64_t __tc_ep = static_cast<int64_t>(${o.epoch}); int32_t __tc_y = 0; int32_t __tc_mo = 0; int32_t __tc_d = 0; __tc_civil_from_days(__tc_ep / 86400, &__tc_y, &__tc_mo, &__tc_d); int64_t __tc_sod = __tc_ep % 86400; ${TM_INIT}; __tc_tm.tm_year = __tc_y - 1900; __tc_tm.tm_mon = __tc_mo - 1; __tc_tm.tm_mday = __tc_d; __tc_tm.tm_hour = static_cast<int32_t>(__tc_sod / 3600); __tc_tm.tm_min = static_cast<int32_t>((__tc_sod % 3600) / 60); __tc_tm.tm_sec = static_cast<int32_t>(__tc_sod % 60); (void)rtc_set_time(__tc_rtc, &__tc_tm); }`,
+      };
+    }
+    case 'clock.now': {
+      return {
+        expression: `({ ${TM_INIT}; double __tc_epoch = 0.0; if (rtc_get_time(__tc_rtc, &__tc_tm) == 0) { int64_t __tc_days = __tc_days_from_civil(__tc_tm.tm_year + 1900, __tc_tm.tm_mon + 1, __tc_tm.tm_mday); __tc_epoch = static_cast<double>((__tc_days * 86400) + (static_cast<int64_t>(__tc_tm.tm_hour) * 3600) + (static_cast<int64_t>(__tc_tm.tm_min) * 60) + static_cast<int64_t>(__tc_tm.tm_sec)); } __tc_epoch; })`,
+      };
+    }
+    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/fs.ts

@@ -1,135 +1,135 @@
-// ---------------------------------------------------------------------------
-// Filesystem lowering — Zephyr FS API (littlefs on the storage partition)
-//
-// HAL `fs.*` (begin/read_text/write_text/exists/remove) maps onto Zephyr's
-// <zephyr/fs/fs.h>. A littlefs filesystem is mounted at "/lfs" on the board's
-// `storage_partition` fixed-partition (the same partition the ZMS settings
-// backend uses for preferences — a program should not use both surfaces at
-// once without dedicating separate partitions). The mount is lazy: it formats
-// + remounts on first use when the partition is unformatted.
-//
-// The HAL paths are treated as paths WITHIN the filesystem: the shim joins the
-// mount point, so fs.read_text("/data.txt") reads "/lfs/data.txt". This keeps
-// the mount point an implementation detail.
-//
-// Requires Kconfig CONFIG_FILE_SYSTEM + CONFIG_FILE_SYSTEM_LITTLEFS (+ FLASH /
-// FLASH_MAP) — emitted by the scaffold when the program uses fs.* — and the
-// storage_partition node (added by the overlay).
-// ---------------------------------------------------------------------------
-
-import type { HALOpIR } from '@typecad/cuttlefish/api/shared';
-
-/**
- * Emit the littlefs mount + the typed helper API the lowering calls into.
- * Called from shimLines when the program uses the filesystem. The helpers are
- * `static` so multiple TUs that carry the shim (guarded by the include guard)
- * do not collide.
- */
-export function fsInitLines(): string[] {
-  return [
-    '// CUTTLEFISH_FS_BEGIN',
-    'static struct fs_mount_t __tc_fs_mp;',
-    'static bool __tc_fs_mounted = false;',
-    '',
-    'FS_LITTLEFS_DECLARE_DEFAULT_CONFIG(__tc_fs_data);',
-    'static struct fs_mount_t __tc_fs_mp_init = {',
-    '    .type = FS_LITTLEFS,',
-    '    .mnt_point = "/lfs",',
-    '    .fs_data = &__tc_fs_data,',
-    '    .storage_dev = (void *)FIXED_PARTITION_ID(storage_partition),',
-    '};',
-    '',
-    'static void __tc_fs_ensure_mount(void) {',
-    '    if (__tc_fs_mounted) return;',
-    '    __tc_fs_mp = __tc_fs_mp_init;',
-    '    int rc = fs_mount(&__tc_fs_mp);',
-    '    if (rc != 0) {',
-    '        // Any mount failure with a valid config means the partition is',
-    '        // unformatted or corrupt (littlefs reports -EIO on erased flash,',
-    '        // not only -ENODATA/-EINVAL) — format it and remount once.',
-    '        (void)fs_mkfs(FS_LITTLEFS, static_cast<uintptr_t>(FIXED_PARTITION_ID(storage_partition)), NULL, 0);',
-    '        rc = fs_mount(&__tc_fs_mp);',
-    '    }',
-    '    if (rc == 0) {',
-    '        __tc_fs_mounted = true;',
-    '    } else {',
-    '        char __tc_fs_err[48];',
-    '        (void)snprintf(__tc_fs_err, sizeof(__tc_fs_err), "cuttlefish-fs: mount failed rc=%d", rc);',
-    '        __tc_println(__tc_fs_err);',
-    '    }',
-    '}',
-    '',
-    '// Join the mount point with the user path (paths are within the FS).',
-    'static const char* __tc_fs_path(const char* p) {',
-    '    static char buf[128];',
-    '    if (!p) return "/lfs";',
-    '    const char* s = (p[0] == \'/\') ? p + 1 : p;',
-    '    (void)snprintf(buf, sizeof(buf), "/lfs/%s", s);',
-    '    return buf;',
-    '}',
-    '',
-    'static bool __tc_fs_begin(void) { __tc_fs_ensure_mount(); return true; }',
-    '',
-    'static const char* __tc_fs_read_text(const char* path) {',
-    '    __tc_fs_ensure_mount();',
-    '    static char buf[256];',
-    '    buf[0] = 0;',
-    '    struct fs_file_t f;',
-    '    fs_file_t_init(&f);',
-    '    if (fs_open(&f, __tc_fs_path(path), FS_O_READ) == 0) {',
-    '        // Terminate at the READ length: the buffer is static and shared',
-    '        // across reads, so bytes from a longer previous file survive a',
-    '        // short read otherwise.',
-    '        ssize_t n = fs_read(&f, buf, sizeof(buf) - 1);',
-    '        buf[(n > 0) ? n : 0] = 0;',
-    '        (void)fs_close(&f);',
-    '    }',
-    '    return buf;',
-    '}',
-    '',
-    'static void __tc_fs_write_text(const char* path, const char* content) {',
-    '    __tc_fs_ensure_mount();',
-    '    struct fs_file_t f;',
-    '    fs_file_t_init(&f);',
-    '    if (fs_open(&f, __tc_fs_path(path), FS_O_WRITE | FS_O_CREATE | FS_O_TRUNC) == 0) {',
-    '        (void)fs_write(&f, content, (content ? strlen(content) : 0));',
-    '        (void)fs_close(&f);',
-    '    }',
-    '}',
-    '',
-    'static bool __tc_fs_exists(const char* path) {',
-    '    __tc_fs_ensure_mount();',
-    '    struct fs_dirent ent;',
-    '    return fs_stat(__tc_fs_path(path), &ent) == 0;',
-    '}',
-    '',
-    'static bool __tc_fs_remove(const char* path) {',
-    '    __tc_fs_ensure_mount();',
-    '    return fs_unlink(__tc_fs_path(path)) == 0;',
-    '}',
-    '// CUTTLEFISH_FS_END',
-  ];
-}
-
-/**
- * Resolve a HAL fs.* op to Zephyr C++.
- * Returns `{ code }` — each op's code is the body of the HAL FS class method.
- */
-export function lowerFs(op: HALOpIR): { code?: string; expression?: string } {
-  const o = op as any;
-  switch (op.operation) {
-    case 'fs.read_text':
-      return { code: `return __tc_fs_read_text(${o.path});` };
-    case 'fs.write_text':
-      return { code: `__tc_fs_write_text(${o.path}, ${o.content});` };
-    case 'fs.exists':
-      return { code: `return __tc_fs_exists(${o.path});` };
-    case 'fs.remove':
-      return { code: `return __tc_fs_remove(${o.path});` };
-    default:
-      throw new Error(
-        `framework-zephyr does not yet support HAL op \`${op.operation}\`. ` +
-          `Open an issue or use rawCpp() to emit it manually.`,
-      );
-  }
-}
+// ---------------------------------------------------------------------------
+// Filesystem lowering — Zephyr FS API (littlefs on the storage partition)
+//
+// HAL `fs.*` (begin/read_text/write_text/exists/remove) maps onto Zephyr's
+// <zephyr/fs/fs.h>. A littlefs filesystem is mounted at "/lfs" on the board's
+// `storage_partition` fixed-partition (the same partition the ZMS settings
+// backend uses for preferences — a program should not use both surfaces at
+// once without dedicating separate partitions). The mount is lazy: it formats
+// + remounts on first use when the partition is unformatted.
+//
+// The HAL paths are treated as paths WITHIN the filesystem: the shim joins the
+// mount point, so fs.read_text("/data.txt") reads "/lfs/data.txt". This keeps
+// the mount point an implementation detail.
+//
+// Requires Kconfig CONFIG_FILE_SYSTEM + CONFIG_FILE_SYSTEM_LITTLEFS (+ FLASH /
+// FLASH_MAP) — emitted by the scaffold when the program uses fs.* — and the
+// storage_partition node (added by the overlay).
+// ---------------------------------------------------------------------------
+
+import type { HALOpIR } from '@typecad/cuttlefish/api/shared';
+
+/**
+ * Emit the littlefs mount + the typed helper API the lowering calls into.
+ * Called from shimLines when the program uses the filesystem. The helpers are
+ * `static` so multiple TUs that carry the shim (guarded by the include guard)
+ * do not collide.
+ */
+export function fsInitLines(): string[] {
+  return [
+    '// CUTTLEFISH_FS_BEGIN',
+    'static struct fs_mount_t __tc_fs_mp;',
+    'static bool __tc_fs_mounted = false;',
+    '',
+    'FS_LITTLEFS_DECLARE_DEFAULT_CONFIG(__tc_fs_data);',
+    'static struct fs_mount_t __tc_fs_mp_init = {',
+    '    .type = FS_LITTLEFS,',
+    '    .mnt_point = "/lfs",',
+    '    .fs_data = &__tc_fs_data,',
+    '    .storage_dev = (void *)FIXED_PARTITION_ID(storage_partition),',
+    '};',
+    '',
+    'static void __tc_fs_ensure_mount(void) {',
+    '    if (__tc_fs_mounted) return;',
+    '    __tc_fs_mp = __tc_fs_mp_init;',
+    '    int rc = fs_mount(&__tc_fs_mp);',
+    '    if (rc != 0) {',
+    '        // Any mount failure with a valid config means the partition is',
+    '        // unformatted or corrupt (littlefs reports -EIO on erased flash,',
+    '        // not only -ENODATA/-EINVAL) — format it and remount once.',
+    '        (void)fs_mkfs(FS_LITTLEFS, static_cast<uintptr_t>(FIXED_PARTITION_ID(storage_partition)), NULL, 0);',
+    '        rc = fs_mount(&__tc_fs_mp);',
+    '    }',
+    '    if (rc == 0) {',
+    '        __tc_fs_mounted = true;',
+    '    } else {',
+    '        char __tc_fs_err[48];',
+    '        (void)snprintf(__tc_fs_err, sizeof(__tc_fs_err), "typecad-hal-fs: mount failed rc=%d", rc);',
+    '        __tc_println(__tc_fs_err);',
+    '    }',
+    '}',
+    '',
+    '// Join the mount point with the user path (paths are within the FS).',
+    'static const char* __tc_fs_path(const char* p) {',
+    '    static char buf[128];',
+    '    if (!p) return "/lfs";',
+    '    const char* s = (p[0] == \'/\') ? p + 1 : p;',
+    '    (void)snprintf(buf, sizeof(buf), "/lfs/%s", s);',
+    '    return buf;',
+    '}',
+    '',
+    'static bool __tc_fs_begin(void) { __tc_fs_ensure_mount(); return true; }',
+    '',
+    'static const char* __tc_fs_read_text(const char* path) {',
+    '    __tc_fs_ensure_mount();',
+    '    static char buf[256];',
+    '    buf[0] = 0;',
+    '    struct fs_file_t f;',
+    '    fs_file_t_init(&f);',
+    '    if (fs_open(&f, __tc_fs_path(path), FS_O_READ) == 0) {',
+    '        // Terminate at the READ length: the buffer is static and shared',
+    '        // across reads, so bytes from a longer previous file survive a',
+    '        // short read otherwise.',
+    '        ssize_t n = fs_read(&f, buf, sizeof(buf) - 1);',
+    '        buf[(n > 0) ? n : 0] = 0;',
+    '        (void)fs_close(&f);',
+    '    }',
+    '    return buf;',
+    '}',
+    '',
+    'static void __tc_fs_write_text(const char* path, const char* content) {',
+    '    __tc_fs_ensure_mount();',
+    '    struct fs_file_t f;',
+    '    fs_file_t_init(&f);',
+    '    if (fs_open(&f, __tc_fs_path(path), FS_O_WRITE | FS_O_CREATE | FS_O_TRUNC) == 0) {',
+    '        (void)fs_write(&f, content, (content ? strlen(content) : 0));',
+    '        (void)fs_close(&f);',
+    '    }',
+    '}',
+    '',
+    'static bool __tc_fs_exists(const char* path) {',
+    '    __tc_fs_ensure_mount();',
+    '    struct fs_dirent ent;',
+    '    return fs_stat(__tc_fs_path(path), &ent) == 0;',
+    '}',
+    '',
+    'static bool __tc_fs_remove(const char* path) {',
+    '    __tc_fs_ensure_mount();',
+    '    return fs_unlink(__tc_fs_path(path)) == 0;',
+    '}',
+    '// CUTTLEFISH_FS_END',
+  ];
+}
+
+/**
+ * Resolve a HAL fs.* op to Zephyr C++.
+ * Returns `{ code }` — each op's code is the body of the HAL FS class method.
+ */
+export function lowerFs(op: HALOpIR): { code?: string; expression?: string } {
+  const o = op as any;
+  switch (op.operation) {
+    case 'fs.read_text':
+      return { code: `return __tc_fs_read_text(${o.path});` };
+    case 'fs.write_text':
+      return { code: `__tc_fs_write_text(${o.path}, ${o.content});` };
+    case 'fs.exists':
+      return { code: `return __tc_fs_exists(${o.path});` };
+    case 'fs.remove':
+      return { code: `return __tc_fs_remove(${o.path});` };
+    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/gpio.ts

@@ -30,39 +30,6 @@ function findDtSpec(chip: ZephyrChipDescriptor, pin: number) {
   return chip.gpio.dtSpecs.find((s) => s.pin === pin);
 }
 
-// HAL passes UPPERCASE modes ("OUTPUT") while docs say lowercase ("output").
-// The *_pullup / *_pulldown modes map to GPIO_INPUT (Zephyr does not have
-// separate input+pull mode flags) and OR in a GPIO_PULL_UP / GPIO_PULL_DOWN
-// bit via `dtFlagsForMode` — without that bit the pin floats, so INPUT_PULLUP
-// was a silent no-op (bug B1). Mirrors the gpio_pullup_en/gpio_pulldown_en
-// extras framework-esp32 emits for the same modes.
-const MODE_MAP: Record<string, string> = {
-  output: 'GPIO_OUTPUT',
-  OUTPUT: 'GPIO_OUTPUT',
-  input: 'GPIO_INPUT',
-  INPUT: 'GPIO_INPUT',
-  input_pullup: 'GPIO_INPUT',
-  INPUT_PULLUP: 'GPIO_INPUT',
-  input_pulldown: 'GPIO_INPUT',
-  INPUT_PULLDOWN: 'GPIO_INPUT',
-};
-
-/** Additional DT flag bits for a HAL mode, OR'd into the configure flags.
- *  Returns '' for modes with no extra bits so the join leaves the mode alone. */
-function dtFlagsForMode(mode: string): string {
-  const m = (mode ?? '').toLowerCase();
-  if (m === 'input_pullup') return ' | GPIO_PULL_UP';
-  if (m === 'input_pulldown') return ' | GPIO_PULL_DOWN';
-  return '';
-}
-
-/** Combined mode + pull flags for a HAL mode string, e.g.
- *  'INPUT_PULLUP' → 'GPIO_INPUT | GPIO_PULL_UP'. */
-function flagsForMode(mode: string): string {
-  const base = MODE_MAP[mode] ?? 'GPIO_INPUT';
-  return base + dtFlagsForMode(mode);
-}
-
 // ── Thin GPIO (hal/gpio-pin.ts) — flag tokens ─────────────────────────────
 //
 // "GPIO.OUTPUT | GPIO.PULL_UP" token text maps name-for-name onto the GPIO_*