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

Inline comments:
In `@vera/wasm/calls_arrays.py`:
- Around line 467-475: The slice bounds are being narrowed with i32.wrap_i64
before clamping, allowing large positive i64 indices to wrap to negative i32
values; change the code that builds start_instrs/end_instrs so you perform the
bounds checks and clamp values while still i64 (compare to 0 and to the array
length as i64, compute min/max to clamp to [0,len] in i64), and only after
clamping emit i32.wrap_i64 and local.set {s} / local.set {e}; apply the same fix
for the other occurrence around the block handling lines 477-504 so all bounds
are clamped in i64 prior to narrowing to i32.

In `@vera/wasm/calls_containers.py`:
- Around line 136-160: The current fallback in _map_wasm_tag routes every
non-primitive/non-String type to the opaque-handle tag "b", but Array<T>
actually lowers to an i32_pair and must not be folded into 'b' (this breaks
map_insert/map_values for Map<K, Array<T>>). Update _map_wasm_tag to detect
Array types (e.g. type strings like "Array<...>") and explicitly reject them by
raising an error (TypeError or ValueError) with a clear message that Map values
may only be primitives or String for now; leave String -> "s" and primitives ->
"i"/"f" unchanged. Also ensure _map_wasm_types remains consistent (the "s" tag
returns ["i32","i32"]; the opaque 'b' still returns ["i32"]) so imported names
and translate_expr expectations stay aligned.

In `@vera/wasm/calls_encoding.py`:
- Around line 1426-1440: url_parse currently discards the local has_auth and
delimiter presence info that url_join needs to reconstruct URLs exactly; modify
url_parse to preserve authority and delimiter state (e.g., add a boolean flag
like scheme_has_authority derived from has_auth and separate flags for
query_delimiter_present and fragment_delimiter_present) instead of only
computing auth_start from colon_pos/has_auth, and populate those flags wherever
has_auth/colon_pos/auth_start are used (including the blocks around has_auth,
colon_pos, auth_start). Then update url_join to consult scheme_has_authority
when emitting the scheme separator (emit "://" only when true, otherwise ":"),
and use the query_delimiter_present and fragment_delimiter_present flags to
decide whether to emit "?" or "#" for empty vs absent query/fragment, ensuring
round-trip preservation; apply the same changes consistently where similar logic
appears.
- Around line 391-423: The decoding currently only counts trailing '=' into
local pad but still treats '=' as value 0 in the main decode loop; change the
decoder so any '=' found outside the canonical trailing padding positions causes
an error: after computing pad (locals pad, ptr, slen) ensure the main loop only
processes bytes at indices < slen - pad, and add an explicit check in the main
loop that if the loaded byte equals 61 ('=') and the current index >= (slen -
pad) allow it only as part of trailing padding, otherwise return Err; update
references to local variables pad, ptr, slen and the main loop that maps input
bytes to values to enforce this validation (also apply the same fix for the
similar block around lines 553-561).

In `@vera/wasm/calls_handlers.py`:
- Around line 302-307: The catch-arm result type inference only checks
expr.clauses[0].body when it's an ast.Block and ignores expression-bodied
handlers, which leaves result_wt None and omits the (result ...) in generated
WAT; update the logic so that when clause_body exists but is not an ast.Block
you still infer its result type (call the appropriate expression inference
helper or infer from the expression node instead of only using
_infer_block_result_type), assign that to result_wt (falling back to inferring
from expr.body if still None), and apply the same change to the other occurrence
with the same pattern (the block around the second instance at 347-352) so
non-block handler arms produce the correct (result ...) in the emitted
block/try_table.

In `@vera/wasm/calls_parsing.py`:
- Around line 80-90: The current loop that skips space (byte 32) uses local.get
{byte} and always branches back (br $lp_pn), which allows embedded spaces to be
ignored; update the parse_nat and parse_int generation to only skip spaces while
parsing has not started by introducing or using a "started" local (or check that
index/local {idx} equals its initial value) and change the space-handling block
so it only branches (br $lp_pn) when started==0 (i.e., before any digit/sign has
been consumed); ensure the same change is applied to the other occurrence around
lines 301-311 so embedded spaces like "12 34" or "- 5" are rejected after
parsing starts.

In `@vera/wasm/calls_strings.py`:
- Around line 435-447: The to_string routine incorrectly negates INT64_MIN
causing overflow and emitting no digits; update the code in the to_string path
(around the negation/negative-check where locals is_neg and val are used) to
detect the INT64_MIN constant (-9223372036854775808) and handle it specially by
either (a) writing the known string/digits for INT64_MIN, or (b) converting to
an unsigned magnitude before digit extraction (cast val to u64 then take
magnitude without signed negation) so digit loop sees the correct positive
magnitude; adjust the branches around the i64.lt_s/negation block (the code that
sets is_neg/local.set {val}) to implement this INT64_MIN branch or
unsigned-magnitude conversion and ensure the rest of the digit-emission logic
consumes the unsigned magnitude.
- Around line 811-823: The fractional rounding can produce 1_000_000 and drop
the carry (so 1.9999995 becomes 1.0); after computing the rounded fractional
value stored in frac_val, detect if it equals 1_000_000 and if so set frac_val
to 0 and increment the integer part (the fval floor/local holding the integer)
accordingly; update the instruction sequence around the lines that compute and
set frac_val (references: local.get {fval}, i64.trunc_f64_s, local.set
{frac_val}) to perform this check and adjust the integer part before emitting
the six-digit loop so the carry is preserved.
- Around line 181-201: Before calling $alloc or doing i32.wrap_i64, validate the
slice bounds using the original i64 values and len_s: ensure start and end are
non-negative, cap them to len_s (or return/reject if out-of-range), and ensure
end >= start; only after clamping/validation perform i32.wrap_i64, compute
new_len (end - start), then call $alloc and gc_shadow_push(dst). Update the
block that sets locals start, end, new_len and the subsequent allocation (the
locals named start, end, new_len, dst and the call $alloc / gc_shadow_push
calls) to do this pre-check/clamp and to bail out or normalize lengths before
allocation and copying.
- Around line 250-253: The code uses idx (allocated local "i32") converted from
the Python index and then performs i32.load8_u without bounds checks; update the
char_code implementation to validate idx is within [0, len_s) and non-negative
before the load: after computing/setting idx and before the i32.load8_u call,
insert checks comparing idx against len_s and branch to trap or return a defined
error/value if out of range (use the existing ptr_s, len_s, idx locals and the
function's failure/trap path). Apply the same range-check pattern to the
analogous block referenced at lines 262-273 so all loads from the string buffer
validate 0 <= idx < len_s before calling i32.load8_u.