docs(imports): Allign docs and clean redaction.

Author: dylan-sutton-chavez

docs/pages/reference/imports.md

@@ -3,7 +3,7 @@ title: "Imports"
 description: "Importing modules in Edge Python: syntax, resolution, and the two module flavors."
 ---
 
-Supports `import`, `from <spec> import <names>`, `from <spec> import *`. Resolution is compile-time, the VM never learns what a module is; bytecode flattens every import into the sequence that materialises the exports.
+Supports `import`, `from <spec> import <names>`, `from <spec> import *`. Resolution is compile-time: the VM never learns what a module is; bytecode flattens every import into the sequence that materialises the exports.
 
 ## The two flavors
 
@@ -56,15 +56,15 @@ The names above (`json`, `utils`, `math`) are illustrative. `json` is an [offici
 2. For each spec, asks the host `Resolver` to materialise as `Resolved::Native { bindings, canonical }` or `Resolved::Code { src, canonical }`.
 3. Natives become direct-dispatch entries; code modules parse to a fresh `SSAChunk`. Both register under the canonical spec so first-class references and `import_module()` lookups resolve uniformly. See [Syntax, Imports](/implementation/syntax).
 
-Modules are singletons across the compilation unit: same canonical spec -> one `SSAChunk`, top level runs once, one `HeapObj::Module` shared by every importer. Two files importing `./util.py` see the same module, `mod is mod_alias` is true; module-attr mutations are observed by every consumer. Inside the module's top level, `__name__` is bound to the canonical spec so `if __name__ == "__main__":` skips when imported.
+Modules are singletons across the compilation unit: same canonical spec -> one `SSAChunk`, top level runs once, one `HeapObj::Module` shared by every importer. Two files importing `./util.py` see the same module — `mod is mod_alias` is true; module-attr mutations are observed by every consumer. Inside the module's top level, `__name__` is bound to the canonical spec so `if __name__ == "__main__":` skips when imported.
 
 Helpers and constants stay private: they live in the module's slot frame, reached via attribute access on the `HeapObj::Module` Val, not through the parent chunk's name table. `a.f` calling `helper` resolves through `a`'s attrs, not the importer's globals.
 
 The runtime never fetches. The host (browser, WASI, embedded Rust) brings the bytes; the compiler accepts them through `Resolver`.
 
 ## packages.json
 
-Bare-name imports resolve through an import map in `packages.json` (next to the entry script). The manifest is always `packages.json`, no `edge.json` or other variants.
+Bare-name imports resolve through an import map in `packages.json` (next to the entry script). The manifest is always `packages.json` — no `edge.json` or other variants.
 
 ```json
 {
@@ -81,14 +81,14 @@ Schema:
 - Top-level value is a JSON object. Empty `{}` is valid.
 - `imports` (optional): alias -> spec string.
 - `extends` (optional): directory whose `packages.json` is consulted when an alias isn't found locally.
-- `host` (optional): name -> JS module URL. Read by the browser runtime's `<edge-python>` element to load [host libraries](/reference/packages#host-libraries) on the main thread (DOM, network, storage,...). The compiler itself ignores it (it's one of the silently-ignored keys below); the runtime consumes it. See the [runtime README](https://github.com/dylan-sutton-chavez/edge-python/tree/main/runtime).
+- `host` (optional): name -> JS module URL. Read by the browser runtime's `<edge-python>` element to load [host libraries](/reference/packages#host-libraries) on the main thread (DOM, network, storage…). The compiler itself ignores it (it's one of the silently-ignored keys below); the runtime consumes it. See the [runtime README](https://github.com/dylan-sutton-chavez/edge-python/tree/main/runtime).
 - Unknown top-level keys silently ignored (forward-compatible).
 - Booleans, numbers, arrays at any level are rejected.
-- String escapes: `\"`, `\\`, `\/`, `\n`, `\t`, `\r`. `\uXXXX` not supported, paste UTF-8 literally.
+- String escapes: `\"`, `\\`, `\/`, `\n`, `\t`, `\r`. `\uXXXX` not supported — paste UTF-8 literally.
 
 `from utils import x` resolves to `./lib/utils.py` relative to the entry script; `from math import add` loads `.wasm` per the [wire format](/reference/wasm-abi).
 
-`packages.json` is optional, scripts can use string-form paths directly without project config, and the browser runtime resolves the [official packages](/reference/packages#defaults) by bare name without it.
+`packages.json` is optional — scripts can use string-form paths directly without project config, and the browser runtime resolves the [official packages](/reference/packages#defaults) by bare name without it.
 
 ### Walk-up resolution
 
@@ -97,17 +97,17 @@ Bare-name imports resolve against the nearest `packages.json` walking up from th
 ```
 my_app/
 ├── packages.json <- root manifest
-├── main.py   bare imports here resolve via root manifest
+├── main.py # bare imports here resolve via root manifest
 ├── lib/
 │   ├── packages.json <- sub-package manifest
-│   └── helper.py   bare imports here resolve via lib/ first
+│   └── helper.py # bare imports here resolve via lib/ first
 └── ...
 ```
 
 - **Bare-name imports** (`from utils import x`) walk up looking for `packages.json`. First one decides. Capped at 32 hops; over: `packages.json walk-up exceeded <cap> hops resolving '<name>'`.
-- **Hermetic by default**: if the nearest manifest doesn't declare the alias, compilation fails (`alias '<name>' not declared in '<manifest>'`). No silent fall-through, prevents a deep transitive dep from borrowing parent aliases.
+- **Hermetic by default**: if the nearest manifest doesn't declare the alias, compilation fails (`alias '<name>' not declared in '<manifest>'`). No silent fall-through — prevents a deep transitive dep from borrowing parent aliases.
 - **`extends` opts in to inheritance**: `"extends": ".."` re-runs the search from the extended directory when the alias isn't local. Cycles detected at compile time (`circular extends chain in packages.json`).
-- **Quoted relative paths** (`from "./helpers.py" import f`) resolve against the importing file, transitively-imported `lib/a.py` doing `from "./b.py" import g` finds `lib/b.py`.
+- **Quoted relative paths** (`from "./helpers.py" import f`) resolve against the importing file; transitively-imported `lib/a.py` doing `from "./b.py" import g` finds `lib/b.py`.
 
 Spec classification (handled by the resolver):
 
@@ -169,21 +169,21 @@ Append `#sha256-<64 hex chars>` to any URL spec to require a content match:
 from "https://example.com/utils.py#sha256-deadbeef0123456789abcdef0123456789abcdef0123456789abcdef01234567" import normalize
 ```
 
-The compiler asks the host for raw bytes (`Resolver::fetch_bytes`), computes SHA-256, refuses to compile on mismatch, diagnostic surfaces both digests:
+The compiler asks the host for raw bytes (`Resolver::fetch_bytes`), computes SHA-256, refuses to compile on mismatch; the diagnostic surfaces both digests:
 
 ```text
 error: integrity check failed for 'https://example.com/utils.py'
   expected sha256-deadbeef0123456789abcdef0123456789abcdef0123456789abcdef01234567
   got      sha256-feedface9876543210fedcba9876543210fedcba9876543210fedcba98765432
 ```
 
-Verification lives in the compiler, not the host, every host inherits it uniformly. Hosts without `fetch_bytes` surface a clean "not supported" error rather than silently bypassing.
+Verification lives in the compiler, not the host: every host inherits it uniformly. Hosts without `fetch_bytes` surface a clean "not supported" error rather than silently bypassing.
 
 Only `sha256` supported. Other prefixes (`md5-...`, `sha384-...`) fail with `unrecognized integrity fragment`. The hex body must be exactly 64 chars.
 
 ## Lockfile and content-addressed cache
 
-The browser worker auto-generates a lockfile and a content-addressed cache (both in IndexedDB) as a side-effect of running scripts that import URLs, repeat runs go to zero network round-trips and upstream drift is detected on demand.
+The browser worker auto-generates a lockfile and a content-addressed cache (both in IndexedDB) as a side-effect of running scripts that import URLs; repeat runs go to zero network round-trips, and upstream drift is detected on demand.
 
 | File | Who writes it | Purpose |
 |---|---|---|
@@ -209,7 +209,7 @@ integrity drift for 'https://cdn.foo/kit/index.py'
 
 Same primitive as inline `#sha256-...` integrity, applied automatically to every imported URL. Explicit hashes in source are still honoured and fail at compile time before any code runs.
 
-Non-browser hosts make their own caching choices, `Resolver` sees only `(spec -> Resolved)` and `(spec -> bytes)`.
+Non-browser hosts make their own caching choices: `Resolver` sees only `(spec -> Resolved)` and `(spec -> bytes)`.
 
 ## Sandbox