fix(zephyr): correct ZRMB header length to 84 bytes and fix determinism test API names

- lib/arbiter_blob.c: ZRMB_HEADER_LEN 80 -> 84 (struct includes crc32 field,
  4+2+2+4+4+32+32+4 = 84 bytes). Update CRC comment offset accordingly.
- python/arbiter/emit_blob.py: header_len field value 80 -> 84, crc32 pack_into
  offset 76 -> 80 to match actual struct layout.
- tests/unit/test_arbiter_blob/src/main.c: valid_blob[80] -> valid_blob[84],
  fix header_len/total_len bytes from 0x50 to 0x54, remove hardcoded 80 in
  null-param tests (use sizeof(valid_blob)), fix bad[] array size to 84.
- tests/unit/test_arbiter_determinism/src/main.c: replace all lowercase
  arbiter_* struct/function names with ARBITER_ prefix to match the public
  header API. Fix result field names: .mode -> .current_mode,
  .fired_count -> .requested_action_count.

Co-Authored-By: Oz <oz-agent@warp.dev>

Author: tbitcs

LEDGER.md

@@ -1,5 +1,16 @@
 # Change Ledger
 
+## 2026-06-01T00:04 — Fix ZRMB header length and CRC offset
+- **Author**: Oz
+- **Type**: fix
+- **REQs affected**: REQ-BUILD-001, REQ-ARCH-006, REQ-ARCH-023
+- **Summary**: Corrected the binary blob header length from 80 to 84 bytes
+  (the actual size of magic/version/flags/lengths/two hashes/crc32), updated
+  the CRC offset from 76 to 80 in the emitter, and fixed the blob unit test
+  fixture lengths. This removes Linux `-Werror` array-initializer failures
+  and aligns runtime loader validation with emitted blobs.
+- **Status**: complete
+
 ## 2026-06-01T00:00 — Fix public/generated header include casing
 - **Author**: Oz
 - **Type**: fix

lib/arbiter_blob.c

@@ -9,7 +9,7 @@ LOG_MODULE_DECLARE(arbiter, CONFIG_ARBITER_LOG_LEVEL);
 
 #define ZRMB_MAGIC      0x424D525A /* "ZRMB" little-endian */
 #define ZRMB_VERSION    1
-#define ZRMB_HEADER_LEN 80 /* magic(4)+ver(2)+flags(2)+hlen(4)+tlen(4)+mhash(32)+shash(32)+crc(4) */
+#define ZRMB_HEADER_LEN 84 /* magic(4)+ver(2)+flags(2)+hlen(4)+tlen(4)+mhash(32)+shash(32)+crc(4) */
 
 struct zrmb_header {
 	uint32_t magic;
@@ -81,7 +81,7 @@ int ARBITER_blob_load(const uint8_t *blob, size_t blob_len,
 	}
 
 	/* Validate CRC over everything except the CRC field itself.
-	 * CRC field is at offset 76 (4 bytes before end of header).
+	 * CRC field is at offset 80 (4 bytes before end of header).
 	 */
 	uint32_t crc = compute_crc32(blob, offsetof(struct zrmb_header, crc32));
 	uint32_t crc_rest = compute_crc32(

python/arbiter/emit_blob.py

@@ -32,7 +32,7 @@ def emit_blob(model: CanonicalModel) -> bytes:
     header += ZRMB_MAGIC
     header += struct.pack("<H", ZRMB_VERSION)
     header += struct.pack("<H", 0)  # flags
-    header += struct.pack("<I", 80)  # header_len
+    header += struct.pack("<I", 84)  # header_len
     header += struct.pack("<I", 0)   # total_len placeholder
     header += model_hash_bytes
     header += schema_hash_bytes
@@ -66,6 +66,6 @@ def emit_blob(model: CanonicalModel) -> bytes:
     # CRC over everything except the CRC field (last 4 bytes of header)
     blob = bytes(header[:-4]) + bytes(sections)
     crc = zlib.crc32(blob) & 0xFFFFFFFF
-    struct.pack_into("<I", header, 76, crc)  # crc32
+    struct.pack_into("<I", header, 80, crc)  # crc32
 
     return bytes(header) + bytes(sections)

tests/unit/test_arbiter_blob/src/main.c

@@ -7,13 +7,13 @@
 extern int ARBITER_blob_load(const uint8_t *blob, size_t blob_len,
 			   struct ARBITER_model *model_out);
 
-/* Minimal valid ZRMB header (80 bytes) */
-static uint8_t valid_blob[80] = {
+/* Minimal valid ZRMB header (84 bytes) */
+static uint8_t valid_blob[84] = {
 	'Z', 'R', 'M', 'B',       /* magic */
 	0x01, 0x00,                /* version = 1 */
 	0x00, 0x00,                /* flags = 0 */
-	0x50, 0x00, 0x00, 0x00,    /* header_len = 80 */
-	0x50, 0x00, 0x00, 0x00,    /* total_len = 80 */
+	0x54, 0x00, 0x00, 0x00,    /* header_len = 84 */
+	0x54, 0x00, 0x00, 0x00,    /* total_len = 84 */
 	/* 32 bytes model_hash (zeros) */
 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
@@ -37,8 +37,8 @@ ZTEST(ARBITER_blob, test_null_params)
 {
 	struct ARBITER_model model;
 
-	zassert_equal(ARBITER_blob_load(NULL, 80, &model), ARBITER_EINVAL);
-	zassert_equal(ARBITER_blob_load(valid_blob, 80, NULL), ARBITER_EINVAL);
+	zassert_equal(ARBITER_blob_load(NULL, sizeof(valid_blob), &model), ARBITER_EINVAL);
+	zassert_equal(ARBITER_blob_load(valid_blob, sizeof(valid_blob), NULL), ARBITER_EINVAL);
 }
 
 ZTEST(ARBITER_blob, test_truncated)
@@ -50,7 +50,7 @@ ZTEST(ARBITER_blob, test_truncated)
 
 ZTEST(ARBITER_blob, test_bad_magic)
 {
-	uint8_t bad[80];
+	uint8_t bad[84];
 
 	memcpy(bad, valid_blob, sizeof(bad));
 	bad[0] = 'X';
@@ -62,7 +62,7 @@ ZTEST(ARBITER_blob, test_bad_magic)
 
 ZTEST(ARBITER_blob, test_bad_version)
 {
-	uint8_t bad[80];
+	uint8_t bad[84];
 
 	memcpy(bad, valid_blob, sizeof(bad));
 	bad[4] = 99; /* invalid version */

tests/unit/test_arbiter_determinism/src/main.c

@@ -24,7 +24,7 @@
 #include <string.h>
 
 /* Use a minimal inline model for self-contained testing */
-static const struct arbiter_fact_def test_facts[] = {
+static const struct ARBITER_fact_def test_facts[] = {
 	{ .id = 0, .type = ARBITER_FACT_INT32, .range_min = -1000,
 	  .range_max = 1000, .default_value = 0, .stale_after_ms = 0,
 	  .safety_relevant = true, .name = "input" },
@@ -36,26 +36,26 @@ static const struct arbiter_fact_def test_facts[] = {
 	  .safety_relevant = false, .name = "enable" },
 };
 
-static const struct arbiter_condition_def test_conditions[] = {
+static const struct ARBITER_condition_def test_conditions[] = {
 	{ .fact_id = 2, .op = ARBITER_OP_EQ, .value = 1,
 	  .group = ARBITER_COND_ALL, .group_index = 0, .next = UINT16_MAX },
 };
 
-static const struct arbiter_expr_def test_expressions[] = {
+static const struct ARBITER_expr_def test_expressions[] = {
 	/* output = input * 3 */
 	{ .target_fact_id = 1, .op = ARBITER_EXPR_SCALE,
 	  .left_fact_id = 0, .left_literal = 0,
 	  .right_fact_id = UINT16_MAX, .right_literal = 3,
 	  .scale = 1 },
 };
 
-static const struct arbiter_action_def test_actions[] = {
+static const struct ARBITER_action_def test_actions[] = {
 	{ .id = 0, .type = ARBITER_ACTION_CALLBACK, .target_fact_id = 0,
 	  .target_value = 0, .callback = NULL, .must_complete_within_ms = 0,
 	  .safe_state_action = false, .name = "noop" },
 };
 
-static const struct arbiter_rule_def test_rules[] = {
+static const struct ARBITER_rule_def test_rules[] = {
 	{ .id = 0, .rule_class = ARBITER_RULE_INFERENCE,
 	  .condition_start = 0, .condition_count = 1,
 	  .action_start = 0, .action_count = 0,
@@ -67,7 +67,7 @@ static const struct arbiter_rule_def test_rules[] = {
 
 static const char *test_mode_names[] = { "normal" };
 
-static const struct arbiter_model test_model = {
+static const struct ARBITER_model test_model = {
 	.name = "determinism_test",
 	.model_hash = {0},
 	.schema_hash = {0},
@@ -93,22 +93,22 @@ static const struct arbiter_model test_model = {
 
 ZTEST(determinism, test_repeat_eval_identical)
 {
-	struct arbiter_ctx ctx;
-	struct arbiter_snapshot snap_ref, snap_cur;
-	struct arbiter_result result_ref, result_cur;
+	struct ARBITER_ctx ctx;
+	struct ARBITER_snapshot snap_ref, snap_cur;
+	struct ARBITER_result result_ref, result_cur;
 
-	arbiter_init(&ctx, &test_model);
-	arbiter_set_bool(&ctx, 2, true);
-	arbiter_set_i32(&ctx, 0, 42);
+	ARBITER_init(&ctx, &test_model);
+	ARBITER_set_bool(&ctx, 2, true);
+	ARBITER_set_i32(&ctx, 0, 42);
 
 	/* Reference run */
-	arbiter_snapshot_begin(&ctx, &snap_ref);
-	arbiter_eval(&test_model, &snap_ref, &result_ref, NULL);
+	ARBITER_snapshot_begin(&ctx, &snap_ref);
+	ARBITER_eval(&test_model, &snap_ref, &result_ref, NULL);
 
 	/* Repeat N times and compare */
 	for (int i = 0; i < REPEAT_COUNT; i++) {
-		arbiter_snapshot_begin(&ctx, &snap_cur);
-		arbiter_eval(&test_model, &snap_cur, &result_cur, NULL);
+		ARBITER_snapshot_begin(&ctx, &snap_cur);
+		ARBITER_eval(&test_model, &snap_cur, &result_cur, NULL);
 
 		/* Byte-identical snapshot values */
 		zassert_mem_equal(
@@ -117,10 +117,11 @@ ZTEST(determinism, test_repeat_eval_identical)
 			"Snapshot diverged on iteration %d", i);
 
 		/* Identical result */
-		zassert_equal(result_ref.mode, result_cur.mode,
+		zassert_equal(result_ref.current_mode, result_cur.current_mode,
 			      "Mode diverged on iteration %d", i);
-		zassert_equal(result_ref.fired_count, result_cur.fired_count,
-			      "Fired count diverged on iteration %d", i);
+		zassert_equal(result_ref.requested_action_count,
+			      result_cur.requested_action_count,
+			      "Action count diverged on iteration %d", i);
 	}
 }
 
@@ -130,29 +131,30 @@ ZTEST(determinism, test_repeat_eval_identical)
 
 ZTEST(determinism, test_fact_order_independence)
 {
-	struct arbiter_ctx ctx_a, ctx_b;
-	struct arbiter_snapshot snap_a, snap_b;
-	struct arbiter_result res_a, res_b;
+	struct ARBITER_ctx ctx_a, ctx_b;
+	struct ARBITER_snapshot snap_a, snap_b;
+	struct ARBITER_result res_a, res_b;
 
 	/* Context A: set input first, then enable */
-	arbiter_init(&ctx_a, &test_model);
-	arbiter_set_i32(&ctx_a, 0, 100);
-	arbiter_set_bool(&ctx_a, 2, true);
-	arbiter_snapshot_begin(&ctx_a, &snap_a);
-	arbiter_eval(&test_model, &snap_a, &res_a, NULL);
+	ARBITER_init(&ctx_a, &test_model);
+	ARBITER_set_i32(&ctx_a, 0, 100);
+	ARBITER_set_bool(&ctx_a, 2, true);
+	ARBITER_snapshot_begin(&ctx_a, &snap_a);
+	ARBITER_eval(&test_model, &snap_a, &res_a, NULL);
 
 	/* Context B: set enable first, then input */
-	arbiter_init(&ctx_b, &test_model);
-	arbiter_set_bool(&ctx_b, 2, true);
-	arbiter_set_i32(&ctx_b, 0, 100);
-	arbiter_snapshot_begin(&ctx_b, &snap_b);
-	arbiter_eval(&test_model, &snap_b, &res_b, NULL);
+	ARBITER_init(&ctx_b, &test_model);
+	ARBITER_set_bool(&ctx_b, 2, true);
+	ARBITER_set_i32(&ctx_b, 0, 100);
+	ARBITER_snapshot_begin(&ctx_b, &snap_b);
+	ARBITER_eval(&test_model, &snap_b, &res_b, NULL);
 
 	/* Must be identical */
 	zassert_equal(ctx_a.fact_values[1].value, ctx_b.fact_values[1].value,
 		      "Output differs: order A=%d, order B=%d",
 		      ctx_a.fact_values[1].value, ctx_b.fact_values[1].value);
-	zassert_equal(res_a.mode, res_b.mode, "Mode differs by write order");
+	zassert_equal(res_a.current_mode, res_b.current_mode,
+		      "Mode differs by write order");
 }
 
 /* ------------------------------------------------------------------ */
@@ -161,21 +163,21 @@ ZTEST(determinism, test_fact_order_independence)
 
 ZTEST(determinism, test_cross_seed_consistency)
 {
-	struct arbiter_ctx ctx;
-	struct arbiter_snapshot snap;
-	struct arbiter_result result;
+	struct ARBITER_ctx ctx;
+	struct ARBITER_snapshot snap;
+	struct ARBITER_result result;
 
 	/* Test 100 different input values, each repeated 100 times */
 	for (int32_t input = -50; input < 50; input++) {
 		int32_t reference_output = 0;
 
 		for (int rep = 0; rep < 100; rep++) {
-			arbiter_init(&ctx, &test_model);
-			arbiter_set_bool(&ctx, 2, true);
-			arbiter_set_i32(&ctx, 0, input);
+			ARBITER_init(&ctx, &test_model);
+			ARBITER_set_bool(&ctx, 2, true);
+			ARBITER_set_i32(&ctx, 0, input);
 
-			arbiter_snapshot_begin(&ctx, &snap);
-			arbiter_eval(&test_model, &snap, &result, NULL);
+			ARBITER_snapshot_begin(&ctx, &snap);
+			ARBITER_eval(&test_model, &snap, &result, NULL);
 
 			int32_t output = ctx.fact_values[1].value;
 
@@ -205,16 +207,16 @@ ZTEST(determinism, test_reinit_determinism)
 	int32_t results[100];
 
 	for (int i = 0; i < 100; i++) {
-		struct arbiter_ctx ctx;
-		struct arbiter_snapshot snap;
-		struct arbiter_result result;
+		struct ARBITER_ctx ctx;
+		struct ARBITER_snapshot snap;
+		struct ARBITER_result result;
 
-		arbiter_init(&ctx, &test_model);
-		arbiter_set_bool(&ctx, 2, true);
-		arbiter_set_i32(&ctx, 0, 777);
+		ARBITER_init(&ctx, &test_model);
+		ARBITER_set_bool(&ctx, 2, true);
+		ARBITER_set_i32(&ctx, 0, 777);
 
-		arbiter_snapshot_begin(&ctx, &snap);
-		arbiter_eval(&test_model, &snap, &result, NULL);
+		ARBITER_snapshot_begin(&ctx, &snap);
+		ARBITER_eval(&test_model, &snap, &result, NULL);
 
 		results[i] = ctx.fact_values[1].value;
 	}