What

Delivers the concurrency half deferred when #59 shipped the <Async> language surface, and cuts release v0.0.192 — Stage A of the server-effects sprint (WASI.md records the Stage-0 groundwork this builds on).

async(Http.get(url)) / async(Http.post(url, body)) — with call-free argument expressions — now fuse into a single vera.async_http_get / vera.async_http_post host import that issues the request on a host ThreadPoolExecutor at the async(...) point (request issuance keeps program order) and returns the Future as a #578 bit-31-tagged handle wrapper (new wrap kind 4). await probes the value's first word for the wrapper tag: fused handles unwrap and block on vera.async_await; eager values pass through unchanged. Every other async shape keeps the eager identity lowering.

Two overlapping async(Http.get)s are pinned by a server-side request-ordering test (local ThreadingHTTPServer, the /a handler holds until /b arrives — no wall-clock assertions).

Design invariants

• One fusion predicate, two consumers. Import emission is decided by both the _scan_io_ops pre-scan and the WasmContext translation; if they disagree, a fused call site references an import the pre-scan suppressed (WAT compile error) or a sync import is declared that translation never calls. The predicates live in one new module — vera/wasm/async_fusion.py — imported by both, and mutation M5 (pre-scan intercept removed) proves the pin.
• Fusion ⊂ W002 whitelist, so the warning is never false. The fuse condition (direct Http.get/post call, call-free args) is strictly narrower than the checker's W002 commutative whitelist — a warned async can never execute concurrently, and an unwarned-but-eager one is spec-conformant (§9.5.4's MAY).
• Type-directed await discrimination. The handle-check keys on the literal type Future<Result<String, String>> — the only type fused futures inhabit, always a heap pointer, so the tag probe (0xFEEDC004 at offset 0) is memory-safe. Value-typed futures (Future<Int> is an i64) keep the identity lowering; a pure program emits zero task imports. Alias-typed slots fall back loudly (the wrapper tag matches no constructor → trap), never silently.
• Workers never touch guest memory. The pure fetch halves (fetch_get/fetch_post, split out of the Http host callbacks in vera/runtime/http.py) run on workers and return Python strings; the Result ADT is built at await time on the guest thread. The GC shadow-stack overflow in array_map (and sibling iterative builders) at ~4000 heap-allocating elements #570/html_parse and json_parse trap with Out-of-bounds memory access on inputs that pressure GC during host-side tree walk #692 UAF class cannot reach a worker.
• Full opaque-handle GC contract (Decimal pattern, kind 4): wrapper shadow-rooted at the async site — including the operand-stack window (both(async(A), async(B)), get/post-distinguished Err text making an aliased wrapper observable) — and Phase 2c fires host_decref_handle(4, handle) for unawaited futures (cancel + evict, observable via ExecuteResult.host_store_sizes["future"]).
• Ctrl-C + teardown. A KeyboardInterrupt during a blocked await rides the wasmtime>=45 BaseException trampoline to the centralized exit-130 handler (new e2e sibling of the IO.sleep/IO.read_char pins); the executor is torn down (shutdown(cancel_futures=True)) on every exit path via the invocation finally.
• Browser stays eager (spec-conformant): the request fires synchronously (XHR) at the async point; the (isOk, payload) strings are buffered host-side (a guest pointer held only in a JS map would be invisible to the conservative GC scan) and the ADT is built at await. New Node e2e test pins the fused-shape Err path.
• Future<T> return types now compile. Previously a function declaring a Future<T> return was silently [E605]-skipped; Future is now transparent in the type mapper (RED-first via the GC-registration test).

Mutation validation (8/8 kill)

(M7's first fixture survived the mutation — let-bound wrappers are rooted elsewhere — so the operand-stack fixture was added and confirmed RED under the mutation before keeping both.)

Docs

Spec §9.5.4 rewritten (implementation MAY evaluate concurrently when the effect row is commutative; the reference implementation's exact shape documented, alias limitation noted), §7.4 effect-ordering note, §12.9.3 browser-divergence row; SKILL.md async section rewritten with a fan-out example; vera/README.md module map (new async_fusion.py + async_http.py rows); TESTING.md tables + battery descriptions; #591 test anchors moved to the fetch halves.

Release v0.0.192

Version sync across 6 files; CHANGELOG section (the queued #420/#419/#839/#835 [Unreleased] split entries ride this release); HISTORY opens Stage 16: the server-effects sprint; doc counts 5,577.

Verification

• pytest tests/ — 5,529 passed, 22 skipped (incl. browser parity 108)
• pytest -m stress — 26 passed
• mypy vera/ clean; ruff check clean without --fix
• all scripts/check_*.py green (conformance 103, examples 35, doc-counts, version-sync, site-assets, encoding, diagnostic-fields, skill/spec/readme/faq/html examples, licenses, wheel gate, limitations sync, changelog gate)
• 8 mutations each kill their discriminating tests; restore green
• behavioral concurrency via server-side request ordering, never wall-clock

Closes #841

🤖 Generated with Claude Code

Summary by CodeRabbit

• New Features
  • async(Http.get/post(...)) now lowers to a fused concurrent path on the native runtime; await blocks for results, including browser support.
• Bug Fixes
  • Added W002 warning when async(...) must evaluate eagerly/serially outside the commutativity whitelist.
  • Improved interrupt and async error-path handling; hardened UTF-8 decoding/propagation for HTTP responses.
• Documentation
  • Updated spec and guidance to reflect v0.0.192 semantics; added WASI sprint record and refreshed project/test metrics.
• Tests
  • Expanded checker, codegen, GC-rooting, and cross-module fused-await coverage (including new browser parity).