rip-lang 2.5.1 → 2.7.2

package/CHANGELOG.md

@@ -7,6 +7,53 @@ All notable changes to Rip will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.7.2] - 2026-02-03
+
+### Clean ES Module REPL
+
+**Proper `vm.SourceTextModule` Implementation**: The REPL now uses Node's standard ES module API instead of temp files:
+
+```coffee
+rip> { Cash } = await import("./utils.rip")
+rip> config = Cash((await import("./config.rip")).default)
+rip> config.app.name
+→ 'Rip Labs API'
+```
+
+**Key improvements:**
+- Uses `vm.SourceTextModule` for in-memory module evaluation (no temp files)
+- `.rip` files compiled on-the-fly via module linker
+- Cross-runtime compatible (Node.js, Bun, potentially Deno)
+- Dynamic `await import()` transformed to static imports automatically
+- Clean variable persistence through VM context
+
+This is the standard way to handle ES modules in sandboxed contexts - no hacks required.
+
+---
+
+## [2.7.1] - 2026-02-03
+
+### Bun-Native REPL with Dynamic Import Support
+
+**Full `import()` Support in REPL**: The REPL now uses Bun's native evaluation instead of Node's `vm` module, enabling dynamic imports:
+
+```coffee
+rip> { Cash } = await import("./utils.js")
+rip> config = Cash((await import("./config.js")).default)
+rip> config.app.name
+→ 'My App'
+```
+
+**Key changes:**
+- Replaced `vm.runInContext` with file-based async evaluation
+- Variables persist across REPL lines via `globalThis.__ripRepl`
+- Temp files cleaned up automatically on exit
+- Reactive runtime injected into global scope for cross-line sharing
+
+This enables using the REPL for real development workflows with module imports.
+
+---
+
 ## [2.5.1] - 2026-01-16
 
 ### Template Enhancement
@@ -176,7 +223,7 @@ Counter.new().mount("#app")               # Selector string support
 
 | Category | Score | Notes |
 |----------|-------|-------|
-| **Reactivity** | A+ | Fine-grained, signals, effects |
+| **Reactivity** | A+ | Fine-grained, state, effects |
 | **Templates** | A | S-expressions, Pug shorthand |
 | **Components** | A | Props, lifecycle, context API |
 | **Performance** | A | 250× faster parser gen, 51KB bundle |
@@ -187,7 +234,7 @@ Counter.new().mount("#app")               # Selector string support
 
 **What's in 51KB?**
 - Complete compiler (lexer, parser, code generator)
-- Reactive runtime (signals, derived values, effects)
+- Reactive runtime (state, computed values, effects)
 - Template engine (S-expression syntax, dynamic classes)
 - Component system (props, lifecycle, fine-grained updates)
 - Zero dependencies
@@ -292,10 +339,10 @@ Each item gets its own effect. Changing `selected` updates ONLY the affected cla
 ### Added - Reactive UI Framework
 
 **Phase 1: Reactivity** (previously released)
-- Signal-based reactivity: `count = 0` creates reactive state
-- Derived values: `doubled ~= count * 2` auto-tracks dependencies
-- Effects: `effect -> console.log count` runs on changes
-- Runtime: `__signal()`, `__computed()`, `__effect()`, `__batch()`, `__readonly()`
+- State-based reactivity: `count := 0` creates reactive state
+- Computed values: `doubled ~= count * 2` auto-tracks dependencies
+- Effects: `~> console.log count` runs on changes
+- Runtime: `__state()`, `__computed()`, `__effect()`, `__batch()`, `__readonly()`
 
 **Phase 2: Templates**
 - Indentation-based template syntax in `render` blocks
@@ -317,8 +364,8 @@ Each item gets its own effect. Changing `selected` updates ONLY the affected cla
   - Optional: `@label?`
   - Default: `@label = "default"`
   - Rest: `@...rest`
-- Reactive state within components (auto-signals)
-- Derived values within components (auto-computed)
+- Reactive state within components (auto-state)
+- Computed values within components (auto-computed)
 - Component composition: `Button label: "Click"` inside render
 - Children/slots: `@children` prop for nested content
 - Lifecycle hooks: `mounted:`, `unmounted:`
@@ -332,8 +379,8 @@ Each item gets its own effect. Changing `selected` updates ONLY the affected cla
 ### Technical Details
 - Components compile to ES6 classes with constructor, render, mount, unmount
 - Props validated at construction (required props throw if missing)
-- State variables become `__signal()` calls
-- Derived values become `__computed()` calls
+- State variables become `__state()` calls
+- Computed values become `__computed()` calls
 - `mount()` wraps render in `__effect()` for reactive updates
 - PascalCase names in templates trigger component instantiation
 

package/README.md

@@ -5,39 +5,37 @@
 <h1 align="center">Rip</h1>
 
 <p align="center">
-  <strong>Elegant reactive code that compiles to modern JavaScript</strong>
+  <strong>A modern language that compiles to JavaScript</strong>
 </p>
 
 <p align="center">
-  <a href="CHANGELOG.md"><img src="https://img.shields.io/badge/version-2.5.1-blue.svg" alt="Version"></a>
+  <a href="CHANGELOG.md"><img src="https://img.shields.io/badge/version-2.7.2-blue.svg" alt="Version"></a>
   <a href="#zero-dependencies"><img src="https://img.shields.io/badge/dependencies-ZERO-brightgreen.svg" alt="Dependencies"></a>
-  <a href="#"><img src="https://img.shields.io/badge/tests-1046%2F1046-brightgreen.svg" alt="Tests"></a>
+  <a href="#"><img src="https://img.shields.io/badge/tests-979%2F979-brightgreen.svg" alt="Tests"></a>
   <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-green.svg" alt="License"></a>
 </p>
 
 ---
 
-## What is Rip?
+Rip is a modern language inspired by CoffeeScript. It compiles to **ES2022** (classes, `?.`, `??`, modules), adds about a **dozen new operators**, includes **built-in reactivity**, and sports a self-hosting compiler with **zero dependencies** — all in about 10,000 lines of code.
 
-Rip is a modern reactive language that compiles to JavaScript. It takes the elegant, readable syntax that made CoffeeScript beloved and brings it into the modern era — with ES2022 output, built-in reactivity, and a clean component system for building UIs.
-
-**The language IS the framework.** Unlike React, Vue, or Svelte where reactivity comes from libraries or compiler magic, Rip's reactive features are **language-level operators**:
+> **No imports. No hooks. No dependency arrays. Just write code.**
 
 ```coffee
-count := 0              # Signal (reactive state)
-doubled ~= count * 2    # Derived (auto-updates)
-effect -> log doubled   # Effect (side effects)
-```
+data = fetchUsers!                  # Dammit operator (call + await)
+user = User.new name: "Alice"       # Ruby-style constructor
+squares = (x * x for x in [1..10])  # List comprehension
 
-No imports. No hooks. No dependency arrays. Just write code.
+str =~ /Hello, (\w+)/               # Regex match
+log "Found: #{_[1]}"                # Captures in _[1], _[2], etc.
+```
 
-The compiler is completely standalone with **zero dependencies**, and it's self-hosting: Rip compiles itself. At ~14,000 lines of code, it's smaller than CoffeeScript while including a complete reactive framework.
+---
 
 **What makes Rip different:**
-- **Reactive primitives** — `:=` signals, `~=` derived values, `effect` blocks as syntax
-- **Components as syntax** — `component Counter` with props, lifecycle, fine-grained DOM updates
-- **Templates** — Pug-style HTML in `render` blocks, two-way binding with `<=>`
 - **Modern output** — ES2022 with native classes, `?.`, `??`, modules
+- **New operators** — `!`, `!?`, `//`, `%%`, `=~`, `.new()`, and more
+- **Reactive operators** — `:=`, `~=`, `~>` as language syntax
 - **Zero dependencies** — everything included, even the parser generator
 - **Self-hosting** — `bun run parser` rebuilds the compiler from source
 
@@ -45,263 +43,150 @@ The compiler is completely standalone with **zero dependencies**, and it's self-
 
 ## Installation
 
-**Option 1: Install from npm**
 ```bash
-curl -fsSL https://bun.sh/install | bash   # Install Bun (if needed)
-bun add -g rip-lang
+bun add -g rip-lang            # Install globally
 ```
 
-**Option 2: Clone from source**
 ```bash
-git clone https://github.com/shreeve/rip-lang.git
-cd rip-lang && bun link
-```
-
-**Then use it:**
-```bash
-rip                     # Interactive REPL
-rip file.rip            # Run a file
-rip -c file.rip         # Compile to JavaScript
-bun file.rip            # Direct execution with Bun loader
+rip                            # Interactive REPL
+rip file.rip                   # Run a file
+rip -c file.rip                # Compile to JavaScript
 ```
 
 ---
 
-## Language Features
+## Language
 
 ### Functions & Classes
+
 ```coffee
-# Three function styles
-def greet(name)           # Named function (hoisted)
+def greet(name)                # Named function
   "Hello, #{name}!"
 
-add = (a, b) -> a + b     # Arrow function
-handler = (e) => @process e   # Fat arrow (preserves this)
-
-# Classes with clean syntax
-class Animal
-  constructor: (@name) ->
-  speak: -> console.log "#{@name} makes a sound"
+add = (a, b) -> a + b          # Arrow function
+handler = (e) => @process e    # Fat arrow (preserves this)
 
 class Dog extends Animal
-  speak: -> console.log "#{@name} barks"
+  speak: -> log "#{@name} barks"
 
-# Ruby-style constructors (both styles work)
-dog = Dog.new("Buddy")    # → new Dog("Buddy")
-dog = new Dog("Buddy")    # Traditional JS style
+dog = Dog.new("Buddy")         # Ruby-style constructor
 ```
 
 ### Destructuring & Comprehensions
+
 ```coffee
-# Destructuring
 {name, age} = person
 [first, ...rest] = items
 
-# Comprehensions (context-aware!)
-squares = (x * x for x in [1..10])   # Returns array
-console.log x for x in items         # Just loops (no array created)
+squares = (x * x for x in [1..10])   # Array comprehension
+console.log x for x in items         # Loop (no array)
 ```
 
-### Async & Optional Chaining
+### Async & Chaining
+
 ```coffee
-# Auto-async detection
 def loadUser(id)
-  response = await fetch "/api/users/#{id}"
+  response = await fetch "/api/#{id}"
   await response.json()
 
-# Optional chaining (both styles work)
-user?.profile?.name      # ES2020 native
-arr?[0]                  # CoffeeScript soak
-fn?(arg)                 # Safe call
+user?.profile?.name            # Optional chaining
+data = fetchData!              # Await shorthand
 ```
 
----
-
-## Unique Features
-
-### New Operators & Syntax
-
-| Feature | Example | What it does |
-|---------|---------|--------------|
-| **Ruby `.new()`** | `Counter.new()` | Ruby-style constructor → `new Counter()` |
-| **Dammit `!`** | `fetchData!` | Calls the function AND awaits it |
-| **Void `!`** | `def process!` | Suppresses implicit return (always returns undefined) |
-| **Otherwise `!?`** | `val !? 5` | Defaults only if `undefined` (null/0/false are kept!) |
-| **Floor div `//`** | `7 // 2` | Floor division → `Math.floor(7 / 2)` = 3 |
-| **True mod `%%`** | `-1 %% 3` | True modulo (not remainder) → 2, not -1 |
-| **Equal, dammit! `=!`** | `MAX =! 100` | Forces `const` declaration (can't reassign) |
-| **Ternary `?:`** | `x > 0 ? 'yes' : 'no'` | JS-style ternary (plus CoffeeScript's if/then/else) |
-| **Dual optional** | `a?.b` and `a?[0]` | Both ES6 native and CoffeeScript soak styles |
-
-### Regex Enhancements
-
-| Feature | Example | What it does |
-|---------|---------|--------------|
-| **Match `=~`** | `str =~ /(\w+)/` | Ruby-style regex, captures in `_[1]` |
-| **Regex index** | `str[/pat/, 1]` | Extract capture group directly |
-| **Heregex** | `///pat # comment///` | Extended regex with comments and whitespace |
-
-### Strings & Data
-
-| Feature | Example | What it does |
-|---------|---------|--------------|
-| **Heredoc** | `'''` closing column | Smart indentation — closing position sets left margin |
-| **`__DATA__`** | `__DATA__\nconfig...` | Ruby-style inline data section, accessible as `DATA` |
-
-### Reactivity (Built-in)
-
-| Feature | Example | What it does |
-|---------|---------|--------------|
-| **Signal `:=`** | `count := 0` | Creates reactive state container |
-| **Derived `~=`** | `doubled ~= count * 2` | Auto-updates when dependencies change |
-| **Effect** | `effect -> log x` | Runs whenever referenced signals change |
-
-### Components & Templates
-
-| Feature | Example | What it does |
-|---------|---------|--------------|
-| **Component** | `component Counter` | Define reactive UI component |
-| **Render** | `render` block | Indentation-based HTML templates |
-| **Props** | `@prop`, `@prop?`, `@prop = default` | Component input from parent |
-| **Rest props** | `@...rest` | Capture remaining props |
-| **Two-way bind** | `input value <=> name` | Bidirectional data binding |
-| **Event handlers** | `@click: handler` | DOM event binding |
-| **Lifecycle** | `mounted:`, `unmounted:` | Component lifecycle hooks |
-| **Context API** | `setContext`, `getContext` | Pass data down component tree |
-| **Fine-grained** | No virtual DOM | Surgical DOM updates via signals |
-
-**→ 26 major enhancements over CoffeeScript!**
-
----
+### Reactivity
 
-## Reactivity
+State, computed values, and effects as language operators:
 
-**The language IS the framework.** Reactivity is built into Rip's syntax—not a library you import, not hooks you call. Just operators.
+| Operator | Mnemonic | Example | What it does |
+|----------|----------|---------|--------------|
+| `=` | "gets value" | `x = 5` | Regular assignment |
+| `:=` | "has state" | `count := 0` | Reactive state container |
+| `~=` | "always equals" | `twice ~= count * 2` | Auto-updates on changes |
+| `~>` | "reacts to" | `~> log count` | Runs on dependency changes |
+| `=!` | "equals, dammit!" | `MAX =! 100` | Readonly constant |
 
-```coffee
-count := 0                    # Signal — reactive state
-doubled ~= count * 2          # Derived — auto-updates when count changes
-effect -> console.log doubled # Effect — runs when dependencies change
-
-count = 5   # doubled becomes 10, effect logs "10"
-count = 10  # doubled becomes 20, effect logs "20"
-```
+---
 
-**Compare to React:**
-```javascript
-// React: imports, hooks, dependency arrays, rules...
-import { useState, useMemo, useEffect } from 'react';
-const [count, setCount] = useState(0);
-const doubled = useMemo(() => count * 2, [count]);
-useEffect(() => console.log(doubled), [doubled]);
-```
+## New Operators
 
-**Rip: 3 lines. React: 5 lines + imports + dependency arrays + hook rules.**
+| Operator | Example | What it does |
+|----------|---------|--------------|
+| `!` (dammit) | `fetchData!` | Calls AND awaits |
+| `!` (void) | `def process!` | Suppresses implicit return |
+| `!?` (otherwise) | `val !? 5` | Default only if `undefined` |
+| `?:` (ternary) | `x > 0 ? 'yes' : 'no'` | JS-style ternary expression |
+| `?.` `?[]` | `a?.b` `a?[0]` | Optional chaining (both styles) |
+| `...` (spread) | `[...rest, last]` | Spread at start or end (JS: end only) |
+| `//` | `7 // 2` | Floor division → 3 |
+| `%%` | `-1 %% 3` | True modulo → 2 |
+| `=~` | `str =~ /Hello, (\w+)/` | Match (captures in `_`) |
+| `[//, n]` | `str[/Hello, (\w+)/, 1]` | Extract capture n |
+| `.new()` | `Dog.new()` | Ruby-style constructor |
 
-| Concept | React | Vue | Solid | Rip |
-|---------|-------|-----|-------|-----|
-| State | `useState()` | `ref()` | `createSignal()` | `x := 0` |
-| Derived | `useMemo()` | `computed()` | `createMemo()` | `x ~= y * 2` |
-| Effect | `useEffect()` | `watch()` | `createEffect()` | `effect ->` |
+**Optional chaining** — Both CoffeeScript and ES6 styles are supported:
 
-No imports. No hooks. No dependency arrays. Just operators that do what they say.
+| Syntax | Style | Compiles to |
+|--------|-------|-------------|
+| `obj?[0]` | CoffeeScript | `(obj != null ? obj[0] : undefined)` |
+| `fn?(arg)` | CoffeeScript | `(typeof fn === 'function' ? fn(arg) : undefined)` |
+| `obj?.[0]` | ES6/JS | `obj?.[0]` |
+| `fn?.(arg)` | ES6/JS | `fn?.(arg)` |
 
-[Full reactivity guide →](docs/GUIDE.md#reactivity)
+### Heredoc & Heregex
 
----
-
-## Components
-
-Components are a **language construct**, not a pattern. Define with the `component` keyword, get props, state, lifecycle, and fine-grained DOM updates—all without a virtual DOM.
+**Heredoc** — The closing `'''` position sets the left margin (smart dedent):
 
 ```coffee
-component Counter
-  @label = "Count"          # Prop with default
-  @initial = 0              # Another prop
-
-  count := @initial         # Reactive state (signal)
-  doubled ~= count * 2      # Derived value (auto-updates)
-
-  inc: -> count += 1        # Methods
-  dec: -> count -= 1
-
-  render
-    div.counter
-      h2 @label
-      span.value count
-      span.derived " (×2 = #{doubled})"
-      button @click: @dec, "−"
-      button @click: @inc, "+"
-
-# Mount with Ruby-style constructor
-Counter.new(label: "Score", initial: 10).mount "#app"
+html = '''
+    <div>
+      <p>Hello</p>
+    </div>
+  '''
+# Result: "  <div>\n    <p>Hello</p>\n  </div>" (note the leading 2 spaces)
 ```
 
-**What you get:**
-- **Props:** `@prop` (required), `@prop?` (optional), `@prop = default`
-- **State:** Signals (`:=`) and derived values (`~=`) just work
-- **Lifecycle:** `mounted:`, `unmounted:`, `updated:`
-- **Context:** `setContext`/`getContext` for deep prop passing
-- **Fine-grained updates:** Only changed DOM nodes update—no virtual DOM diffing
+**Heregex** — Extended regex with comments and whitespace:
 
-[Component guide →](docs/GUIDE.md#components)
+```coffee
+pattern = ///
+  ^(\d{3})    # area code
+  -(\d{4})    # number
+///
+```
 
 ---
 
-## Templates
+## vs React / Vue / Solid
+
+| Concept | React | Vue | Solid | Rip |
+|---------|-------|-----|-------|-----|
+| State | `useState()` | `ref()` | `createSignal()` | `x := 0` |
+| Computed | `useMemo()` | `computed()` | `createMemo()` | `x ~= y * 2` |
+| Effect | `useEffect()` | `watch()` | `createEffect()` | `~> body` |
 
-Indentation-based HTML with Pug-style selectors. Templates compile to **fine-grained DOM operations**—when a signal changes, only the affected text node or attribute updates. No virtual DOM, no diffing, no wasted work.
+Rip's reactivity is framework-agnostic — use it with React, Vue, Svelte, or vanilla JS.
 
-```coffee
-render
-  div#app.container
-    h1.title "Hello, #{name}!"
-
-    # Two-way binding with <=> operator
-    input type: "text", value <=> username
-    input type: "number", value <=> count    # Auto-uses valueAsNumber!
-
-    # Dynamic classes (Tailwind-friendly)
-    button.btn.("primary" if active) @click: submit
-      "Submit"
-
-    # Loops with keys for efficient updates
-    ul.items
-      for item in items, key: item.id
-        li.item item.name
-```
+---
 
-**Template features:**
-| Syntax | What it does |
-|--------|--------------|
-| `div#id.class1.class2` | IDs and classes (CSS selector style) |
-| `@click: handler` | Event binding |
-| `@click.prevent.stop:` | Event modifiers |
-| `@keydown.enter:` | Key modifiers |
-| `value <=> var` | Two-way binding (auto-syncs input ↔ variable) |
-| `.("class", cond && "other")` | Dynamic classes |
-| `for x in arr, key: x.id` | Keyed iteration |
-| `span if condition` | Conditional rendering |
-
-**The `<=>` operator** handles two-way binding automatically:
-```coffee
-# This one line...
-input type: "number", value <=> count
+## vs CoffeeScript
 
-# ...replaces all this React ceremony:
-# <input type="number" value={count}
-#   onChange={e => setCount(parseInt(e.target.value) || 0)} />
-```
+| Feature | CoffeeScript | Rip |
+|---------|--------------|-----|
+| **Output** | ES5 (var, prototypes) | ES2022 (classes, `?.`, `??`) |
+| **Reactivity** | None | Built-in |
+| **Dependencies** | Multiple | Zero |
+| **Self-hosting** | No | Yes |
+| **Lexer** | 3,558 LOC | 3,250 LOC |
+| **Compiler** | 10,346 LOC | 5,878 LOC |
+| **Total** | 17,760 LOC | ~10,100 LOC |
 
-[Template guide →](docs/GUIDE.md#templates)
+Smaller codebase, modern output, built-in reactivity.
 
 ---
 
-## Browser Support
+## Browser
 
-Run Rip directly in the browser (51KB compressed—complete language + reactive framework).
-
-**Try it live:** [https://shreeve.github.io/rip-lang/](https://shreeve.github.io/rip-lang/)
+Run Rip directly in the browser (51KB compressed):
 
 ```html
 <script src="https://shreeve.github.io/rip-lang/docs/dist/rip.browser.min.js"></script>
@@ -312,78 +197,50 @@ Run Rip directly in the browser (51KB compressed—complete language + reactive
 </script>
 ```
 
-```bash
-bun run browser    # Build the bundle
-bun run serve      # Start dev server at localhost:3000
-```
-
----
-
-## Modernizing What CoffeeScript Started
-
-CoffeeScript showed us beautiful syntax. Rip takes that vision further:
-
-| | Rip | CoffeeScript |
-|---|---|---|
-| **Output** | ES2022 (classes, `?.`, `??`) | ES5 (var, prototypes) |
-| **Reactivity** | Built-in (signals, effects, templates) | None |
-| **Dependencies** | Zero | Multiple |
-| **Self-hosting** | Yes (compiles itself) | No |
-| **Codebase** | ~14,000 LOC | 17,760 LOC |
+**Try it live:** [shreeve.github.io/rip-lang](https://shreeve.github.io/rip-lang/)
 
 ---
 
-## Why S-Expressions?
-
-Traditional compilers use complex AST node classes. Rip uses simple arrays:
+## Architecture
 
 ```
 Source → Lexer → Parser → S-Expressions → Codegen → JavaScript
                           ["=", "x", 42]
 ```
 
-**Traditional AST:**
-```javascript
-class BinaryOp {
-  constructor(op, left, right) { ... }
-  compile() { /* 50 lines */ }
-}
-```
+Simple arrays instead of AST node classes. The compiler is self-hosting — `bun run parser` rebuilds from source.
 
-**Rip's approach:**
-```javascript
-case '+': return `(${gen(left)} + ${gen(right)})`;
-```
-
-| Component | CoffeeScript | Rip |
-|-----------|--------------|-----|
-| Lexer | 3,558 LOC | 3,537 LOC |
-| Parser Generator | 2,285 LOC (Jison) | ~1,000 LOC (Solar) |
-| Compiler | 10,346 LOC | 7,965 LOC |
-| **Total** | **17,760 LOC** | **~14,000 LOC** |
+---
 
-Result: Smaller than CoffeeScript, yet includes a complete **reactive framework** with signals, derived values, effects, templates, and components.
+## The Rip Stack
 
----
+Rip includes optional packages for full-stack development:
 
-## Runtime Compatibility
+| Package | Purpose | Lines |
+|---------|---------|-------|
+| [@rip-lang/api](packages/api/) | Web framework (Sinatra-style) | ~595 |
+| [@rip-lang/server](packages/server/) | Multi-worker process manager | ~1,110 |
+| [@rip-lang/db](packages/db/) | DuckDB HTTP server | ~225 |
+| [@rip-lang/schema](packages/schema/) | ORM with reactive models | ~420 |
 
-**Runs everywhere:** Bun (first-class), Node.js 12+, Deno, modern browsers.
+```bash
+bun add @rip-lang/api @rip-lang/server
+```
 
-Output uses ES2022: classes, `let`/`const`, `?.`, `??`, `for await`, top-level await.
+[Full stack documentation →](packages/README.md)
 
 ---
 
 ## Quick Reference
 
 ```bash
-rip                    # Interactive REPL
-rip file.rip           # Run a file
-rip -c file.rip        # Compile to JavaScript
-rip -s file.rip        # Show S-expressions (debug parser)
-rip -t file.rip        # Show tokens (debug lexer)
-bun run test           # Run all 1046 tests
-bun run parser         # Rebuild parser (self-hosting!)
+rip                    # REPL
+rip file.rip           # Run
+rip -c file.rip        # Compile
+rip -t file.rip        # Tokens
+rip -s file.rip        # S-expressions
+bun run test           # 979 tests
+bun run parser         # Rebuild parser
 bun run browser        # Build browser bundle
 ```
 
@@ -393,12 +250,11 @@ bun run browser        # Build browser bundle
 
 | Guide | Description |
 |-------|-------------|
-| [AGENT.md](AGENT.md) | Complete developer/AI guide |
-| [docs/GUIDE.md](docs/GUIDE.md) | Language guide (reactivity, templates, components) |
-| [docs/INTERNALS.md](docs/INTERNALS.md) | Compiler architecture, S-expressions |
-| [docs/BROWSER.md](docs/BROWSER.md) | Browser usage, REPL |
+| [docs/GUIDE.md](docs/GUIDE.md) | Language guide |
+| [docs/REACTIVITY.md](docs/REACTIVITY.md) | Reactivity deep dive |
+| [docs/INTERNALS.md](docs/INTERNALS.md) | Compiler architecture |
+| [packages/](packages/README.md) | Full-stack packages |
 | [CONTRIBUTING.md](CONTRIBUTING.md) | How to contribute |
-| [CHANGELOG.md](CHANGELOG.md) | Version history |
 
 ---
 
@@ -408,7 +264,7 @@ bun run browser        # Build browser bundle
 { "dependencies": {} }
 ```
 
-Everything included: compiler, parser generator (solar.rip), REPL, browser bundle, test framework. Rip compiles itself — `bun run parser` rebuilds from source.
+Everything included: compiler, parser generator, REPL, browser bundle, test framework.
 
 ---
 
@@ -416,24 +272,12 @@ Everything included: compiler, parser generator (solar.rip), REPL, browser bundl
 
 > *Simplicity scales.*
 
-Keep the IR simple (S-expressions), keep the pipeline clear (lex → parse → generate), keep the code minimal. Test everything.
+Simple IR (S-expressions), clear pipeline (lex → parse → generate), minimal code, comprehensive tests.
 
 ---
 
-## Credits
+**Inspired by:** CoffeeScript, Lisp, Ruby | **Powered by:** [Bun](https://bun.sh)
 
-**Inspired by:** CoffeeScript (syntax), Lisp/Scheme (S-expressions), Ruby (regex operators, `__DATA__`), Solar (parser generator).
+MIT License
 
-**Powered by:** [Bun](https://bun.sh) — the fast all-in-one JavaScript runtime.
-
----
-
-## License
-
-MIT
-
----
-
-<p align="center">
-  <strong>Start simple. Build incrementally. Ship elegantly.</strong> ✨
-</p>
+<p align="center"><strong>Start simple. Build incrementally. Ship elegantly.</strong></p>