[tannevaled]

Re-checked, as the section promises

What does not work yet carries a dated re-check line. This is that pass, on
fc8ca1a (darwin/arm64) against MRI 4.0.7 on the same host.

claim in the README	measured now
GOOS=js GOARCH=wasm does not build	go build ./cmd/rbgo exit 0; ./cmd/wasm exit 0
the browser target has no CI lane	ci.yml has wasm (js, browser), green on every PR
$stderr is not a separate stream	rbgo -e '$stdout.print "O"; $stderr.print "E"' → O on stdout, E on stderr; warn → stderr

The browser entry is the one worth pausing on. #684 fixed the build and
added the lane — the commit subject says so: "fix the js/wasm build, and make
the guard that caught it reachable". So this repository has been shipping a
green gate and a document saying that gate does not exist, in two places:
the limitation, and the Platforms section, whose table omitted the lane
entirely while the prose underneath said it had none.

A dated limitation going stale is ordinary, and the section says when it was
last checked. A limitation that a gate in the same tree disproves on every
push is not: the answer was here the whole time and nothing read it.

The guard

readme_wasm_lane_test.go fails when ci.yml builds GOOS=js GOARCH=wasm and
the README says it cannot, naming both. It is narrow deliberately — it does not
try to validate the whole section against reality, which would mean running the
world; it checks the one class of claim that files already in the repository can
settle. If the lane is ever removed on purpose, the test skips with a note
rather than passing silently.

Proved in both directions, with a check that the control actually modified the
file — and it caught the first draft of this very commit, which quoted the
old sentence back verbatim in the removal note. The note is now a paraphrase.

Two entries added, both measured, both fail-open

$ rbgo -e 'require "timeout"; Timeout.timeout(0.3) { sleep 2 }; puts "returned"'
returned                 # MRI 4.0.7: Timeout::Error after 0.3s

Timeout.timeout never times out. The module, Timeout::Error and the
rescue path all exist; only the enforcement is missing, and
internal/vm/timeout.go:11 says so plainly — it needs pre-emptive interruption
of a running block. Every shape measured: sleep, a busy loop, and a custom
exception class all run to completion. The block is also yielded nil where MRI
yields the limit.

It is written as a paragraph rather than a table row because of its shape:
Timeout.timeout is the ordinary Ruby way to bound work that might hang, and
here it returns successfully, so code that relies on it is unprotected and
nothing says so. Filed separately.

$ rbgo -e 't = Thread.new { loop { $n = ($n||0)+1; sleep 0.01 } }; sleep 0.05
          b = $n; `sleep 1`; puts($n > b ? "ran" : "frozen")'
frozen                   # MRI 4.0.7: ran

A backtick command holds the interpreter lock: every other Ruby Thread is
stopped for its duration. Kernel#sleep yields correctly, which is the control
that makes this specific to the subprocess path rather than a general scheduler
fault. Found by a new type-aware scanner and then confirmed dynamically; filed
separately with the full census.

🤖 Generated with Claude Code