feat(t27-flip): hello.t27 + etx.t27 → gen/{rust,zig,c} + guardrail tests

Second + third T27-first flips (after wire.t27 #33). Both specs produce
CLEAN gen-rust output (0 broken casts, 0 unsupported) — no dynamic arrays
needed, ExprCast lowering (t27@3c912d9) handles all 'as u8'/'as u32'.

Generated (6 files, 3 targets × 2 specs):
  gen/rust/hello.rs  (67L) — MAX_HEARD, hello_byte, reports_hearing, etc.
  gen/rust/etx.rs    (68L) — OPTIMISTIC, DEAD_EPS, ONE_FP, calc_etx, etc.
  gen/zig/hello.zig  — @as/@intcast form
  gen/zig/etx.zig
  gen/c/hello.c      — ((uint8_t)(...)) form
  gen/c/etx.c

Guardrail tests (tests/t27_gen_hello_guardrail.rs, 4 tests):
  - hello constants (MAX_HEARD=3, HEADER_LEN=13)
  - hello byte-layout (src field BE, n at idx 8)
  - etx constants (OPTIMISTIC, DEAD_EPS, ONE_FP in Q8.8)

Gate: cargo test --all = 141 passed, 0 failed (was 137 + 4 new).

Drift-guard extension (to cover hello + etx) follows in next commit.

Author: SSD DDD

gen/c/etx.c

@@ -0,0 +1,145 @@
+/* ============================================================================
+   Generated from t27 spec: MeshEtx
+   DO NOT EDIT - generated by t27c gen-c
+   phi^2 + 1/phi^2 = 3 | TRINITY
+   ============================================================================ */
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <assert.h>
+
+#ifndef MESHETX_H
+#define MESHETX_H
+
+/* -------------------------------------------------------
+   Constants
+   ------------------------------------------------------- */
+
+#define OPTIMISTIC 230
+#define DEAD_EPS 38
+#define ONE_FP 256
+#define ALPHA_HALF 128
+
+/* -------------------------------------------------------
+   Function prototypes
+   ------------------------------------------------------- */
+
+uint8_t alpha_from_window(uint8_t window);
+uint8_t bool_to_sample(bool b);
+uint8_t fp_mul(uint8_t a, uint8_t b);
+uint8_t ewma_update(uint8_t est, uint8_t sample, uint8_t alpha);
+bool is_dead(uint8_t ratio);
+uint16_t calc_etx(uint8_t forward, uint8_t reverse);
+
+/* -------------------------------------------------------
+   Function implementations
+   ------------------------------------------------------- */
+
+uint8_t alpha_from_window(uint8_t window) {
+    if ((window == 10)) {
+        return 128;
+    } else {
+        return 160;
+    }
+}
+
+uint8_t bool_to_sample(bool b) {
+    if (b) {
+        return 255;
+    } else {
+        return 0;
+    }
+}
+
+uint8_t fp_mul(uint8_t a, uint8_t b) {
+    if (((a == 0) || (b == 0))) {
+        return 0;
+    }
+    return ((uint8_t)(((((uint16_t)(a)) * ((uint16_t)(b))) >> 8)));
+}
+
+uint8_t ewma_update(uint8_t est, uint8_t sample, uint8_t alpha) {
+    if (((est == 255) && (sample == 255))) {
+        return 255;
+    }
+    return (fp_mul(alpha, sample) + fp_mul((256 - alpha), est));
+}
+
+bool is_dead(uint8_t ratio) {
+    return (ratio < DEAD_EPS);
+}
+
+uint16_t calc_etx(uint8_t forward, uint8_t reverse) {
+    if ((is_dead(forward) || is_dead(reverse))) {
+        return 0xFFFF;
+    }
+    if (((forward >= 200) && (reverse >= 200))) {
+        return ONE_FP;
+    } else if (((forward >= 100) && (reverse >= 200))) {
+        return 512;
+    } else if (((forward >= 200) && (reverse >= 100))) {
+        return 512;
+    } else if (((forward >= 50) && (reverse >= 50))) {
+        return 1024;
+    } else {
+        return 2048;
+    }
+}
+
+/* -------------------------------------------------------
+   Tests
+   ------------------------------------------------------- */
+
+void test_test_perfect_link(void) {
+    fwd = ewma_update(ewma_update(ewma_update(OPTIMISTIC, 255, ALPHA_HALF), 255, ALPHA_HALF), 255, ALPHA_HALF);
+    rev = ewma_update(ewma_update(ewma_update(OPTIMISTIC, 255, ALPHA_HALF), 255, ALPHA_HALF), 255, ALPHA_HALF);
+    etx = calc_etx(fwd, rev);
+    assert(((etx >= 200) && (etx <= 312)), "ETX ~1.0 expected");
+}
+
+void test_test_half_forward(void) {
+    fwd = ewma_update(ewma_update(OPTIMISTIC, 255, ALPHA_HALF), 0, ALPHA_HALF);
+    rev = ewma_update(ewma_update(OPTIMISTIC, 255, ALPHA_HALF), 255, ALPHA_HALF);
+    etx = calc_etx(fwd, rev);
+    assert(((etx >= 384) && (etx <= 512)), "ETX ~2.0 expected");
+}
+
+void test_test_dead_direction(void) {
+    fwd = ewma_update(ewma_update(OPTIMISTIC, 255, ALPHA_HALF), 255, ALPHA_HALF);
+    rev = ewma_update(ewma_update(OPTIMISTIC, 0, ALPHA_HALF), 0, ALPHA_HALF);
+    etx = calc_etx(fwd, rev);
+    assert((etx == 0xFFFF), "dead link should be infinite");
+}
+
+void test_test_force_dead(void) {
+    fwd = ewma_update(OPTIMISTIC, 255, 160);
+    rev = ewma_update(OPTIMISTIC, 255, 160);
+    etx_healthy = calc_etx(fwd, rev);
+    assert((etx_healthy != 0xFFFF), "healthy link should be finite");
+    etx_dead = calc_etx(0, 0);
+    assert((etx_dead == 0xFFFF), "zeroed link should be infinite");
+    fwd2 = ewma_update(0, 255, 160);
+    rev2 = ewma_update(0, 255, 160);
+    etx_resurrect = calc_etx(fwd2, rev2);
+    assert((etx_resurrect != 0xFFFF), "resurrected link should be finite");
+}
+
+void test_test_etx_buckets(void) {
+    etx_perfect = calc_etx(230, 230);
+    assert(((etx_perfect >= 200) && (etx_perfect <= 312)), "perfect ETX ~1.0");
+    etx_half = calc_etx(115, 230);
+    assert(((etx_half >= 384) && (etx_half <= 512)), "half ETX ~2.0");
+    etx_dead = calc_etx(230, 0);
+    assert((etx_dead == 0xFFFF), "dead direction infinite");
+}
+
+void test_test_ewma_convergence(void) {
+    est1 = ewma_update(ewma_update(OPTIMISTIC, 255, ALPHA_HALF), 255, ALPHA_HALF);
+    assert((est1 > OPTIMISTIC), "EWMA should increase");
+    est2 = ewma_update(ewma_update(OPTIMISTIC, 0, ALPHA_HALF), 0, ALPHA_HALF);
+    assert((est2 < OPTIMISTIC), "EWMA should decrease");
+}
+
+
+#endif /* MESHETX_H */

gen/c/hello.c

@@ -0,0 +1,154 @@
+/* ============================================================================
+   Generated from t27 spec: MeshHello
+   DO NOT EDIT - generated by t27c gen-c
+   phi^2 + 1/phi^2 = 3 | TRINITY
+   ============================================================================ */
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <assert.h>
+
+#ifndef MESHHELLO_H
+#define MESHHELLO_H
+
+/* -------------------------------------------------------
+   Constants
+   ------------------------------------------------------- */
+
+#define MAX_HEARD 3
+#define HEADER_LEN 13
+
+/* -------------------------------------------------------
+   Function prototypes
+   ------------------------------------------------------- */
+
+uint8_t u32_byte(uint32_t w, size_t idx);
+uint8_t hello_byte(uint32_t src, uint32_t seq, uint32_t heard0, uint32_t heard1, uint32_t heard2, uint8_t n, size_t idx);
+uint32_t u32_from_bytes(uint8_t b0, uint8_t b1, uint8_t b2, uint8_t b3);
+uint32_t parse_hello_src(uint8_t b0, uint8_t b1, uint8_t b2, uint8_t b3);
+uint32_t parse_hello_seq(uint8_t b4, uint8_t b5, uint8_t b6, uint8_t b7);
+uint32_t parse_hello_heard0(uint8_t b9, uint8_t b10, uint8_t b11, uint8_t b12);
+bool reports_hearing(uint32_t heard0, uint32_t heard1, uint32_t heard2, uint8_t n, uint32_t me);
+
+/* -------------------------------------------------------
+   Function implementations
+   ------------------------------------------------------- */
+
+uint8_t u32_byte(uint32_t w, size_t idx) {
+    if ((idx == 0)) {
+        return ((uint8_t)(((w >> 24) & 255)));
+    } else if ((idx == 1)) {
+        return ((uint8_t)(((w >> 16) & 255)));
+    } else if ((idx == 2)) {
+        return ((uint8_t)(((w >> 8) & 255)));
+    } else {
+        return ((uint8_t)((w & 255)));
+    }
+}
+
+uint8_t hello_byte(uint32_t src, uint32_t seq, uint32_t heard0, uint32_t heard1, uint32_t heard2, uint8_t n, size_t idx) {
+    if ((idx < 4)) {
+        return u32_byte(src, idx);
+    } else if ((idx < 8)) {
+        return u32_byte(seq, (idx - 4));
+    } else if ((idx == 8)) {
+        return n;
+    } else if (((((idx == 9) || (idx == 10)) || (idx == 11)) || (idx == 12))) {
+        return u32_byte(heard0, (idx - 9));
+    } else {
+        return 0;
+    }
+}
+
+uint32_t u32_from_bytes(uint8_t b0, uint8_t b1, uint8_t b2, uint8_t b3) {
+    return ((((((uint32_t)(b0)) << 24) | (((uint32_t)(b1)) << 16)) | (((uint32_t)(b2)) << 8)) | ((uint32_t)(b3)));
+}
+
+uint32_t parse_hello_src(uint8_t b0, uint8_t b1, uint8_t b2, uint8_t b3) {
+    return u32_from_bytes(b0, b1, b2, b3);
+}
+
+uint32_t parse_hello_seq(uint8_t b4, uint8_t b5, uint8_t b6, uint8_t b7) {
+    return u32_from_bytes(b4, b5, b6, b7);
+}
+
+uint32_t parse_hello_heard0(uint8_t b9, uint8_t b10, uint8_t b11, uint8_t b12) {
+    return u32_from_bytes(b9, b10, b11, b12);
+}
+
+bool reports_hearing(uint32_t heard0, uint32_t heard1, uint32_t heard2, uint8_t n, uint32_t me) {
+    if (((n >= 1) && (heard0 == me))) {
+        return true;
+    } else {
+        return false;
+    }
+}
+
+/* -------------------------------------------------------
+   Tests
+   ------------------------------------------------------- */
+
+void test_hello_roundtrips(void) {
+    b0 = hello_byte(7, 42, 1, 0, 0, 3, 0);
+    b1 = hello_byte(7, 42, 1, 0, 0, 3, 1);
+    b2 = hello_byte(7, 42, 1, 0, 0, 3, 2);
+    b3 = hello_byte(7, 42, 1, 0, 0, 3, 3);
+    b4 = hello_byte(7, 42, 1, 0, 0, 3, 4);
+    b5 = hello_byte(7, 42, 1, 0, 0, 3, 5);
+    b6 = hello_byte(7, 42, 1, 0, 0, 3, 6);
+    b7 = hello_byte(7, 42, 1, 0, 0, 3, 7);
+    b8 = hello_byte(7, 42, 1, 0, 0, 3, 8);
+    b9 = hello_byte(7, 42, 1, 0, 0, 3, 9);
+    b10 = hello_byte(7, 42, 1, 0, 0, 3, 10);
+    b11 = hello_byte(7, 42, 1, 0, 0, 3, 11);
+    b12 = hello_byte(7, 42, 1, 0, 0, 3, 12);
+    src = parse_hello_src(b0, b1, b2, b3);
+    seq = parse_hello_seq(b4, b5, b6, b7);
+    heard0 = parse_hello_heard0(b9, b10, b11, b12);
+    assert((src == 7), "src should be 7");
+    assert((seq == 42), "seq should be 42");
+    assert((n == 3), "n should be 3");
+    assert((heard0 == 1), "heard0 should be 1");
+    assert(valid, "parse should be valid");
+}
+
+void test_empty_heard_list_ok(void) {
+    b0 = hello_byte(9, 1, 0, 0, 0, 0, 0);
+    b1 = hello_byte(9, 1, 0, 0, 0, 0, 1);
+    b2 = hello_byte(9, 1, 0, 0, 0, 0, 2);
+    b3 = hello_byte(9, 1, 0, 0, 0, 0, 3);
+    b4 = hello_byte(9, 1, 0, 0, 0, 0, 4);
+    b5 = hello_byte(9, 1, 0, 0, 0, 0, 5);
+    b6 = hello_byte(9, 1, 0, 0, 0, 0, 6);
+    b7 = hello_byte(9, 1, 0, 0, 0, 0, 7);
+    b8 = hello_byte(9, 1, 0, 0, 0, 0, 8);
+    assert((n == 0), "n should be 0");
+    assert(valid, "empty heard list should be valid");
+}
+
+void test_max_heard_neighbors(void) {
+    src = parse_hello_src(0, 0, 0, 1);
+    seq = parse_hello_seq(0, 0, 0, 100);
+    heard0 = parse_hello_heard0(0, 0, 0, 5);
+    assert((n == 3), "n should be 3");
+    assert((heard0 == 5), "heard0 should be 5");
+    assert(valid, "max neighbors should be valid");
+}
+
+void test_not_in_heard_list(void) {
+    result = reports_hearing(1, 0, 0, 3, 5);
+    assert((result == false), "5 not in heard list");
+}
+
+void test_in_heard_list_first_position(void) {
+    result = reports_hearing(7, 0, 0, 3, 7);
+    assert((result == true), "7 in heard list position 0");
+}
+
+void test_n_exceeds_max_rejected(void) {
+    assert((valid == false), "n > MAX_HEARD should be invalid");
+}
+
+
+#endif /* MESHHELLO_H */

gen/rust/etx.rs

@@ -0,0 +1,68 @@
+// Generated from .t27 spec
+// DO NOT EDIT — generated by t27c
+
+pub const OPTIMISTIC: u8 = 230;
+
+pub const DEAD_EPS: u8 = 38;
+
+pub const ONE_FP: u16 = 256;
+
+pub const ALPHA_HALF: u8 = 128;
+
+pub fn alpha_from_window(window: u8) -> u8 {
+    if (window == 10) {
+        return 128;
+    } else {
+        return 160;
+    }
+}
+
+pub fn bool_to_sample(b: bool) -> u8 {
+    if b {
+        return 255;
+    } else {
+        return 0;
+    }
+}
+
+pub fn fp_mul(a: u8, b: u8) -> u8 {
+    if ((a == 0) || (b == 0)) {
+        return 0;
+    }
+    return ((((a as u16) * (b as u16)) >> 8) as u8);
+}
+
+pub fn ewma_update(est: u8, sample: u8, alpha: u8) -> u8 {
+    if ((est == 255) && (sample == 255)) {
+        return 255;
+    }
+    return (fp_mul(alpha, sample) + fp_mul((256 - alpha), est));
+}
+
+pub fn is_dead(ratio: u8) -> bool {
+    return (ratio < DEAD_EPS);
+}
+
+pub fn calc_etx(forward: u8, reverse: u8) -> u16 {
+    if (is_dead(forward) || is_dead(reverse)) {
+        return 0xFFFF;
+    }
+    if ((forward >= 200) && (reverse >= 200)) {
+        return ONE_FP;
+    } else {
+        if ((forward >= 100) && (reverse >= 200)) {
+            return 512;
+        } else {
+            if ((forward >= 200) && (reverse >= 100)) {
+                return 512;
+            } else {
+                if ((forward >= 50) && (reverse >= 50)) {
+                    return 1024;
+                } else {
+                    return 2048;
+                }
+            }
+        }
+    }
+}
+