Changed README

Author: W4G1

README.md

@@ -24,9 +24,41 @@ Unlike traditional Web Workers which require separate entry files and manual mes
 npm install experimental-threads
 ```
 
+## Usage
+
+```typescript
+import { spawn } from "experimental-threads";
+import { v4: uuiv4 } from "uuid";
+
+const data = { hello: 'world' };
+
+// We must use eval() to capture the local scope of 'data'
+const result = await eval(spawn(() => {
+  // 'data' is available inside the Worker
+  console.log(data.hello); // "world"
+
+  // Magic. No dynamic import necessary inside the closure
+  return uuiv4();
+}));
+
+console.log(result); // 'cca68b4c-7416-4b44-ba94-9cf6ca90bf59'
+```
+
+## Why must `spawn()` be wrapped in `eval()`?
+
+The usage of `eval()` is a deliberate architectural choice to enable **Runtime Scope Bridging**.
+
+Standard JavaScript functions cannot reflectively access the local variables of their caller. While our AST analysis allows the library to identify *identifiers* (variable names) within your closure, it cannot access their *values*.
+
+1. `spawn()` analyzes the source and finds that you used the variable `data`.
+2. `spawn()` returns a generated code string that acts as a bridge.
+3. `eval()` executes this string in the **current local scope**, allowing the library to resolve the runtime value of `data` and transfer it to the thread.
+
+This eliminates the need for manual dependency injection, and preserves the ergonomics of standard JavaScript closures.
+
 ## Architecture
 
-### 1. Runtime Scope Analysis & AST Traversal
+### Runtime Scope Analysis & AST Traversal
 
 Standard JavaScript closures cannot be serialized to Workers because they are bound to the parent execution context. **experimental-threads** bypasses this limitation by performing **Just-In-Time (JIT) Static Analysis** on the calling code.
 
@@ -38,7 +70,7 @@ When `spawn(fn)` is invoked:
 4. **Identifier Resolution:** It walks the scope chain of the function body, distinguishing between *bound identifiers* (parameters, local variables) and *free variables* (captured from the outer scope).
 5. **Transpilation:** It generates a standalone worker entry script that imports necessary modules and injects the captured free variables as structured-cloned properties.
 
-### 2. Deterministic Memory Hydration (`Global<T>`)
+### Deterministic Memory Hydration (`Global<T>`)
 
 In a multi-process or multi-isolate architecture (like Web Workers), module singletons are not shared. They are instantiated once per thread. This breaks the identity of shared locks or buffers.
 
@@ -48,24 +80,7 @@ This library introduces **Location-Dependent Reference Integrity**.
 * **Memory Registry:** The main thread maintains a global memory registry, mapping these IDs to their underlying `SharedArrayBuffer` pointers.
 * **Hydration:** When a Worker boots and imports a module containing a `Global`, the constructor intercepts the instantiation. Instead of allocating new memory, it queries the registry transmitted during the handshake phase and **hydrates** the instance with the existing buffer from the main/parent thread.
 
-This guarantees that `const lock = new Global(new Mutex())` refers to the exact same memory address (access cost) in every thread, enabling atomic synchronization.
-
-## Usage
-
-```typescript
-import { spawn } from "experimental-threads";
-
-const data = { hello: 'world' };
-
-const result = await eval(spawn(async () => {
-   // Will be automatically captured
-  console.log(data.hello); // "world"
-
-  return Math.random();
-}));
-
-console.log(result); // 0.6378467071314606
-```
+This guarantees that `const lock = new Global(new Mutex())` refers to the exact same memory address in every thread, enabling atomic synchronization.
 
 ## Synchronization Primitives
 
@@ -81,4 +96,4 @@ A signaling mechanism to control access to a common resource by multiple process
 
 ## License
 
-MIT
+MIT