rip-lang 3.6.0 → 3.6.2

package/README.md

@@ -307,7 +307,7 @@ Simple arrays (with `.loc`) instead of AST node classes. The compiler is self-ho
 | Grammar | `src/grammar/grammar.rip` | 935 |
 | Parser Generator | `src/grammar/solar.rip` | 916 |
 | REPL | `src/repl.js` | 707 |
-| Browser Entry | `src/browser.js` | 107 |
+| Browser Entry | `src/browser.js` | 119 |
 | Tags | `src/tags.js` | 63 |
 | **Total** | | **~10,325** |
 

package/docs/RIP-GUIDE.md

@@ -534,6 +534,57 @@ user.save!()
 
 ---
 
+## Browser
+
+Rip runs directly in the browser with full async/await support — no build step.
+
+### Inline Scripts
+
+Load the compiler, then write Rip:
+
+```html
+<script type="module" src="/rip/browser.js"></script>
+<script type="text/rip">
+  res = fetch! 'https://api.example.com/data'
+  data = res.json!
+  console.log data
+</script>
+```
+
+The `!` operator works in inline scripts — `processRipScripts` wraps
+compiled code in an async IIFE transparently.
+
+### Console REPL
+
+The `rip()` function is available in any browser console where `rip.browser.js`
+is loaded:
+
+```javascript
+rip("42 * 10 + 8")                  // → 428
+rip("name = 'Alice'")               // → 'Alice' (persists on globalThis)
+rip("(x * x for x in [1..5])")      // → [1, 4, 9, 16, 25]
+
+// Async — use await, Chrome displays the resolved value
+await rip("res = fetch! 'https://jsonplaceholder.typicode.com/todos/1'; res.json!")
+// → {userId: 1, id: 1, title: 'delectus aut autem', completed: false}
+```
+
+Sync code returns values directly. Async code (using `!`) returns a Promise
+that Chrome auto-awaits. Variables persist between calls on `globalThis`.
+
+### `importRip(url)`
+
+Fetch, compile, and import a `.rip` file as an ES module:
+
+```html
+<script type="text/rip">
+  { launch } = importRip! '/rip/ui.rip'
+  launch '/demo'
+</script>
+```
+
+---
+
 ## Full-Stack Example
 
 A complete API server in Rip:

package/docs/RIP-TYPES.md

@@ -1878,6 +1878,104 @@ Each row is a test case. Verify both .js and .d.ts output.
 
 ---
 
+## Current Status
+
+Rip Types Phase I is complete. The `.d.ts` emission covers the full
+surface area of the type system — variables, functions, classes, components,
+type aliases, interfaces, enums, generics, and all four reactive operators.
+
+Phase II (consuming external `.d.ts` files for IDE intelligence) is in
+progress via the VS Code extension. Phase III (a standalone Language
+Server Protocol server) is planned.
+
+### Architecture
+
+The type system uses a two-phase approach:
+
+1. **Lexer phase** — `rewriteTypes()` strips type annotations from the token
+   stream and stores them as `.data` metadata on surviving tokens. The parser
+   never sees types.
+2. **Compiler phase** — `emitTypes(tokens, sexpr)` runs after parsing,
+   producing `.d.ts` from both annotated tokens (variables, functions, types)
+   and the s-expression tree (components). One function, one output.
+
+### What's Working
+
+**Variables and Constants:**
+
+| Rip Input | .d.ts Output |
+|-----------|-------------|
+| `x:: number = 0` | `let x: number;` |
+| `x:: number =! 100` | `declare const x: number;` |
+| `x:: number := 0` | `declare const x: Signal<number>;` |
+| `x:: number ~= y * 2` | `declare const x: Computed<number>;` |
+| `x:: Function ~> ...` | `declare const x: () => void;` |
+| `export` variants of all above | `export const/let ...` |
+
+**Functions:**
+
+| Rip Input | .d.ts Output |
+|-----------|-------------|
+| `def f(a:: T):: R` | `declare function f(a: T): R;` |
+| `def f<T>(a:: T):: T` | `declare function f<T>(a: T): T;` |
+| `def f<T extends Base>(...)` | `declare function f<T extends Base>(...);` |
+| `f = (a:: T) -> ...` | `declare function f(a: T);` |
+| `export def ...` | `export function ...;` |
+
+**Types, Interfaces, and Enums:**
+
+| Rip Input | .d.ts Output |
+|-----------|-------------|
+| `Name ::= type { id: number }` | `type Name = { id: number; };` |
+| `Name ::= number` | `type Name = number;` |
+| Block union `::= \| "a" \| "b"` | `type Name = "a" \| "b";` |
+| `interface Name { ... }` | `interface Name { ... }` |
+| `interface X extends Y` | `interface X extends Y { ... }` |
+| Function types `read: => string` | `read: () => string` |
+| `enum Name { A = 1; B = 2 }` | `enum Name { A = 1, B = 2 }` |
+
+**Classes:**
+
+| Rip Input | .d.ts Output |
+|-----------|-------------|
+| `class X { prop:: T = val }` | `declare class X { prop: T; }` |
+| `constructor: (@name:: T) ->` | `constructor(name: T);` |
+| `method: (a:: T) ->` | `method(a: T);` |
+| `class X extends Y` | `declare class X extends Y { ... }` |
+
+**Components:**
+
+| Rip Input | .d.ts Output |
+|-----------|-------------|
+| `Name = component { ... }` | `declare class Name { ... }` |
+| Reactive state `count:: number := 0` | `count: number;` |
+| Computed `doubled ~= ...` | `readonly doubled: any;` |
+| Methods | Method declarations |
+| Auto-generated | `constructor`, `mount()`, `unmount()` |
+
+**Infrastructure:**
+
+| Feature | Status |
+|---------|--------|
+| `Signal<T>` / `Computed<T>` preamble | Auto-generated when `:=` or `~=` used |
+| Import pass-through | Working |
+| Export default | Working |
+| Optional properties (`email?: string`) | Working |
+| Type suffixes (`T?`, `T??`, `T!`) | Working |
+| Generic constraints (`<T extends X>`) | Working |
+| Deferred emission (after parsing) | Working |
+| Component variable deduplication | Working |
+
+### Roadmap
+
+| Phase | Description | Status |
+|-------|-------------|--------|
+| Phase I | `.d.ts` emission from annotated Rip code | **Complete** |
+| Phase II | External type consumption — read third-party `.d.ts` files for autocomplete, hover, and go-to-definition | In progress (VS Code extension) |
+| Phase III | Language Server Protocol — full LSP server for IDE-agnostic type intelligence | Planned |
+
+---
+
 **See Also:**
 - [RIP-LANG.md](RIP-LANG.md) — Language reference
 - [RIP-REACTIVITY.md](RIP-REACTIVITY.md) — Reactive system details