fix(affinescript-deno-test): document codegen-bug resolution + regression tests

Complements upstream affinescript codegen fix (nextgen-languages/
affinescript 35c476d). Adds a 4-test regression file exercising:
  - enum-in-match returning zero-arity + arg constructors across arms
  - struct field reads through function parameters
  - struct field reads on let-bound function-call results

The smoke-test suite now runs 7/7 green (was 4/4) and the sibling
double-track-browser extension_lifecycle_test.affine pilot reaches
10/10 without the tagged-struct workaround.

README.adoc is updated to flip the "known codegen bugs" section to
RESOLVED with root-cause + fix summary retained for history.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: hyperpolymath

affinescript-ecosystem/affinescript-deno-test/README.adoc

@@ -116,8 +116,9 @@ deno run --allow-read --allow-run --allow-env cli.ts ./tests
 [[constraints]]
 == Constraints and planned follow-ups
 
-One constraint was resolved same-day. Two remain, both resolvable with
-small upstream changes.
+Two constraints were resolved same-day (one for v0.2.0, plus the
+three codegen bugs below). Two remain, both resolvable with small
+upstream changes.
 
 === RESOLVED (v0.2.0): one test per file
 
@@ -157,26 +158,36 @@ return is unmarshalled by hand (AffineScript compiles `Bool` → i32, 0/1).
 Record<string, Record<string, ImportValue>>` option, then unify both paths
 behind `AffineModule`.
 
-=== Known AffineScript codegen bugs blocking richer test idioms
-
-Discovered 2026-04-19 while writing the double-track-browser lifecycle
-test pilot. Both are compiler bugs, not harness bugs — fixing them is
-upstream OCaml work on `developer-ecosystem/nextgen-languages/affinescript/
-lib/codegen.ml`.
-
-* **Enum-in-match codegen**: a `match` on an enum that returns distinct
-  zero-arity constructors across arms produces invalid WASM (stack
-  imbalance). The ideal form `match s { Uninitialised => Initialised(),
-  ... }` must currently be downgraded to a tagged struct.
-* **Parameter struct-field reads**: `s.field_1_or_later` where `s` is a
-  function parameter of struct type returns 0 regardless of the actual
-  value. First-field reads (`s.tag`) work. Workaround: pass scalars
-  instead of structs when possible, or read fields from let-bound locals
-  before calling into helpers.
-
-Scaling the harness to richer application-state test suites is gated
-on both. Estate-wide tracking in
-`~/Desktop/AI-WORK-todo.md` §11.
+=== RESOLVED (2026-04-19): codegen bugs blocking richer test idioms
+
+Both bugs discovered while writing the double-track-browser lifecycle
+test pilot were fixed upstream in `developer-ecosystem/nextgen-languages/
+affinescript/lib/codegen.ml` the same day. Regression coverage lives in
+`example/codegen_regression_test.affine` and the full
+double-track-browser `extension_lifecycle_test.affine` (10/10 green).
+
+* **Enum-in-match stack imbalance** — `PatCon`-with-args pushed the
+  tag-test boolean onto the stack twice (`LocalTee` + a trailing
+  `LocalGet` on the match-result local), so any arm body that produced
+  an i32 blew up WASM validation with "expected 1 elements on the stack
+  for fallthru, found 2". Fixed by removing the save/restore pair; the
+  field-binding code between them is stack-neutral by construction.
+* **Bare zero-arity variant as an expression** — `Initialised` (no
+  parens) fell through to the `ExprVar` lookup and failed with
+  `UnboundVariable` unless written as `State::Initialised`. Fixed by
+  falling back to `ctx.variant_tags` when `lookup_local` misses, mirroring
+  the existing `ExprCall`-with-variant-tag branch.
+* **Non-first struct-field read from parameter/call-result** — the
+  per-variable `field_layouts` map was only populated for let-bound
+  `ExprRecord` literals, so every other binding path defaulted offsets
+  to 0 and `.field_1_or_later` read the tag byte. Fixed by registering
+  struct layouts globally from `TopType(TyStruct)` and propagating them
+  to (a) function parameters via `p_ty`, (b) call-result lets via a new
+  `fn_ret_structs` map, (c) let-bindings with an explicit type
+  annotation, and (d) let-bindings whose RHS is another tracked variable.
+
+The harness now supports idiomatic enum-plus-match application-state
+test suites without fallback tagged-struct workarounds.
 
 == Why AffineScript rather than ReScript?
 

affinescript-ecosystem/affinescript-deno-test/example/codegen_regression_test.affine

@@ -0,0 +1,74 @@
+// SPDX-License-Identifier: PMPL-1.0-or-later
+// Regression tests for the two AffineScript codegen bugs discovered
+// 2026-04-19 and fixed in lib/codegen.ml on the same day:
+//
+//   1. Enum-in-match stack imbalance — PatCon-with-args left the tag-test
+//      boolean on the stack twice, so any match arm whose body produced an
+//      i32 value broke WASM validation with "expected 1 elements on the
+//      stack for fallthru, found 2". Fixed by removing the redundant
+//      LocalTee/LocalGet around the match_result local.
+//
+//   2. Non-first struct field read from a function parameter returned 0.
+//      field_layouts was only populated for let-bound ExprRecord literals,
+//      so every other binding path defaulted the offset to 0. Fixed by
+//      registering struct layouts globally from TopType(TyStruct) and
+//      propagating them to function parameters (via p_ty), call-result
+//      lets (via fn_ret_structs), and let-annotated bindings.
+
+enum Lifecycle {
+  LUninit,
+  LInit,
+  LWithProfile(Int),
+  LRunning(Int, Int),
+  LTerminated
+}
+
+struct Counters {
+  tag: Int,
+  profile_id: Int,
+  activity_count: Int
+}
+
+fn advance(s: Lifecycle) -> Lifecycle {
+  return match s {
+    LUninit          => LInit(),
+    LInit            => LWithProfile(0),
+    LWithProfile(p)  => LRunning(p, 0),
+    LRunning(p, c)   => LRunning(p, c + 1),
+    LTerminated      => LTerminated()
+  };
+}
+
+fn make_counters() -> Counters {
+  { tag: 1, profile_id: 42, activity_count: 7 }
+}
+
+fn read_profile_id(c: Counters) -> Int {
+  c.profile_id
+}
+
+fn read_activity_count(c: Counters) -> Int {
+  c.activity_count
+}
+
+pub fn test_enum_match_mixed_constructors() -> Bool {
+  // Previously: "expected 1 elements on the stack" during instantiate.
+  let s0 = LUninit();
+  let s1 = advance(s0);
+  return true;
+}
+
+pub fn test_param_struct_field_offsets() -> Bool {
+  // Previously: both helpers returned 0 because field_layouts defaulted
+  // the offset. Now the declared `c: Counters` annotation pulls in the
+  // struct's layout, so each field reads the right memory slot.
+  let c = make_counters();
+  return read_profile_id(c) == 42 && read_activity_count(c) == 7;
+}
+
+pub fn test_let_from_call_struct_field() -> Bool {
+  // Previously: `let c = make_counters()` did not register a layout
+  // because RHS wasn't a record literal. Now fn_ret_structs kicks in.
+  let c = make_counters();
+  return c.activity_count == 7;
+}