rip-lang 3.7.4 → 3.8.9

package/CHANGELOG.md

@@ -7,7 +7,112 @@ 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).
 
-## [3.7.4] - 2026-02-11
+## [3.8.9] - 2026-02-16
+
+### Compiler — Grammar Desugaring & Cleanup
+
+- **`until` desugared to `while`** — Grammar now emits `["while", ["!", cond], ...]` directly, eliminating `generateUntil` from the compiler. Also fixes the `until...when` guard bug where the guard expression was silently dropped.
+- **`unless` desugared to `if`** — Grammar now emits `["if", ["!", cond], ...]` for all `unless` forms, removing ~20 `unless`-specific code paths from the compiler (dispatch table, postfix conditionals, assignment handlers, return/throw handlers, control flow analysis).
+- **`toSearchable` renamed to `toMatchable`** — The regex helper name now matches the `.match()` API it wraps.
+- **Added missing `%%=` handler** — The mathematical modulo assignment operator now works correctly instead of crashing during code generation.
+
+## [3.8.8] - 2026-02-16
+
+### Compiler — Refactoring & Cleanup
+
+- **Comprehension generator deduplication** — Extracted shared `_forInHeader`, `_forOfHeader`, and `_forAsHeader` helpers, consolidating loop header construction across `generateComprehension`, `generateComprehensionWithTarget`, and `generateComprehensionAsLoop`.
+- **Cleaner for-of loop output** — `for own k of obj` now generates flatter JavaScript using `continue` guard clauses instead of nested `if` blocks.
+- **Component child deduplication** — Extracted `appendChildren` helper in `components.js`, consolidating duplicate child-processing logic from `generateTag` and `generateDynamicTag`. Also fixed a missing `componentMembers` check in `generateDynamicTag`.
+- **Dead code removal** — Removed unused `break-if` and `continue-if` compiler handlers (the grammar handles these through the normal `if` path).
+
+### REPL — Bug Fix
+
+- **Comprehension crash fix** — The REPL now correctly handles multi-line expressions (comprehensions, IIFEs). Previously, the result capture logic produced broken JavaScript by prepending `__result =` to the closing `})();` line instead of the expression start.
+
+### Documentation
+
+- Fixed inaccurate content on the Rip UI demo About page (compiler/framework sizes, architecture description).
+
+## [3.8.7] - 2026-02-14
+
+Rip UI loading optimization (combined bundle, build-time compilation, FOUC prevention). See `packages/ui/CHANGELOG.md` v0.3.2.
+
+## [3.8.6] - 2026-02-13
+
+### Compiler — Render Block Fix
+
+- **Render block fix** — Identifiers matching HTML tag names (e.g., `title`) are no longer misclassified as template elements when preceded by control flow keywords (`if`, `unless`, `while`, `until`, `when`).
+
+Rip UI hash routing and static demo. See `packages/ui/CHANGELOG.md` v0.3.1.
+
+## [3.8.5] - 2026-02-13
+
+### Build — GitHub Pages Fixes
+
+- **Copy ui.rip instead of symlink** — `bun run browser` now copies `packages/ui/ui.rip` to `docs/dist/ui.rip` on every build. Symlinks return 404 on GitHub Pages.
+- Fixed Async example to use clean chained `!` syntax now that precedence is correct.
+
+## [3.8.4] - 2026-02-13
+
+### Compiler — Chained Dammit Operator Fix
+
+- **Chained `!` parenthesization** — `fetch!(url).json!` now correctly compiles to `await (await fetch(url)).json()` instead of `await await fetch(url).json()` which had wrong JS precedence. The `await` from `!` metadata is now parenthesized when used as a property access base.
+- Playground Async example restored to clean `fetch!(url).json!` syntax.
+- 2 new tests (1,241 total).
+
+## [3.8.3] - 2026-02-13
+
+### Lexer — Heregex Forward Slash Escaping
+
+- **Auto-escape `/` in heregex** — Forward slashes inside `///...///` are now automatically escaped to `\/` in the compiled regex literal. Previously required manual `\/` escaping, defeating the purpose of heregex.
+- 1 new test (1,239 total).
+
+## [3.8.2] - 2026-02-13
+
+### Compiler — Class Constructor Fixes
+
+- **`@param` defaults in constructors** — `constructor: (@count = 0) ->` now correctly compiles to `constructor(count = 0) { this.count = count; }` instead of producing invalid `(.,this,count)` syntax.
+- **`super` with `@param` in subclass constructors** — `constructor: (@name) -> super @name, "woof"` now compiles to `constructor(_name) { super(_name, "woof"); this.name = _name; }` using a temporary parameter to avoid illegal `this` access before `super()`.
+- **Single-expression constructor autoAssignments** — `@param` assignments are now emitted in single-expression constructor bodies (previously only worked in block bodies).
+- 3 new tests (1,238 total).
+
+## [3.8.1] - 2026-02-13
+
+### Playground — Fix Class Examples
+
+- **Constructor syntax fix** — All playground examples now use `constructor: (@name) ->` instead of the bare `(@name) ->` shorthand, which produced invalid JS output.
+
+## [3.8.0] - 2026-02-12
+
+### Playground — Example Snippets & Source Persistence
+
+- **Example snippets dropdown** — 6 curated examples (Basics, Reactive State, Classes, Regex & Strings, Async & Dammit, Full Demo) plus a Custom option for user code.
+- **Source persistence** — Editor content saved to localStorage with 2-second debounce, restored on page load.
+- **Auto-switch to Custom** — Editing code after selecting an example automatically switches the dropdown to Custom.
+- Applied to all three playground versions (playground-rip.html, playground-js.html, playground-rip-ui.html).
+
+### Language — Raw Heredocs
+
+- **Raw heredocs (`'''\` and `"""\`)** — Appending `\` to a heredoc opener keeps JS escape sequences (`\n`, `\t`, `\u`, `\x`, `\\`) literal in the output.
+- **`.class` shorthand fix** — `div.foo` or `.foo` with indented children in render blocks now produces correct JS.
+
+### Parser — Recursive Descent Generator
+
+- **Lunar grammar** (`src/grammar/lunar.rip`) — New recursive descent parser generator producing `src/parser-rd.js`.
+- **98.3% test parity** — 1,162 of 1,182 tests passing with the generated parser.
+
+## [3.7.4] - 2026-02-12
+
+### Compiler — Reactive Scoping & Component Fixes
+
+- **Effect cleanup** — `__effect` now captures return values as cleanup functions, run before re-execution and on disposal. Backward-compatible.
+- **Component scope leak** — `collectProgramVariables` no longer recurses into component bodies. Inner `:=` variables don't pollute the outer scope.
+- **Object key reactive transform** — Object literal keys are no longer transformed to `key.value` when the key name matches a reactive variable.
+- **Component effect index** — Fixed `effect[1]` → `effect[2]` for the body of `~>` in components.
+- **Component effect wrapping** — Effects now wrapped in `() => { expr; }` for proper reactivity.
+- **Dot-chain property names** — `app.data.count` no longer transforms `count` as a reactive member when it's a property name in a dot chain.
+- **Reactive prop passthrough** — `buildComponentProps` passes `:=` members as signals (not values) to child components. Child's `__state` returns the signal as-is.
+- **Child unmounting** — `generateChildComponent` tracks child instances in `_children`. `__Component.unmount()` cascades depth-first.
 
 ### Compiler — Nested Function Scope Chain
 

package/README.md

@@ -9,15 +9,15 @@
 </p>
 
 <p align="center">
-  <a href="CHANGELOG.md"><img src="https://img.shields.io/badge/version-3.7.4-blue.svg" alt="Version"></a>
+  <a href="CHANGELOG.md"><img src="https://img.shields.io/badge/version-3.8.9-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-1225%2F1225-brightgreen.svg" alt="Tests"></a>
+  <a href="#"><img src="https://img.shields.io/badge/tests-1%2C242%2F1%2C242-brightgreen.svg" alt="Tests"></a>
   <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-green.svg" alt="License"></a>
 </p>
 
 ---
 
-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,800 lines of code.
+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 11,000 lines of code.
 
 > **No imports. No hooks. No dependency arrays. Just write code.**
 
@@ -146,9 +146,9 @@ 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 |
+| `:=` | "gets state" | `count := 0` | Reactive state container |
 | `~=` | "always equals" | `twice ~= count * 2` | Auto-updates on changes |
-| `~>` | "reacts to" | `~> log count` | Runs on dependency changes |
+| `~>` | "always calls" | `~> log count` | Runs on dependency changes |
 | `=!` | "equals, dammit!" | `MAX =! 100` | Readonly constant |
 
 ---
@@ -227,6 +227,16 @@ html = '''
 # Result: "  <div>\n    <p>Hello</p>\n  </div>"
 ```
 
+**Raw heredoc** — Append `\` to the opening delimiter (`'''\` or `"""\`) to prevent escape processing. Backslash sequences like `\n`, `\t`, `\u` stay literal:
+
+```coffee
+script = '''\
+  echo "hello\nworld"
+  sed 's/\t/  /g' file.txt
+  \'''
+# \n and \t stay as literal characters, not newline/tab
+```
+
 **Heregex** — Extended regex with comments and whitespace:
 
 ```coffee
@@ -252,7 +262,7 @@ Rip's reactivity is framework-agnostic — use it with React, Vue, Svelte, or va
 
 ## Rip UI
 
-Ship the 40KB Rip compiler to the browser. Components are `.rip` source files, compiled on demand, rendered with fine-grained reactivity. No build step. No bundler.
+Ship the ~47KB Rip compiler to the browser. Components are `.rip` source files, compiled on demand, rendered with fine-grained reactivity. No build step. No bundler.
 
 ```coffee
 Counter = component
@@ -267,7 +277,7 @@ Counter = component
 
 Two keywords — `component` and `render` — are all the language adds. Everything else (`:=` state, `~=` computed, methods, lifecycle) is standard Rip.
 
-See [@rip-lang/ui](packages/ui/) for the full framework: file-based router, reactive stash, component store, and renderer.
+See [@rip-lang/ui](packages/ui/) for the full framework: file-based router, reactive stash, component store, and renderer. **[Try the demo](https://shreeve.github.io/rip-lang/demo.html)** — a complete app in one HTML file.
 
 ---
 
@@ -279,9 +289,9 @@ See [@rip-lang/ui](packages/ui/) for the full framework: file-based router, reac
 | **Reactivity** | None | Built-in |
 | **Dependencies** | Multiple | Zero |
 | **Self-hosting** | No | Yes |
-| **Lexer** | 3,558 LOC | 1,958 LOC |
-| **Compiler** | 10,346 LOC | 3,378 LOC |
-| **Total** | 17,760 LOC | ~10,800 LOC |
+| **Lexer** | 3,558 LOC | 2,024 LOC |
+| **Compiler** | 10,346 LOC | 3,289 LOC |
+| **Total** | 17,760 LOC | ~11,000 LOC |
 
 Smaller codebase, modern output, built-in reactivity.
 
@@ -316,25 +326,25 @@ await rip("res = fetch! 'https://api.example.com/todos/1'; res.json!")  // → {
 
 ```
 Source  ->  Lexer  ->  emitTypes  ->  Parser  ->  S-Expressions  ->  Codegen  ->  JavaScript
-           (1,958)    (types.js)     (359)       ["=", "x", 42]     (3,378)      + source map
+           (2,024)    (types.js)     (359)       ["=", "x", 42]     (3,431)      + source map
 ```
 
 Simple arrays (with `.loc`) instead of AST node classes. The compiler is self-hosting — `bun run parser` rebuilds from source.
 
 | Component | File | Lines |
 |-----------|------|-------|
-| Lexer + Rewriter | `src/lexer.js` | 1,958 |
-| Compiler + Codegen | `src/compiler.js` | 3,378 |
+| Lexer + Rewriter | `src/lexer.js` | 2,024 |
+| Compiler + Codegen | `src/compiler.js` | 3,431 |
 | Type System | `src/types.js` | 1,099 |
-| Component System | `src/components.js` | 1,240 |
-| Source Maps | `src/sourcemaps.js` | 122 |
+| Component System | `src/components.js` | 1,281 |
+| Source Maps | `src/sourcemaps.js` | 121 |
 | Parser (generated) | `src/parser.js` | 359 |
-| Grammar | `src/grammar/grammar.rip` | 945 |
-| Parser Generator | `src/grammar/solar.rip` | 916 |
+| Grammar | `src/grammar/grammar.rip` | 944 |
+| Parser Generator | `src/grammar/solar.rip` | 929 |
 | REPL | `src/repl.js` | 582 |
-| Browser Entry | `src/browser.js` | 119 |
-| Tags | `src/tags.js` | 63 |
-| **Total** | | **~10,774** |
+| Browser Entry | `src/browser.js` | 125 |
+| Tags | `src/tags.js` | 62 |
+| **Total** | | **~10,957** |
 
 ---
 
@@ -344,14 +354,14 @@ Rip includes optional packages for full-stack development:
 
 | Package | Version | Purpose |
 |---------|---------|---------|
-| [rip-lang](https://www.npmjs.com/package/rip-lang) | 3.7.4 | Core language compiler |
-| [@rip-lang/api](packages/api/) | 1.1.4 | HTTP framework (Sinatra-style routing, 37 validators) |
-| [@rip-lang/server](packages/server/) | 1.1.3 | Multi-worker app server (hot reload, HTTPS, mDNS) |
-| [@rip-lang/db](packages/db/) | 1.1.2 | DuckDB server with official UI (pure Bun FFI) |
-| [@rip-lang/ui](packages/ui/) | 0.2.0 | Zero-build reactive web framework (stash, router, components) |
-| [@rip-lang/swarm](packages/swarm/) | 1.1.1 | Parallel job runner with worker pool |
-| [@rip-lang/csv](packages/csv/) | 1.1.1 | CSV parser + writer |
-| [@rip-lang/schema](packages/schema/) | 0.1.0 | ORM + validation |
+| [rip-lang](https://www.npmjs.com/package/rip-lang) | 3.8.9 | Core language compiler |
+| [@rip-lang/api](packages/api/) | 1.1.6 | HTTP framework (Sinatra-style routing, 37 validators) |
+| [@rip-lang/server](packages/server/) | 1.1.5 | Multi-worker app server (hot reload, HTTPS, mDNS) |
+| [@rip-lang/db](packages/db/) | 1.1.4 | DuckDB server with official UI (pure Bun FFI) |
+| [@rip-lang/ui](packages/ui/) | 0.3.2 | Zero-build reactive web framework (stash, router, hash routing) |
+| [@rip-lang/swarm](packages/swarm/) | 1.1.3 | Parallel job runner with worker pool |
+| [@rip-lang/csv](packages/csv/) | 1.1.3 | CSV parser + writer |
+| [@rip-lang/schema](packages/schema/) | 0.1.1 | ORM + validation |
 | [VS Code Extension](packages/vscode/) | 0.3.1 | Syntax highlighting, type intelligence, source maps |
 
 ```bash
@@ -390,7 +400,7 @@ rip file.rip           # Run
 rip -c file.rip        # Compile
 rip -t file.rip        # Tokens
 rip -s file.rip        # S-expressions
-bun run test           # 1225 tests
+bun run test           # 1241 tests
 bun run parser         # Rebuild parser
 bun run browser        # Build browser bundle
 ```
@@ -401,12 +411,10 @@ bun run browser        # Build browser bundle
 
 | Guide | Description |
 |-------|-------------|
-| [docs/RIP-GUIDE.md](docs/RIP-GUIDE.md) | Users / AI — practical guide for using Rip in projects |
+| [docs/RIP-LANG.md](docs/RIP-LANG.md) | Full language reference (syntax, operators, reactivity, types, future ideas) |
+| [docs/RIP-INTERNALS.md](docs/RIP-INTERNALS.md) | Compiler architecture (lexer, parser, codegen, S-expressions) |
+| [docs/RIP-TYPES.md](docs/RIP-TYPES.md) | Type system specification |
 | [AGENT.md](AGENT.md) | AI agents — get up to speed for working on the compiler |
-| [docs/RIP-LANG.md](docs/RIP-LANG.md) | Users — full language reference |
-| [docs/RIP-TYPES.md](docs/RIP-TYPES.md) | Contributors — type system specification |
-| [docs/RIP-REACTIVITY.md](docs/RIP-REACTIVITY.md) | Users — reactivity deep dive |
-| [docs/RIP-INTERNALS.md](docs/RIP-INTERNALS.md) | Contributors — compiler architecture |
 
 ---
 

package/docs/RIP-INTERNALS.md

@@ -572,11 +572,9 @@ rip> .js      # Toggle JS display
 ---
 
 **See Also:**
-- [RIP-GUIDE.md](RIP-GUIDE.md) — Practical guide for using Rip
-- [RIP-LANG.md](RIP-LANG.md) — Language reference
+- [RIP-LANG.md](RIP-LANG.md) — Language reference (includes reactivity deep dive)
 - [RIP-TYPES.md](RIP-TYPES.md) — Type system specification
-- [RIP-REACTIVITY.md](RIP-REACTIVITY.md) — Reactivity deep dive
 
 ---
 
-*Rip 3.7 — 1,219 tests passing — Zero dependencies — Self-hosting — ~10,800 LOC*
+*Rip 3.8 — 1,241 tests passing — Zero dependencies — Self-hosting — ~11,000 LOC*

package/docs/RIP-LANG.md

@@ -23,6 +23,7 @@ Rip is a modern reactive language that compiles to ES2022 JavaScript. It combine
 13. [JavaScript Interop](#13-javascript-interop)
 14. [Common Patterns](#14-common-patterns)
 15. [Quick Reference](#15-quick-reference)
+16. [Future Ideas](#16-future-ideas)
 
 ---
 
@@ -84,6 +85,11 @@ multiline = """
   """
 # Result: "This is a\nmulti-line string" (closing """ at col 2 strips 2 spaces)
 
+# Raw heredocs — append \ to keep escape sequences literal
+script = '''\
+  echo "hello\nworld"   # \n stays as \n, not a newline
+  \'''
+
 # Numbers
 count = 42
 price = 19.99
@@ -697,9 +703,9 @@ Rip's reactive features are **language-level operators**, not library imports.
 | Operator | Name | Read as | Purpose |
 |----------|------|---------|---------|
 | `=` | Assign | "gets value" | Regular assignment |
-| `:=` | State | "has state" | Reactive state variable |
+| `:=` | State | "gets state" | Reactive state variable |
 | `~=` | Computed | "always equals" | Computed value (auto-updates) |
-| `~>` | Effect | "reacts to" | Side effect on dependency change |
+| `~>` | Effect | "always calls" | Side effect on dependency change |
 | `=!` | Readonly | "equals, dammit!" | Constant (`const`) |
 
 ## State (`:=`)
@@ -829,6 +835,64 @@ __effect(() => { console.log(count.value); });
 
 The reactive runtime is **automatically inlined** when needed. Non-reactive code produces clean output with no runtime overhead.
 
+## Effect Cleanup
+
+Effects may return a cleanup function that runs before re-execution and on disposal:
+
+```coffee
+~>
+  id = setInterval tick, 1000
+  -> clearInterval id              # cleanup: returned arrow function
+```
+
+This enables higher-level reactive utilities — without adding anything to the language.
+
+## Timing Primitives
+
+Unlike React's `useTransition` or Vue's flush modes, Rip does not add timing to the framework. Timing composes from the triad:
+
+```coffee
+# Delay — truthy after source is stable for N ms, falsy immediately
+showLoading := delay 200 -> loading
+
+# Debounce — propagates after value stops changing for N ms
+debouncedQuery := debounce 300 -> query
+
+# Throttle — at most one update per N ms
+smoothScroll := throttle 100 -> scrollY
+
+# Hold — once true, stays true for at least N ms
+showSaved := hold 2000 -> saved
+```
+
+All four are implemented using `:=` (output signal) + `~>` (watches source, manages timers) + effect cleanup (cancels pending timers). No new compiler features, no scheduler.
+
+### Writable Timing Signals
+
+Timing utilities can wrap a source signal directly:
+
+```coffee
+navigating = delay 100, __state(false)
+```
+
+Reads return the delayed value; writes update the source immediately. A drop-in replacement for `__state` with asymmetric behavior.
+
+## Types and Reactivity
+
+Reactive operators work with Rip's optional type system:
+
+```coffee
+count:: number := 0               # Typed state
+doubled:: number ~= count * 2     # Typed computed
+```
+
+Type annotations are erased from `.js` output. In `.d.ts` output, reactive state emits `Signal<T>` and computed values emit `Computed<T>`:
+
+```ts
+declare const count: Signal<number>;
+declare const doubled: Computed<number>;
+```
+
 ---
 
 # 7. Async Patterns
@@ -1383,4 +1447,87 @@ count = 10  # Logs: "Count: 10, Doubled: 20"
 
 ---
 
-*Rip 3.7 — 1,219 tests passing — Zero dependencies — Self-hosting — ~10,800 LOC*
+# 16. Future Ideas
+
+Ideas and candidates that have been discussed but not yet implemented.
+
+## Standard Library (`stdlib`)
+
+Rip is a zero-dependency language, but a small standard library of useful
+utilities would save users from writing the same one-liners in every project.
+These are **not** language features — they're plain functions that could ship
+as a prelude or optional import.
+
+### Candidates
+
+```coffee
+# Printing (Ruby's p)
+p = console.log
+
+# Exit with optional code (uses implicit `it`)
+exit = -> process.exit(it)
+
+# Tap — call a function for side effects, return the original value
+# Useful in pipe chains: data |> tap(console.log) |> process
+tap = (v, fn) -> fn(v); v
+
+# Identity — returns its argument unchanged
+# Useful as a default callback: items.filter(id)
+id = -> it
+
+# No-op — does nothing
+# Useful as a default handler: onClick ?= noop
+noop = ->
+
+# String method aliases (shorter names for common checks)
+String::starts = String::startsWith
+String::ends   = String::endsWith
+String::has    = String::includes
+
+# Clamp a value to a range
+clamp = (v, lo, hi) -> Math.min(Math.max(v, lo), hi)
+
+# Sleep for N milliseconds (returns a Promise)
+sleep = (ms) -> new Promise (resolve) -> setTimeout resolve, ms
+
+# Times helper — call a function N times, collect results
+times = (n, fn) -> (fn(i) for i in [0...n])
+```
+
+### Design Questions
+
+- **Prelude vs import?** Should these be injected automatically (like Go's
+  `fmt` or Rip's reactive runtime), or explicitly imported (`import { p, tap }
+  from '@rip-lang/std'`)? Leaning toward explicit — Rip's philosophy is zero
+  magic in the output.
+
+- **Scope?** Keep it tiny. A stdlib that grows to 500 functions defeats the
+  purpose. Each entry should save real keystrokes on something people do
+  constantly.
+
+- **Node vs Browser?** Some helpers (like `exit`) are Node-only. Others (like
+  `p`, `tap`, `sleep`) work everywhere. May want to split into `std` (universal)
+  and `std/node` (server-only).
+
+## Future Syntax Ideas
+
+Each would need design discussion before building.
+
+- **`defer`** — Go-style cleanup that runs when the function exits. Compiles
+  to try/finally. `defer file.close()`.
+
+- **Pattern matching** — `match value` with destructuring arms. Big feature,
+  needs careful design.
+
+- **Reactive resource operator (`~>?`)** — Language-level `createResource`.
+  `user ~>? fetch!("/api/users/#{id}").json!` gives `user.loading`,
+  `user.error`, `user.data`. Park until real-world usage shows demand.
+
+- **Pipe operator (`|>`) — Hack-style placeholder** — Currently Rip uses
+  Elixir-style first-arg insertion. A `%` placeholder for arbitrary position
+  (`data |> fn(1, %, 3)`) could be added later if needed. Current design
+  covers 95%+ of cases.
+
+---
+
+*Rip 3.8 — 1,241 tests passing — Zero dependencies — Self-hosting — ~11,000 LOC*

package/docs/RIP-TYPES.md

@@ -1977,6 +1977,5 @@ The type system uses a two-phase approach:
 ---
 
 **See Also:**
-- [RIP-LANG.md](RIP-LANG.md) — Language reference
-- [RIP-REACTIVITY.md](RIP-REACTIVITY.md) — Reactive system details
+- [RIP-LANG.md](RIP-LANG.md) — Language reference (includes reactivity and types)
 - [RIP-INTERNALS.md](RIP-INTERNALS.md) — Compiler internals