AsyncLocalStorage: enterWith / exit aren't implemented — listener never runs

[proggeramlug]

Summary

AsyncLocalStorage.enterWith(...) and AsyncLocalStorage.exit(...) silently no-op; the test that exercises them crashes / exits mid-output:

```
Node: …7 trailing lines covering enterWith + exit semantics
Perry: stops after 'outer post: outer' (line 10) — never reaches enterWith/exit assertions
```

Repro

```
./target/release/perry test-files/test_async_local_storage_context.ts
```

Node output (last 7 lines) is what Perry is missing:

```
enterWith store: entered
exit clears primary: undefined
exit keeps other: other-mutated
exit restores primary: exit-outer
exit preserves other mutation: other-mutated
primary store: primary
secondary store: secondary
```

Suspected root cause

als.enterWith({...}) reaches a not-implemented codepath that exits the process / Promise without producing further console.log output.

This is sibling work to #788 / #789 (AsyncLocalStorage tracking across await/microtasks/timers + real async_hooks.createHook), and likely fixed as part of those tracker issues. Treat this issue as the narrow .enterWith / .exit slice and link it back to #788 once that lands.

Disposition for v0.5.1025

test_async_local_storage_context skip-listed in test-parity/known_failures.json under category bug-open with this issue number. Flips to PASS when .enterWith / .exit semantics land.

[proggeramlug]

Investigation findings (triage)

The premise needs correcting: enterWith / exit / disable ARE implemented (crates/perry-stdlib/src/async_local_storage.rs, wired through the codegen native-table + crates/perry-runtime/src/async_context.rs) and work correctly in isolation. The real bug is a segfault under accumulation, not a missing feature.

What works (verified byte-identical to node --experimental-strip-types)

• The first 10 lines of the repro — run/getStore propagating across await / .then / .catch / process.nextTick / setTimeout / setImmediate / setInterval / nested run — match Node exactly.
• enterWith + await + getStore + disable in isolation → entered (matches Node).
• exit() isolation shape (als.exit(cb) with nested other.run + other.enterWith) in isolation → all four lines match Node.
• viaCatch (rejected promise) + later enterWith → works.
• nested + enterWithContext; 6 timer-based runs + enterWithContext → both work.

The actual bug

The full repro segfaults with EXC_BAD_ACCESS (code=1, address=0x30) right after outer post: outer, before enterWith store: entered. The crash is a null-pointer field read in generated code — als.getStore().trace where getStore() returns undefined at that point and .trace (offset 0x30) dereferences it. Two layered problems:

1. Context loss under accumulation: after the 7 prior run calls + nested(), als.getStore() inside enterWithContext returns undefined even though the isolated form returns the store. Smells like an async-scheduler context capture/restore ordering bug specific to the accumulated snapshot state — not GC: it reproduces with PERRY_GEN_GC=0 (full mark-sweep, no object movement), and async_context.rs already scans stores as GC roots.
2. Null-deref instead of TypeError: reading .trace off undefined segfaults rather than throwing TypeError: Cannot read properties of undefined.

When the getStore() result is guarded against undefined, the segfault disappears (but the await-chain then stops after nested() without running the remaining functions — a third thread to pull).

Not reproducible minimally

Every reduction I tried (T1–T5 above) passes; only the complete repro crashes, so it needs lldb/ASan on the full binary to localize the context-restore path. Releasing for deeper debugging — the title should be re-scoped from "enterWith/exit aren't implemented" to "AsyncLocalStorage: full-suite repro segfaults (getStore returns undefined under accumulation + null-deref)". Sibling to the #788 async-context epic.

[proggeramlug]

Investigated: enterWith and exit are actually implemented and work correctly (stdlib js_async_local_storage_enter_with/_exit + codegen dispatch rows + async_context::enter_with/take_store/restore_store all present and wired). Verified in isolation:

const als = new AsyncLocalStorage();
(async () => {
  als.enterWith({ trace: "entered" });
  await Promise.resolve();
  console.log("after await:", als.getStore().trace);  // -> "entered" ✓ (matches Node)
})();

The test_async_local_storage_context.ts failure is not an ALS bug. It produces lines 1–10 byte-identical to Node (await/then/catch/nextTick/timer/immediate/interval/nested all correct), then segfaults during the async resumption after nested() — before enterWithContext even starts. I bisected it to a generational-GC selective-evacuation bug that reproduces with plain async/await and no async_hooks at all:

• PERRY_GEN_GC=0 / PERRY_GEN_GC_EVACUATE=0 / PERRY_WRITE_BARRIERS=0 / PERRY_GC_FORCE_EVACUATE=1 all make it pass; only the default auto-policy (partial) evacuation crashes.

Filed as #1597 with a minimal repro + full bisection. This test flips to PASS once #1597 lands (the enterWith/exit semantics it's waiting on already work). Removing inprogress — the remaining work is the GC fix in #1597, not ALS.