Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@scripts/check_skill_examples.py`:
- Around line 114-120: The ALLOWLIST dict has duplicate key 1326 so the second
entry ("Wrong: if/else without braces (bare expression)") silently overwrites
the first ("Wrong: non-exhaustive match (missing arm)"); locate the ALLOWLIST in
scripts/check_skill_examples.py and correct one of the numeric keys (either
change the second 1326 to the actual fence line number in SKILL.md for the
if/else fragment or change the first 1326 to the correct fence line for the
non-exhaustive match) so each entry (e.g., the entries labeled "Wrong:
non-exhaustive match (missing arm)" and "Wrong: if/else without braces (bare
expression)") has a unique key matching its fence line in SKILL.md.

In `@spec/09-standard-library.md`:
- Around line 256-259: The doc overstates Map support: update the Map section so
it matches the current ABI instead of claiming "Values may be any type" —
specify that keys require Eq and Hash and are limited to the presently
marshalled primitives (i64/Int/Nat mapping to i64, f64/Float64, String) and that
map entries in the ABI are marshalled as single i32 handles for opaque/value
shapes; change the sentence about values to state that values must be types
supported by the host marshalling (primitive f64/i64/String or single-i32
handle) and keep the note that Map is opaque and that map_insert and map_remove
are pure functional operations (retain those symbols Map<K,V>, Eq, Hash,
map_insert, map_remove to locate the text).
- Around line 260-275: Add a small, valid vera example demonstrating Map usage
so CI can parse it: include a vera block that defines a function (e.g.,
map_demo) that calls map_new(), uses map_insert(...) to add a key ("answer", 42)
and then uses map_get(...) to retrieve it, returning the Some branch value (or 0
on None); reference the builtins map_new, map_insert, and map_get in that
example and ensure the function signature and match arms use the correct
`@Map`<String, Int>, `@Int` and Some/None patterns so the snippet is syntactically
valid for the parser.

In `@vera/codegen/api.py`:
- Around line 1064-1069: The helper _define_map_values is registering imports
with the wrong name suffix ('map_values$k{vt}') while the dispatched ops and
browser runtime expect 'map_values$v{vt}'; update the registration name in
_define_map_values to use 'v' (i.e., f"map_values$v{vt}") so Wasmtime defines
the symbol the module imports, and apply the same fix to the other identical
helper block (the second occurrence around the other define helper) to ensure
both registrations use the 'v' spelling.

In `@vera/wasm/calls.py`:
- Around line 7263-7288: _map_wasm_tag currently only treats "String" as a
two-word ABI and falls through Arrays to "b", causing mismatched import
signatures for map_insert/map_get/map_values when translate_expr pushes
(ptr,len). Modify _map_wasm_tag to detect Array types (e.g. string forms like
"Array<...>" or whatever Array syntax your type strings use) and return the "s"
tag for them (so _map_wasm_types will emit ["i32","i32"]) ensuring the WASM
import signature matches translate_expr's (ptr,len) ABI used by
map_insert/map_get/map_values.

---

Outside diff comments:
In `@vera/checker/resolution.py`:
- Around line 163-173: The conversion of forall_vars to a set (forall_set =
set(forall_vars)) is fine for O(1) membership checks, but the iteration uses
zip(param_types, arg_types) without strict checking; update _infer_type_args to
guard against mismatched lengths by either using zip(..., strict=True) or
asserting len(param_types) == len(arg_types) before the loop, and keep the
existing behavior of skipping None/UnknownType arg_types and calling
_unify_for_inference(param_ty, arg_ty, mapping, forall_set).

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@scripts/check_spec_examples.py`:
- Around line 180-186: The spec index contains duplicate entries and incorrect
line numbers for several string signatures; remove redundant duplicates so each
signature appears only once and correct their line numbers to match the actual
spec: update the entries for string_upper and string_lower to distinct, correct
line numbers (they were mistakenly duplicated), ensure string_replace,
string_split, string_join, string_from_char_code, and string_repeat each have a
single unique, correct line number (remove the duplicate set from the "main
list" or "String transformation" section), and also delete the duplicate
infinity entry mentioned (keep only the correct one); locate and edit the
mapping that contains keys like "string_upper", "string_lower",
"string_replace", "string_split", "string_join", "string_from_char_code",
"string_repeat" to perform these removals/line-number corrections.

In `@tests/test_checker.py`:
- Around line 1526-1601: The test class TestMapCollection is missing negative
and inference tests: add one test (e.g., test_map_wrong_types) that calls
map_insert with a key/value type mismatch and asserts a type error via
_check_err (look for messages like "mismatched" or "expects"), and add another
test (e.g., test_map_infer_map_new) that uses a bare map_new() in a context
expecting `@Map`<K,V> (use let `@Map`<String, Nat> = map_new() or an expression like
map_size(map_new()) with an expected Map type) and assert it type-checks via
_check_ok; place these new tests inside the TestMapCollection class alongside
the existing test_map_wrong_arity, referencing the same helper functions
(_check_ok/_check_err) so the checker exercises wrong-type path and zero-arg
map_new() inference.

In `@tests/test_codegen.py`:
- Around line 7616-7747: Add three tests to TestMapCollection to cover empty-map
edge cases and typed-context inference: (1) add test_map_keys_empty that asserts
array_length(map_keys(map_new())) == 0 to verify map_keys on an empty map
returns an empty array; (2) add test_map_values_empty that asserts
array_length(map_values(map_new())) == 0 to verify map_values on an empty map
returns an empty array; and (3) add test_map_new_inference that forces
type-inference for a bare map_new (e.g. by binding let `@Map`<String, Nat> =
map_new() or using map_get/map_insert on map_new()) and asserts expected
behavior (size 0 or map_keys length 0) to cover the typed-context path; place
these new tests alongside the existing TestMapCollection methods (see map_keys,
map_values, map_new references) so they run with the other map built-in tests.

In `@vera/codegen/api.py`:
- Around line 869-874: The mapping and codegen treat the "s" suffix as a generic
two-i32 pair but the vt == "s" branches always assume String by calling
_read_wasm_string, _alloc_option_some_string, and _alloc_array_of_strings; to
fix, either propagate the concrete pair-ABI type through the import/type name
(e.g., extend _VAL_WASM_TYPES and the import/type encoding to include the inner
concrete type for "s" so codegen uses the appropriate pair-ABI readers/writers),
or explicitly reject non-String usages of "s" during codegen (raise an error
when encountering vt == "s" for types other than String in functions that
generate insert/get/values code such as the code paths touched around
_VAL_WASM_TYPES, the vt=="s" branches, and callers of
_read_wasm_string/_alloc_option_some_string/_alloc_array_of_strings); update the
affected sections (including the similar blocks around lines referenced) to use
one consistent approach.
- Around line 754-761: The _map_store/_map_next_handle allocation never reclaims
handles causing unbounded growth; add a _map_free function and a reusable
free-handle pool so _map_alloc reuses freed handles instead of always
incrementing _map_next_handle, and ensure map_remove (and map_new/map_insert
where items are removed or maps become empty) calls _map_free when a map is no
longer reachable (e.g., when its dict is emptied or when host releases a handle
during execute()). Update all places that drop a handle to call _map_free and/or
push the handle onto the free list so entries in _map_store are deleted (or set
None) and memory is reclaimed; reference symbols: _map_store, _map_next_handle,
_map_alloc, _map_free (new), map_new, map_insert, map_remove, and execute().
- Around line 826-836: The map currently stores ADT pointers as raw i32 payloads
(e.g., via _alloc_array_of_i32 and callers that call _map_store), which lets the
mark-sweep collector free those objects and produce dangling pointers on
subsequent map_get/map_values; fix by either (A) ensuring any heap-backed ADT
pointer placed into an i32 bucket is owned/pinned by making a deep copy into
WASM-managed memory and storing that owned pointer (allocate with _call_alloc
and write the ADT bytes before storing), or (B) restrict the 'b' (i32) cases to
only non-pointer scalar types and refuse/store differently for ADTs; update
_alloc_array_of_i32, the call sites that populate i32 arrays, and
_map_store/_map_get/_map_values to implement the chosen strategy so the GC
cannot collect referenced ADTs prematurely.

In `@vera/wasm/calls.py`:
- Around line 7274-7277: The conditional that treats any type name beginning
with "Array" as the actual Array type is too broad; restrict the pair-ABI check
to only the real Array type by changing the predicate that uses
vera_type.startswith("Array") to an equality check vera_type == "Array" (keep
the existing checks for "String" and the surrounding conditional), so the import
mangling logic that produces 's' only runs for the true Array type and not for
user types like ArrayList.

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@vera/wasm/calls.py`:
- Around line 7430-7435: The Map<...> fallback in the block that reads name =
expr.type_name and then uses split(", ", 1) is not nesting-aware and will break
on inner commas (e.g., Map<Result<Int, Bool>, String>); fix by replacing that
raw split with a depth-aware top-level-comma finder that walks the string and
splits at the comma where nesting depth is zero, or better yet use the parsed
TypeExpr data (e.g., expr.type_args or equivalent parsed fields) instead of
parsing expr.type_name raw string; update the same pattern used later (the
repeated code around the other Map fallback) to the same depth-aware or
parsed-data approach.

---

Outside diff comments:
In `@TESTING.md`:
- Line 80: Update the stale count in the conformance suite narrative: change the
numeric literal "56" to "57" in the sentence that reads "The conformance suite
is a collection of 56 small, focused programs in `tests/conformance/`..." so it
matches the documented suite size elsewhere in TESTING.md; ensure the sentence
now reads "57" and run a quick grep for the phrase "conformance suite" or
"tests/conformance/" to confirm no other mismatched counts remain.
- Line 148: The comment notes the inline test-count in TESTING.md ("# Via pytest
(parametrized — 280 tests)") is stale; update that header to match the current
count reported for test_conformance.py (285) or make the note generic. Edit the
header text in TESTING.md to replace "280 tests" with "285 tests" (or change to
a non-numeric phrase like "parametrized tests") so the markdown accurately
reflects test_conformance.py's test count.

---

Duplicate comments:
In `@scripts/check_spec_examples.py`:
- Around line 64-67: The ALLOWLIST dict in scripts/check_spec_examples.py
contains duplicate tuple keys (e.g. ("09-standard-library.md", 876) appears
twice) which causes silent shadowing and hides entries; open the ALLOWLIST
definition and remove or consolidate the duplicated tuple key so each (filename,
line) tuple appears only once, ensuring any associated value strings (e.g.
"FRAGMENT") are preserved or merged as appropriate; validate by scanning the
ALLOWLIST literal in the file (symbol: ALLOWLIST) and run the provided
duplicate-detection snippet or add a small runtime/assertion to fail fast if
duplicate tuple keys are present.

In `@tests/test_checker.py`:
- Around line 1526-1613: Add a negative type-check test in the TestMapCollection
class that mirrors test_map_insert_and_size but supplies a wrong value type to
map_insert so the checker rejects it; create a new test (e.g.,
test_map_insert_wrong_value_type) that calls _check_err with an expression using
map_insert(map_new(), "k", "not_a_nat") (or otherwise wrong V type) and assert
an appropriate type-mismatch error (use the same error substring style as
test_map_wrong_arity), referencing map_insert and map_new so both success and
wrong-type paths are covered.

In `@tests/test_codegen.py`:
- Around line 7616-7777: Add a new test method in the TestMapCollection class
that directly exercises the zero-arg generic inference path for map_new():
construct a bare map via "let `@Map`<SomeKey, SomeVal> = map_new()" (e.g.
`@Map`<String, Nat>), then call a built-in like map_size or map_keys/map_values or
map_get to verify correct runtime/codegen behavior (assert expected value, e.g.
size 0 or lookup returns None). Reference the existing test names and helpers
(TestMapCollection, map_new, map_size, map_keys, map_values, map_get) so the new
test mirrors the style of the other map tests and covers the bare map_new()
inference scenario.

In `@vera/wasm/calls.py`:
- Around line 7263-7277: The current mapping falls back to "b" when helpers
can't find map types by call-shape; update _infer_map_value_from_map_arg and
_infer_map_key_from_map_arg to recover Map<K,V> from the expression's inferred
type information (e.g. inspect the AST node's resolved/inferred type or type
annotation, and specifically handle map_new and user functions that return maps)
rather than only pattern-matching built-in call shapes, and change _map_wasm_tag
to not silently default to "b" when the key/value type is unknown — instead
propagate a clear error or None so callers (map_get, map_keys, map_values) can
fail fast and register the correct host import or raise a meaningful error;
ensure the same fix is applied to the other occurrences that call these helpers.