rip-lang 2.5.0 → 2.7.1

package/CHANGELOG.md

@@ -7,6 +7,49 @@ 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.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
+
+**Hyphenated Attributes Work Directly**:
+```coffee
+render
+  # Before: needed quoted keys or spread syntax
+  i {"data-lucide": "search"}
+
+  # Now: just works!
+  i data-lucide: "search", aria-hidden: "true"
+  div data-testid: "container", aria-label: "Menu"
+  span data-foo-bar-baz: "multiple-hyphens-work"
+```
+
+The lexer now automatically converts hyphenated attribute names (like `data-*`, `aria-*`) into quoted strings, making HTML-style data attributes intuitive and clean.
+
+---
+
 ## [2.5.0] - 2026-01-16
 
 ### Major Release - Parser Optimization + Complete Framework
@@ -156,7 +199,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 |
@@ -167,7 +210,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
@@ -272,10 +315,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
@@ -297,8 +340,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:`
@@ -312,8 +355,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,27 +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.0-blue.svg" alt="Version"></a>
+  <a href="CHANGELOG.md"><img src="https://img.shields.io/badge/version-2.7.1-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.
+> **No imports. No hooks. No dependency arrays. Just write code.**
 
-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 (17,760 LOC) while including a complete reactive framework with signals, templates, and components.
+```coffee
+data = fetchUsers!                  # Dammit operator (call + await)
+user = User.new name: "Alice"       # Ruby-style constructor
+squares = (x * x for x in [1..10])  # List comprehension
+
+str =~ /Hello, (\w+)/               # Regex match
+log "Found: #{_[1]}"                # Captures in _[1], _[2], etc.
+```
+
+---
 
 **What makes Rip different:**
-- **Reactive primitives** — signals, derived values, and effects built into the language
 - **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
 
@@ -33,229 +43,150 @@ The compiler is completely standalone with zero dependencies, and it's self-host
 
 ## Installation
 
-**Option 1: Install from npm**
-```bash
-curl -fsSL https://bun.sh/install | bash   # Install Bun (if needed)
-bun add -g rip-lang
-```
-
-**Option 2: Clone from source**
 ```bash
-git clone https://github.com/shreeve/rip-lang.git
-cd rip-lang && bun link
+bun add -g rip-lang            # Install globally
 ```
 
-**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
 ```
 
----
+### Reactivity
 
-## 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!**
+State, computed values, and effects as language 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 |
 
-## Reactivity
+---
 
-Built into the language, not a library:
+## New Operators
 
-```coffee
-# Signals hold reactive state
-count := 0
-name := "world"
+| 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 |
 
-# Derived values auto-update
-doubled ~= count * 2
-greeting ~= "Hello, #{name}!"
+**Optional chaining** — Both CoffeeScript and ES6 styles are supported:
 
-# Effects run when dependencies change
-effect -> console.log greeting
+| 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)` |
 
-name = "Rip"   # Effect runs → "Hello, Rip!"
-count = 5      # Nothing (greeting doesn't depend on count)
-```
+### Heredoc & Heregex
 
-[Full reactivity guide →](docs/REACTIVITY.md)
+**Heredoc** — The closing `'''` position sets the left margin (smart dedent):
 
----
-
-## Components
+```coffee
+html = '''
+    <div>
+      <p>Hello</p>
+    </div>
+  '''
+# Result: "  <div>\n    <p>Hello</p>\n  </div>" (note the leading 2 spaces)
+```
 
-Build reactive UIs with fine-grained DOM updates:
+**Heregex** — Extended regex with comments and whitespace:
 
 ```coffee
-component Counter
-  @label = "Count"
-  count := 0
-  inc: -> count += 1
-  dec: -> count -= 1
-
-  render
-    div.counter
-      h2 @label
-      span.value count
-      button @click: @inc, "+"
-      button @click: @dec, "−"
+pattern = ///
+  ^(\d{3})    # area code
+  -(\d{4})    # number
+///
 ```
 
-**Event handlers** — two patterns:
-```coffee
-# Normal: define methods, reference with @
-inc: -> count += 1
-button @click: @inc, "+"
+---
 
-# Compact: inline with fat arrow (parens required)
-button (@click: => @count++), "+"
-```
+## vs React / Vue / Solid
 
-**Features:**
-- Props: `@prop`, `@prop?` (optional), `@prop = default`
-- Lifecycle: `mounted:`, `unmounted:`
-- Context API: `setContext`, `getContext`
-- Fine-grained updates: only changed nodes update, no virtual DOM
+| Concept | React | Vue | Solid | Rip |
+|---------|-------|-----|-------|-----|
+| State | `useState()` | `ref()` | `createSignal()` | `x := 0` |
+| Computed | `useMemo()` | `computed()` | `createMemo()` | `x ~= y * 2` |
+| Effect | `useEffect()` | `watch()` | `createEffect()` | `~> body` |
 
-[Component guide →](docs/COMPONENTS.md)
+Rip's reactivity is framework-agnostic — use it with React, Vue, Svelte, or vanilla JS.
 
 ---
 
-## Templates
+## vs CoffeeScript
 
-Indentation-based HTML with CSS-style selectors:
-
-```coffee
-render
-  div#app.container
-    h1.title "Hello, #{name}!"
-    input value: username, @input: updateName
-    button.("btn", active && "primary") @click: submit
-      "Submit"
-    ul.items
-      for item in items
-        li key: item.id, item.name
-```
+| 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 |
 
-- `div#id.class1.class2` — IDs and classes
-- `@click: @handler` — Event handlers (method reference)
-- `(@click: => @count++)` — Inline handlers (fat arrow, parens required)
-- `.("class1", cond && "class2")` — Dynamic classes (Tailwind-friendly)
-- `value <=> var` — Two-way binding
-
-[Template guide →](docs/TEMPLATES.md)
+Smaller codebase, modern output, built-in reactivity.
 
 ---
 
-## Browser Support
-
-Run Rip directly in the browser (51KB compressed—complete language + reactive framework).
+## Browser
 
-**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>
@@ -266,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
-```
+**Try it live:** [shreeve.github.io/rip-lang](https://shreeve.github.io/rip-lang/)
 
 ---
 
-## 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 |
-
----
-
-## 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 */ }
-}
-```
-
-**Rip's approach:**
-```javascript
-case '+': return `(${gen(left)} + ${gen(right)})`;
-```
+Simple arrays instead of AST node classes. The compiler is self-hosting — `bun run parser` rebuilds from source.
 
-| 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 1033 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
 ```
 
@@ -347,12 +250,11 @@ bun run browser        # Build browser bundle
 
 | Guide | Description |
 |-------|-------------|
-| [AGENT.md](AGENT.md) | Complete developer/AI guide |
-| [docs/REACTIVITY.md](docs/REACTIVITY.md) | Signals, effects, derived values |
-| [docs/COMPONENTS.md](docs/COMPONENTS.md) | Component system |
-| [docs/TEMPLATES.md](docs/TEMPLATES.md) | Template DSL |
+| [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 |
 
 ---
 
@@ -362,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.
 
 ---
 
@@ -370,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).
-
-**Powered by:** [Bun](https://bun.sh) — the fast all-in-one JavaScript runtime.
-
----
+MIT License
 
-## 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>

package/docs/BROWSER.md

@@ -2,9 +2,9 @@
 
 # Rip in the Browser
 
-**Complete Language + Reactive Framework in 51KB**
+**Complete Language + Reactive Runtime in 51KB**
 
-Rip compiles to modern JavaScript and runs beautifully in the browser. With brotli compression, the entire package—compiler, reactive runtime, template engine, and component system—fits in just **51KB**. That's a complete framework in less space than most utility libraries!
+Rip compiles to modern JavaScript and runs beautifully in the browser. With brotli compression, the entire package—compiler and reactive runtime—fits in just **51KB**. That's a complete language in less space than most utility libraries!
 
 ---
 
@@ -18,16 +18,14 @@ rip.browser.min.js.br   51 KB  (brotli, 91% smaller!)
 
 **What's in that 51KB?**
 - Complete compiler (lexer, parser, code generator)
-- Reactive runtime (signals, derived values, effects)
-- Template engine (S-expression syntax, dynamic classes)
-- Component system (props, lifecycle, fine-grained updates)
+- Reactive runtime (state, computed values, effects)
 - Zero dependencies
 
 **For comparison:**
 - React (min+gzip): ~42KB (just the library, no compiler)
 - Vue (min+gzip): ~34KB (just the library, no compiler)
 - Svelte: ~2KB runtime (but requires build step + compiler)
-- **Rip: 51KB (complete language + framework, runs anywhere!)**
+- **Rip: 51KB (complete language + reactive runtime, runs anywhere!)**
 
 ---
 
@@ -900,11 +898,10 @@ See the `docs/examples/` directory for working demos:
 - More features than most frameworks, smaller than most libraries
 - Fast loading even on mobile
 
-**2. Complete Framework**
-- Reactive primitives (signals, derived, effects)
-- S-expression templates with fine-grained updates
-- Component system with props and lifecycle
+**2. Complete Language**
+- Reactive primitives (state, computed, effects)
 - Modern ES6+ output
+- Framework-agnostic — use with any UI library
 
 **3. Zero Build Step**
 - Write Rip directly in HTML
@@ -965,7 +962,7 @@ Then serve `node_modules/rip-lang/dist/rip.browser.min.js`
 **Rip in the browser gives you:**
 
 ✅ **51KB** - Complete language + reactive framework (brotli)
-✅ **Reactivity** - Signals, derived values, effects
+✅ **Reactivity** - State, computed values, effects
 ✅ **Templates** - S-expression syntax, fine-grained DOM updates
 ✅ **Components** - Props, lifecycle, zero virtual DOM
 ✅ **Triple REPL** - Terminal, Browser, Console