docs(async): Allign docs and clean redaction.

Author: dylan-sutton-chavez

docs/pages/language/async.md

@@ -3,12 +3,12 @@ title: "Async"
 description: "Cooperative coroutines: run, sleep, frame, gather, with_timeout, cancel, receive."
 ---
 
-Cooperative concurrency via `async def` coroutines and `await` / `yield`. No preemption, a coroutine runs until it yields, sleeps, awaits, or returns. Single-threaded scheduler; concurrency by interleaving, not parallelism.
+Cooperative concurrency via `async def` coroutines and `await` / `yield`. No preemption: a coroutine runs until it yields, sleeps, awaits, or returns. Single-threaded scheduler; concurrency by interleaving, not parallelism.
 
-No `asyncio` module. Primitives, `run`, `sleep`, `frame`, `gather`, `with_timeout`, `cancel`, `receive`, are top-level builtins.
+No `asyncio` module. Primitives: `run`, `sleep`, `frame`, `gather`, `with_timeout`, `cancel`, `receive` — are top-level builtins.
 
 ```python
-import asyncio # ModuleNotFoundError: there is no asyncio
+import asyncio # ModuleNotFoundError: It was decided not to use asyncio and introduce the asynchrony within the virtual machine.
 ```
 
 ```python
@@ -28,7 +28,7 @@ ok
 
 A `def` body executes immediately. An `async def` body returns a coroutine value that does nothing until driven with `run` / `gather`. Only coroutines are cancellable (`cancel`) and can suspend on real time (`sleep`).
 
-A plain `def` inside a coroutine (or at module top-level) can still call yielding builtins (`sleep`, `receive`, deferred host calls), the scheduler snapshots the helper's frame, suspends the call chain, re-enters the helper on resume so its return value lands at the original call site. The module body runs as an implicit coroutine, so top-level statements suspend the same way. From the caller, a sync helper that internally sleeps is indistinguishable from one that doesn't.
+A plain `def` inside a coroutine (or at module top-level) can still call yielding builtins (`sleep`, `receive`, deferred host calls): the scheduler snapshots the helper's frame, suspends the call chain, and re-enters the helper on resume so its return value lands at the original call site. The module body runs as an implicit coroutine, so top-level statements suspend the same way. From the caller, a sync helper that internally sleeps is indistinguishable from one that doesn't.
 
 ```python
 def routine():
@@ -37,9 +37,9 @@ def routine():
 async def coro():
   return 1
 
-print(routine())   # 1
-print(coro())   # <coroutine> (does not run yet)
-print(run(coro()))   # 1 (run drives it to completion)
+print(routine()) # 1
+print(coro()) # <coroutine> (does not run yet)
+print(run(coro())) # 1 (run drives it to completion)
 ```
 
 ## Driving coroutines
@@ -61,7 +61,7 @@ print(run(square(5)))
 
 ## Sleeping
 
-`sleep(seconds)` suspends until `seconds` of wall time pass. Without a host time hook, a virtual clock advances logically, coroutines interleave deterministically with no real wait (useful for tests).
+`sleep(seconds)` suspends until `seconds` of wall time pass. Without a host time hook, a virtual clock advances logically; coroutines interleave deterministically with no real wait (useful for tests).
 
 ```python
 async def task(name):
@@ -95,7 +95,7 @@ print(gather(fetch("a", 0.05), fetch("b", 0.02), fetch("c", 0.03)))
 ['a!', 'b!', 'c!']
 ```
 
-The total wall time is `max(delays)`, not the sum, `b` and `c` overlap with `a`'s sleep.
+The total wall time is `max(delays)`, not the sum — `b` and `c` overlap with `a`'s sleep.
 
 ### Errors
 
@@ -154,11 +154,11 @@ except TimeoutError:
 timed out
 ```
 
-`with_timeout` evaluates the coroutine eagerly, it's a call, not an awaitable.
+`with_timeout` evaluates the coroutine eagerly — it's a call, not an awaitable.
 
 ## cancel
 
-`cancel(coro)` flags a registered coroutine for cancellation. On its next scheduler tick it transitions to `Cancelled` and stops. The body does not observe a `CancelledError`, cancellation is cooperative and silent.
+`cancel(coro)` flags a registered coroutine for cancellation. On its next scheduler tick it transitions to `Cancelled` and stops. The body does not observe a `CancelledError`; cancellation is cooperative and silent.
 
 A coroutine in a tight synchronous loop without `await`/`sleep` cannot be cancelled until it yields:
 
@@ -184,8 +184,8 @@ Both live in the built-in exception namespace and match `except` clauses normall
 
 * **No preemption**, `while True: pass` inside a coroutine blocks the scheduler.
 * **Silent cancellation**, `cancel(coro)` stops the coro; the body doesn't see `CancelledError`. Use `with_timeout` for deadline-as-exception.
-* **Cooperative host loop**, scheduler suspends to the host when it can't progress synchronously (pending timer/frame/event); embedder resumes via `run_start` / `run_resume` / `run_push_event`. The legacy non-suspending `run` cannot resume, code using `sleep(n>0)`, `frame()`, or an empty `receive()` must run via the driver loop; statements after a top-level `run()` don't execute after a yield.
-* **`async for`** works against any `for`-iterable plus coroutines and async generators (`async def` with `yield`). Each iteration resumes to the next yield. No `__aiter__` / `__anext__` dispatch on user classes, write an `async def` generator. Behaviour over lists/tuples/dicts is identical to regular `for`.
+* **Cooperative host loop**, scheduler suspends to the host when it can't progress synchronously (pending timer/frame/event); embedder resumes via `run_start` / `run_resume` / `run_push_event`. The legacy non-suspending `run` cannot resume. Code using `sleep(n>0)`, `frame()`, or an empty `receive()` must run via the driver loop; statements after a top-level `run()` don't execute after a yield.
+* **`async for`** works against any `for`-iterable plus coroutines and async generators (`async def` with `yield`). Each iteration resumes to the next yield. No `__aiter__` / `__anext__` dispatch on user classes; write an `async def` generator instead. Behaviour over lists/tuples/dicts is identical to regular `for`.
 * **`async with`** reuses sync dispatch (`__enter__` / `__exit__`); `__aenter__` / `__aexit__` aren't consulted. For async setup/teardown, use `try` / `finally` with explicit `await`.
 * **No async comprehensions**, `[x async for x in it]` unsupported.
 * **No `gen.send` / `throw` / `close`**, generators and coroutines are one-way producers. For bidirectional flow, use `run` / `gather` and pass messages via args.