docs: Clean redundancy in docs and typos.

Author: dylan-sutton-chavez

docs/pages/getting-started/introduction.md

@@ -16,16 +16,16 @@ Edge Python is a sandboxed Python subset compiled to a ~170 KB WebAssembly modul
 
 ## Try it
 
-### Use in the Browser:
+### Browser:
 
 Run Edge Python live in your browser at [demo.edgepython.com](https://demo.edgepython.com/).
 
-### Download the Command Line Interface:
+### Command Line Interface:
 
-Insted you can download in your computer ([reference docs](https://github.com/dylan-sutton-chavez/edge-python/tree/main/cli)):
+Or download it to your machine ([reference docs](https://github.com/dylan-sutton-chavez/edge-python/tree/main/cli)):
 
 ```bash
 curl -fsSL https://dylan-sutton-chavez.github.io/edge-python/install.sh | sh
 
-edge -h # Explain all the commands
+edge -h # List all commands
 ```

docs/pages/getting-started/quickstart.md

@@ -11,20 +11,7 @@ Edge Python ships as a 170 KB WebAssembly module. Fastest way to try it, the pla
 
 ## Embed it
 
-Two artifacts:
-
-1. `compiler_lib.wasm` (170 KB, lexer, parser, stack VM).
-2. A loader. Browser: the [`runtime/`](https://github.com/dylan-sutton-chavez/edge-python/tree/main/runtime) package; WASI: your runtime's import API.
-
-Build yourself:
-
-```bash
-git clone https://github.com/dylan-sutton-chavez/edge-python
-cd edge-python/compiler
-cargo wasm # -> target/wasm32-unknown-unknown/release/compiler_lib.wasm
-```
-
-Rust consumers can let cargo fetch the release artifact via `DEP_COMPILER_LIB_WASM` (see the repo README). No native CLI, `compiler_lib.wasm` is the artifact and the host owns I/O, network, time, module fetching. Full ABI: [What it is, Where it runs](/getting-started/what-it-is#where-it-runs).
+The playground is the fastest path; to put Edge Python in your own page, drop in the `<edge-python>` element below. Building the `.wasm` from source or embedding in Rust/WASI is covered in [Where it runs](/getting-started/what-it-is#where-it-runs).
 
 ### Drop-in HTML element
 

docs/pages/getting-started/what-it-is.md

@@ -17,7 +17,7 @@ Reads like Python (parses Python syntax). Runs differently, what it executes is
 * **Exceptions**: `try` / `except` / `else` / `finally`, named handlers, `raise X from Y` (chain info discarded but `X` is what propagates), and subclass-aware matching (`except Exception` catches `RuntimeError`).
 * **Context managers**: `with` and `async with` invoke `__enter__` / `__exit__` on the context-manager value; a truthy return from `__exit__` suppresses the raised exception.
 * **Protocol dunders**: operator overloading, indexing, iteration, hashing, and `repr` / `str` / `format` dispatch through user-defined dunders, see [Dunders](/language/dunders) for the full matrix.
-* **Numbers**: integers up to `±2^127` (auto-promoted past 47 bits; beyond the cap raises `OverflowError`) and full IEEE-754 floats. No `complex`, `Decimal`, `Fraction`, or arbitrary precision beyond 128 bits.
+* **Numbers**: bounded integers (fast inline path, auto-promoting to wide; see [Integer width](/reference/limits-and-errors#integer-width)) and full IEEE-754 floats. No `complex`, `Decimal`, or `Fraction`.
 * **Sequences**: lists, tuples, dicts (insertion-ordered), sets, frozensets, ranges, strings (UTF-8, codepoint-indexed), and bytes.
 * **f-strings**: full grammar, embedded expressions, `{expr=}` self-doc, `!r` / `!s` / `!a` conversions, and format specs covering `s d b o x X f F e E g G n % c` plus fill / align / sign / `#` / `0` / width / `,` / precision.
 * **Walrus operator**: `:=` in expressions (Name target only).
@@ -41,9 +41,9 @@ These parse for syntactic compatibility but raise at runtime, or simply don't ex
 
 Multi-paradigm sandboxed compiler:
 
-- **Smaller binary**, compiler + VM in 170 KB WebAssembly release.
+- **Small binary**, compiler + VM in one WebAssembly release.
 - **Faster interpreter**, no method-resolution overhead; hot opcodes promote to type-specialised fast paths via IC.
-- **Aggressive memoisation**, pure functions auto-cached; most functional code is pure by construction.
+- **Aggressive memoisation**, pure functions auto-cached after two hits ([Functions](/language/functions#generators)); most functional code is pure by construction.
 - **Easier sandboxing**, no protocol dispatch, no stdlib; attack surface is the fixed built-in set.
 
 ## Sandbox guarantees

docs/pages/implementation/design.md

@@ -17,7 +17,7 @@ Classes support single-level inheritance, `super()`, full dunder dispatch, `@pro
 - **Single-pass SSA codegen**: Variables versioned per assignment (`x_1`, `x_2`). Control-flow joins emit `Phi` opcodes resolved at runtime.
 - **Token-threaded dispatch**: `Vec<Instruction>` where each is `(opcode: OpCode, operand: u16)`. Hot loop is a flat `match`; Rust lowers it to a jump table. Not direct threading (computed-goto isn't available in safe Rust).
 - **Per-instruction inline caching**: Each binary op records operand type tags. After `QUICK_THRESH = 4` stable hits the IC stores a typed `FastOp` (`AddInt`, `AddFloat`, `AddStr`, `LtFloat`, `EqStr`, `ModInt`, ...) as a speculative fast path with type-guard deopt.
-- **Template memoisation**: Pure user functions cache `(args) -> result` after `TPL_THRESH = 2` hits, capped at 256 entries per function. Gated on no-kw calls, an outer scope free of impure ops (`StoreItem`, `StoreAttr`, `Raise`, `Yield`, `Global`, `Nonlocal`, `Import`, ...), and byte-stable arguments (mutable containers disqualify). Hashing is an FNV-like fold over raw `Val.0` bits with a value-eq verify.
+- **Template memoisation**: pure user functions cache `(args) -> result` after `TPL_THRESH = 2` hits, capped at 256 entries each. Gated on no-kw calls, byte-stable args (mutable containers disqualify), and an impurity-free body (purity detection in [Syntax](/implementation/syntax#lambda-and-function-bodies)). Hashing is an FNV-like fold over raw `Val.0` bits with a value-eq verify.
 - **NaN-boxed values**: `Val` is a 64-bit union: 47-bit signed ints (inline), IEEE-754 floats (NaNs canonicalised), bools, None, an undef sentinel, and 28-bit heap indices.
 - **Mark-and-sweep GC**: Triggered when `live >= gc_threshold` or `alloc_count >= max(live/4, 4096)`. After each sweep `gc_threshold = max(live * 2, 512)`. Roots: stack, with-stack, yields, event queue, slots and live-slot snapshots, slot templates, globals, every iterator frame's `iter_stack`, opcode-cache constants, active const pools, function templates.
 
@@ -77,7 +77,7 @@ Heap is a `Vec<HeapSlot>` arena with a free list (capped 524,288, sorted to pref
 
 ## Coroutine and context-manager dispatch
 
-`async def` and `yield`-bearing `def` both produce `HeapObj::Coroutine`. `run()` drives the scheduler; `sleep`, `gather`, `with_timeout`, `cancel`, `receive` are top-level builtins. No `asyncio` module.
+`async def` and `yield`-bearing `def` both produce `HeapObj::Coroutine`. `run()` drives the scheduler; the other primitives are top-level builtins ([Async](/language/async)).
 
 A plain `def` inside a coroutine calling a yielding builtin gets its state (`ip`, slots, stack/iter deltas) snapshotted as a `SyncFrame` pushed on the enclosing Coroutine's `sync_frames` (innermost-last). `resume_coroutine` walks this stack inside-out before re-entering the outer body, so each helper's return value lands at the original `Call` site, otherwise the outer's `resume_ip` would skip past the unfinished helper.
 

docs/pages/implementation/syntax.md

@@ -206,7 +206,7 @@ Free variables (non-parameters with no local binding) are looked up in the outer
 
 Parameter slots: `Normal`, `Star` (`*args`), `DoubleStar` (`**kwargs`). Lone `*` separator marks following params as keyword-only. Defaults live in `HeapObj::Func.defaults` and apply to the last-N positional slots. Annotations (`x: T`, `-> T`) parse and drain to `chunk.annotations` (tooling-only).
 
-`compile_body` checks impurity opcodes (`StoreItem`, `StoreAttr`, `CallPrint`, `CallInput`, `Global`, `Nonlocal`, `Import`, `Raise`, `Yield`, `LoadAttr`) to set `body.is_pure`. Template memoisation caches pure `(args) -> result` after `TPL_THRESH = 2` hits (capped at 256 entries).
+`compile_body` checks impurity opcodes (`StoreItem`, `StoreAttr`, `CallPrint`, `CallInput`, `Global`, `Nonlocal`, `Import`, `Raise`, `Yield`, `LoadAttr`) to set `body.is_pure` — the flag that gates template memoisation ([Design](/implementation/design#concepts)).
 
 ## Type annotations
 

docs/pages/language/data-types.md

@@ -33,29 +33,7 @@ For runtime membership in a type, use [`isinstance`](/reference/builtins#isinsta
 
 ## Integer
 
-Two-tier. **Inline (fast)**: 47-bit signed in a NaN-boxed `Val`, one ALU op per arithmetic, zero alloc. **LongInt (slow)**: i128 in a heap slot, auto when literal/result exceeds 47-bit. Boundary invisible, same `int` type, same operators. Hard cap ±2¹²⁷; wider -> `OverflowError`. No CPython unbounded ints; no complex (`1j`, `2+3j`).
-
-```python
-# Inline range
-print(2 ** 46)
-print(2 ** 46 - 1)
-
-# Auto-promoted to LongInt
-print(2 ** 100)
-
-# Past the 128-bit cap
-try:
-    print(2 ** 127)
-except OverflowError:
-    print("overflow")
-```
-
-```text Output
-70368744177664
-70368744177663
-1267650600228229401496703205376
-overflow
-```
+One `int` type, transparently two-tier: a fast inline path that auto-promotes to wide integers, capped at ±2¹²⁷ (full mechanics in [Integer width](/reference/limits-and-errors#integer-width)). No CPython unbounded ints; no complex (`1j`, `2+3j`).
 
 ```python
 # Modular exponentiation

docs/pages/language/dunders.md

@@ -178,13 +178,14 @@ class K:
     def __eq__(self, o):
         return self.n == o.n
 
-print(hash(K(5)))
-print({K(1): 'one'}[K(1)] if K(1).__hash__() == K(1).__hash__() else 'unhashable')
+k = K(5)
+print(hash(k))
+print({k: 'found'}[k]) # same instance reference looks up reliably
 ```
 
 ```text Output
 5
-one
+found
 ```
 
 Built-in dict/set still compare instance keys by identity (`Val` bits); user `__hash__` is returned by `hash()` but doesn't change containment in built-in containers. Use the same instance reference to look up reliably.

docs/pages/language/syntax.md

@@ -125,22 +125,22 @@ hello world
 
 ### Escape sequences
 
-Supported: `\n`, `\t`, `\r`, `\\`, `\'`, `\"`, `\0`, `\xHH`, `\uHHHH`, `\UHHHHHHHH`, `\NNN` (1\u20133 octal digits). Named-char escapes (`\N{GREEK SMALL LETTER ALPHA}`) not supported \u2014 use `\u`.
+Supported: `\n`, `\t`, `\r`, `\\`, `\'`, `\"`, `\0`, `\xHH`, `\uHHHH`, `\UHHHHHHHH`, `\NNN` (1–3 octal digits). Named-char escapes (`\N{GREEK SMALL LETTER ALPHA}`) not supported — use `\u`.
 
 ```python
 print('\n line break')
 print('\t tab')
 print('\x41 hex')
 print('\u00e9 unicode')
-print('\101') # octal escape \u2014 'A'
+print('\101') # octal escape — 'A'
 ```
 
 ```text Output
 
  line break
 	 tab
 A hex
-\u00e9 unicode
+é unicode
 A
 ```
 

docs/pages/reference/builtins.md

@@ -862,7 +862,7 @@ print(c.x)
 
 ## Async
 
-Top-level builtins, no `asyncio` module.
+Concurrency primitives; full model in [Async](/language/async).
 
 ### run