rip-lang 2.9.0 → 2.9.2

package/CHANGELOG.md

@@ -7,6 +7,45 @@ 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.9.0] - 2026-02-05
+
+### Compiler Fix
+
+- **Interpolated string object keys**: `{"#{k}": v}` now correctly compiles to `{[\`${k}\`]: v}` instead of invalid `{\`${k}\`: v}`. Template literals in object key position are wrapped in computed property syntax.
+
+### @rip-lang/db — DuckDB Server with Official UI
+
+Major milestone: complete DuckDB HTTP server with the official DuckDB UI.
+
+- **Pure Bun FFI driver** — Direct calls to DuckDB's C API, no npm packages, no Zig
+- **Modern chunk-based API** — Uses `duckdb_fetch_chunk` + `duckdb_vector_get_data` for direct columnar memory reads. No deprecated `duckdb_value_*` functions.
+- **DuckDB UI loads instantly** — Full binary serialization protocol, proper COOP/COEP headers, SSE keepalive, version handshake
+- **Complete type support** — DECIMAL (exact precision), ENUM (dictionary lookup), UUID (native hugeint), LIST/STRUCT/MAP (child vector traversal), all timestamp variants
+- **Timestamp policy** — All timestamps normalized to UTC Date objects; TIMESTAMPTZ recommended
+- **Binary protocol** — Native 16-byte UUID serialization, uint64-aligned validity bitmaps, proper TypeInfo encoding
+
+### @rip-lang/api — v1.0.0
+
+- Published as stable 1.0.0
+- Polished README with feature table and cross-references
+
+### @rip-lang/server — v1.0.0
+
+- Published as stable 1.0.0
+- Added proper dependencies (rip-lang + @rip-lang/api)
+- Polished README with feature table and cross-references
+
+### Housekeeping
+
+- Removed all Zig code and npm DuckDB dependency from @rip-lang/db
+- Consolidated documentation (DEBUGGING.md + INTERNALS.md → README.md)
+- Dynamic platform detection for DuckDB UI headers
+- Support both `--port=N` and `--port N` argument formats
+- Updated all package dependencies to ^2.9.0
+- Removed bun.lock from git tracking
+
+---
+
 ## [2.7.2] - 2026-02-03
 
 ### Clean ES Module REPL

package/README.md

@@ -72,6 +72,16 @@ class Dog extends Animal
 dog = Dog.new("Buddy")         # Ruby-style constructor
 ```
 
+### String Interpolation
+
+```coffee
+"Hello, #{name}!"              # CoffeeScript-style
+"Hello, ${name}!"              # JavaScript-style
+"#{a} + #{b} = #{a + b}"      # Expressions work in both
+```
+
+Both `#{}` and `${}` compile to JavaScript template literals. Use whichever you prefer.
+
 ### Destructuring & Comprehensions
 
 ```coffee
@@ -136,15 +146,35 @@ State, computed values, and effects as language operators:
 
 ### Heredoc & Heregex
 
-**Heredoc** — The closing `'''` position sets the left margin (smart dedent):
+**Heredoc** — The closing `'''` or `"""` position defines the left margin. All content is dedented relative to the column where the closing delimiter sits:
 
 ```coffee
+html = '''
+    <div>
+      <p>Hello</p>
+    </div>
+    '''
+# Closing ''' is at column 4 (same as content) → no leading whitespace
+# Result: "<div>\n  <p>Hello</p>\n</div>"
+
 html = '''
     <div>
       <p>Hello</p>
     </div>
   '''
-# Result: "  <div>\n    <p>Hello</p>\n  </div>" (note the leading 2 spaces)
+# Closing ''' is at column 2 (2 less than content) → 2 spaces of leading whitespace
+# Result: "  <div>\n    <p>Hello</p>\n  </div>"
+```
+
+Use `"""` for interpolation, `'''` for literal strings. The same margin rule applies to both:
+
+```coffee
+name = "World"
+msg = """
+  Hello, #{name}!
+  Welcome to Rip.
+  """
+# Result: "Hello, World!\nWelcome to Rip."
 ```
 
 **Heregex** — Extended regex with comments and whitespace:

package/docs/BROWSER.md

@@ -166,7 +166,7 @@ Variables:
 Split-pane editor showing real-time compilation:
 
 **Left Pane (Rip):**
-```rip
+```coffee
 def fibonacci(n)
   if n <= 1
     n
@@ -335,7 +335,7 @@ Build tools, playgrounds, or educational apps:
 ### All Rip Features Available
 
 **✅ Modern Syntax:**
-```rip
+```coffee
 # Destructuring
 {name, age} = person
 [first, ...rest] = array
@@ -357,7 +357,7 @@ pattern = ///
 ```
 
 **✅ Ruby-Style Regex:**
-```rip
+```coffee
 # Match operator
 email =~ /(.+)@(.+)/
 domain = _[2]
@@ -367,7 +367,7 @@ zip = "12345-6789"[/^(\d{5})/, 1]  # "12345"
 ```
 
 **✅ Functions:**
-```rip
+```coffee
 # Three styles
 def add(a, b)         # Hoisted
   a + b
@@ -380,7 +380,7 @@ divide = (a, b) =>    # Bound this
 ```
 
 **✅ Classes:**
-```rip
+```coffee
 class Person
   constructor: (@name, @age) ->
 
@@ -389,7 +389,7 @@ class Person
 ```
 
 **✅ Async/Await:**
-```rip
+```coffee
 # Auto-detected!
 fetchData = ->
   response = await fetch(url)
@@ -402,7 +402,7 @@ getData = ->
 ```
 
 **✅ String Interpolation:**
-```rip
+```coffee
 name = "World"
 message = "Hello, #{name}!"
 
@@ -576,7 +576,7 @@ Real-time data processing with clean syntax:
 
 The `toSearchable()` helper includes injection protection:
 
-```rip
+```coffee
 # Safe by default - rejects newlines
 userInput =~ /^[a-z]+$/  # Returns null if input has \n
 

package/docs/GUIDE.md

@@ -483,7 +483,7 @@ Rip extends CoffeeScript with two powerful regex features inspired by Ruby: the
 
 ### Syntax
 
-```rip
+```coffee
 text =~ /pattern/
 ```
 
@@ -496,14 +496,14 @@ text =~ /pattern/
 ### Examples
 
 **Basic matching:**
-```rip
+```coffee
 text = "hello world"
 if text =~ /world/
   console.log("Found:", _[0])  # "world"
 ```
 
 **Capture groups:**
-```rip
+```coffee
 email = "user@example.com"
 if email =~ /(.+)@(.+)/
   username = _[1]  # "user"
@@ -511,7 +511,7 @@ if email =~ /(.+)@(.+)/
 ```
 
 **Phone number parsing:**
-```rip
+```coffee
 phone = "2125551234"
 if phone =~ /^([2-9]\d\d)([2-9]\d\d)(\d{4})$/
   formatted = "(#{_[1]}) #{_[2]}-#{_[3]}"
@@ -522,7 +522,7 @@ if phone =~ /^([2-9]\d\d)([2-9]\d\d)(\d{4})$/
 
 ### Syntax
 
-```rip
+```coffee
 value[/pattern/]      # Returns full match (capture 0)
 value[/pattern/, n]   # Returns capture group n
 ```
@@ -530,17 +530,17 @@ value[/pattern/, n]   # Returns capture group n
 ### Examples
 
 **Simple match:**
-```rip
+```coffee
 "steve"[/eve/]           # Returns "eve"
 ```
 
 **Capture group:**
-```rip
+```coffee
 "steve"[/e(v)e/, 1]      # Returns "v"
 ```
 
 **Email domain:**
-```rip
+```coffee
 domain = "user@example.com"[/@(.+)$/, 1]
 # Returns: "example.com"
 ```
@@ -549,7 +549,7 @@ domain = "user@example.com"[/@(.+)$/, 1]
 
 The real power comes from using both features together:
 
-```rip
+```coffee
 # Parse, validate, and format in clean steps
 email = "Admin@Company.COM"
 if email =~ /^([^@]+)@([^@]+)$/i
@@ -562,7 +562,7 @@ if email =~ /^([^@]+)@([^@]+)$/i
 
 One of the most powerful use cases is building validators:
 
-```rip
+```coffee
 validators =
   # Extract and validate in one expression
   id:       (v) -> v[/^([1-9]\d{0,19})$/] and parseInt(_[1])
@@ -589,7 +589,7 @@ validators =
 
 Rip supports heregexes - extended regular expressions that allow whitespace and comments for readability:
 
-```rip
+```coffee
 pattern = ///
   ^ \d+      # starts with digits
   \s*        # optional whitespace
@@ -607,7 +607,7 @@ pattern = ///
 
 By default, **rejects strings with newlines**:
 
-```rip
+```coffee
 # Safe - rejects malicious input
 userInput = "test\nmalicious"
 userInput =~ /^test$/   # Returns null! (newline detected)
@@ -632,5 +632,5 @@ text =~ /line2/m        # Works! (/m flag allows newlines)
 
 **See Also:**
 - [INTERNALS.md](INTERNALS.md) - Compiler and parser details
-- [PHILOSOPHY.md](PHILOSOPHY.md) - Why Rip exists
+- [RATIONALE.md](RATIONALE.md) - Why Rip exists
 - [BROWSER.md](BROWSER.md) - Browser usage and REPL guide

package/docs/INTERNALS.md

@@ -43,7 +43,7 @@ Source Code → CoffeeScript Lexer → Solar Parser → S-Expressions → Codege
 
 ## Example Flow
 
-```rip
+```coffee
 # Input
 x = 42
 
@@ -320,7 +320,7 @@ generate(sexpr, context = 'statement') {
 
 **Example: Comprehensions**
 
-```rip
+```coffee
 # Statement context (result discarded) → Plain loop
 console.log x for x in arr
 # → for (const x of arr) { console.log(x); }
@@ -364,7 +364,7 @@ fn = function() {
 
 **Functions automatically become async or generators:**
 
-```rip
+```coffee
 # Contains await → becomes async function
 getData = ->
   result = await fetch(url)
@@ -405,7 +405,7 @@ fetchAll = ->
 | `a ??= 10` | ES6 | `a ??= 10` |
 
 **Mix and match:**
-```rip
+```coffee
 obj?.arr?[0]  # ES6 + CoffeeScript together!
 ```
 
@@ -413,7 +413,7 @@ obj?.arr?[0]  # ES6 + CoffeeScript together!
 
 **Traditional for loops instead of wasteful IIFEs:**
 
-```rip
+```coffee
 # Optimized to traditional loop
 for i in [1...100]
   process(i)
@@ -424,7 +424,7 @@ for i in [1...100]
 ```
 
 **Reverse iteration support:**
-```rip
+```coffee
 for i in [10..1] by -1
   process(i)
 # → for (let i = 10; i >= 1; i--) { process(i); }
@@ -472,7 +472,7 @@ Comprehensions can act as **data builders** or **control loops**. Rip distinguis
 - **Benefit:** Automatic optimization - no wasteful array building!
 
 **Example of improvement:**
-```rip
+```coffee
 fn = ->
   process x for x in arr    # ← Rip: plain loop! CS: IIFE (wasteful)
   doMore()
@@ -540,7 +540,7 @@ for (const x of arr) {
 
 ### Own + Guard + Value Variable (Critical!)
 
-```rip
+```coffee
 for own k, v of obj when v > 5
   process(k, v)
 ```
@@ -562,13 +562,13 @@ for (const k in obj) {
 ### Async Comprehensions
 
 **Sequential (await in body):**
-```rip
+```coffee
 # IIFE is async, awaits happen serially inside loop
 results = (await fetchData(url) for url in urls)
 ```
 
 **Parallel (recommended for I/O):**
-```rip
+```coffee
 # Build array of promises, then await all in parallel
 results = await Promise.all (fetchData(url) for url in urls)
 ```
@@ -853,5 +853,5 @@ Solar's s-expression mode is the **secret sauce** that makes Rip practical:
 
 **See Also:**
 - [GUIDE.md](GUIDE.md) - Language features and syntax
-- [PHILOSOPHY.md](PHILOSOPHY.md) - Design decisions and rationale
+- [RATIONALE.md](RATIONALE.md) - Design decisions and rationale
 - [BROWSER.md](BROWSER.md) - Browser usage and REPL guide

package/docs/RATIONALE.md

@@ -0,0 +1,180 @@
+<p><img src="rip.svg" alt="Rip Logo" width="100"></p>
+
+# Why Rip Exists
+
+> Philosophy, design decisions, and the case for a modern CoffeeScript successor.
+
+---
+
+## The Short Version
+
+Rip exists because:
+
+1. **Simplicity scales** — S-expressions make compilers 50% smaller and 10x easier to maintain
+2. **Zero dependencies** — True autonomy from the npm ecosystem
+3. **Modern output** — ES2022 everywhere, no legacy baggage
+4. **Unique features** — 10+ innovations CoffeeScript never had
+5. **Reactivity as operators** — `:=`, `~=`, `~>` are language syntax, not library imports
+6. **Self-hosting** — Rip compiles itself, including its own parser generator
+
+---
+
+## 1. Why S-Expressions
+
+Most compilers use complex AST node classes. Rip uses **simple arrays**:
+
+```javascript
+// Traditional AST (CoffeeScript, TypeScript, Babel)
+class BinaryOp {
+  constructor(op, left, right) { ... }
+  compile() { /* 50+ lines */ }
+}
+
+// Rip's S-Expression
+["+", left, right]  // That's it!
+```
+
+**Result:** CoffeeScript's compiler is 17,760 LOC. Rip's is ~11,000 LOC — smaller, yet includes a complete reactive runtime.
+
+### The Fundamental Rule
+
+> **Transform the IR (s-expressions), not the output (strings)**
+
+This single principle eliminates entire categories of bugs. When your IR is simple data (arrays), transformations are trivial and debuggable:
+
+```javascript
+// Debugging: inspect the data directly
+console.log(sexpr);
+// ["comprehension", ["*", "x", 2], [["for-in", ["x"], ["array", 1, 2, 3]]], []]
+// Clear structure, 2-3 minutes to debug
+
+// vs. string manipulation
+console.log(code);
+// "(() => {\n  const result = [];\n  for (const x of arr) {\n..."
+// Blob of text, 20-30 minutes to debug
+```
+
+**Lisp got this right 60 years ago.** Code is data, data is code.
+
+---
+
+## 2. Rip vs CoffeeScript
+
+| Metric | CoffeeScript | Rip |
+|--------|--------------|-----|
+| **Feature Parity** | Baseline | ~99% |
+| **Unique Features** | 0 | 10+ innovations |
+| **Dependencies** | Multiple | **ZERO** |
+| **Self-Hosting** | No | **YES** |
+| **Total LOC** | 17,760 | ~11,000 |
+| **Output** | ES6 (2017) | ES2022 |
+| **Reactivity** | None | Built-in |
+
+### What Rip Adds
+
+1. **Reactivity as operators** — `:=` state, `~=` computed, `~>` effects
+2. **Ternary operator** — `x ? a : b` (freed by using `??` for nullish)
+3. **Dammit operator** — `fetchData!` calls AND awaits
+4. **Ruby-style regex** — `str =~ /pattern/` with captures in `_`
+5. **Dual optional syntax** — Both CoffeeScript soak AND ES6 optional chaining
+6. **Void functions** — `def process!` suppresses implicit returns
+7. **Smart comprehensions** — Context-aware (loop vs. array building)
+8. **`__DATA__` marker** — Ruby-style inline data sections
+9. **Heregex** — Extended regex with comments and whitespace
+10. **Zero dependencies** — Everything included, even the parser generator
+
+### The Complete Feature Table
+
+| Feature | CoffeeScript | Rip | Winner |
+|---------|-------------|------|--------|
+| Optional operators | 4 soak | 10 (5 soak + 5 ES6) | Rip |
+| Ternary | No | Yes | Rip |
+| Regex features | Basic | Ruby-style (`=~`, indexing) | Rip |
+| Async shorthand | No | Dammit operator (`!`) | Rip |
+| Void functions | No | `def fn!` | Rip |
+| Reactivity | None | `:=`, `~=`, `~>` | Rip |
+| Comprehension optimization | Always IIFE | Context-aware | Rip |
+| Modules | CommonJS | ES6 | Rip |
+| Classes | ES5 | ES6 | Rip |
+| Dependencies | Multiple | **ZERO** | Rip |
+| Parser generator | External (Jison) | **Built-in (solar.rip)** | Rip |
+| Self-hosting | No | **Yes** | Rip |
+
+---
+
+## 3. The Case Against CoffeeScript (And Why Rip Is Different)
+
+The strongest argument against CoffeeScript in 2026:
+
+- **Ecosystem abandoned** — Hiring, tooling, community all gone
+- **TypeScript won** — Type safety became the standard
+- **JavaScript absorbed it** — `?.`, `??`, `=>`, classes, destructuring all native now
+- **Tooling rotted** — IDE support deprecated, build plugins unmaintained
+
+**These are valid criticisms.** Rip addresses every one:
+
+| Criticism | CoffeeScript's Problem | Rip's Answer |
+|-----------|----------------------|--------------|
+| No ecosystem | Dead community | Zero dependencies — doesn't need one |
+| No types | Can't integrate with TS tooling | ES2022 output works with any JS toolchain |
+| Tooling rot | Plugins unmaintained | Self-contained — nothing to maintain |
+| No innovation | Frozen since 2017 | 10+ unique features, active development |
+| No corporate backing | Abandoned | Self-hosting — depends on nothing |
+
+**The key insight:** CoffeeScript failed because it depended on an ecosystem that moved on. Rip succeeds by depending on nothing.
+
+---
+
+## 4. Reactivity as a Language Feature
+
+This is Rip's signature innovation. While React, Vue, and Solid provide reactivity through library imports, Rip provides it as **language operators**:
+
+```coffee
+count := 0                    # State — reactive container
+doubled ~= count * 2          # Computed — auto-updates when count changes
+~> console.log count           # Effect — runs when dependencies change
+```
+
+Compare to React:
+```javascript
+import { useState, useMemo, useEffect } from 'react';
+const [count, setCount] = useState(0);
+const doubled = useMemo(() => count * 2, [count]);
+useEffect(() => { console.log(count); }, [count]);
+```
+
+**No imports. No hooks. No dependency arrays. Just operators.**
+
+The reactive runtime is ~200 lines, embedded in the compiler, and only included when reactive operators are used.
+
+---
+
+## 5. Design Principles
+
+### Simplicity Scales
+
+Simple IR (s-expressions), clear pipeline (lex → parse → generate), minimal code, comprehensive tests. Every design decision optimizes for **long-term maintainability**, not short-term cleverness.
+
+### Zero Dependencies Is a Feature
+
+```json
+{ "dependencies": {} }
+```
+
+Everything included: compiler, parser generator, REPL, browser bundle, test framework. No supply chain attacks. No version conflicts. No `node_modules` bloat.
+
+### Self-Hosting Proves Quality
+
+Rip compiles its own parser generator (`solar.rip` → `parser.js`). If the compiler can compile itself, it works.
+
+---
+
+**See Also:**
+- [GUIDE.md](GUIDE.md) — Complete language reference
+- [REACTIVITY.md](REACTIVITY.md) — Reactivity deep dive
+- [INTERNALS.md](INTERNALS.md) — Compiler architecture
+- [BROWSER.md](BROWSER.md) — Browser usage and REPL
+
+---
+
+*Version 2.9.0 — 1115/1115 tests passing — Zero dependencies — Self-hosting*

package/docs/REACTIVITY.md

@@ -51,7 +51,7 @@ Every reactive system reduces to these three concepts:
 
 ## Quick Example
 
-```rip
+```coffee
 count := 0                      # count has state 0
 doubled ~= count * 2            # doubled always equals count * 2
 logger ~> console.log count     # reacts to count changes
@@ -71,7 +71,7 @@ increment()  # Logs: 2
 
 State creates a **reactive container** that tracks its readers and notifies them on change.
 
-```rip
+```coffee
 count := 0        # count has state 0
 count += 1        # Update triggers dependents
 ```
@@ -91,7 +91,7 @@ count.value += 1;
 
 Computed creates a **computed value** that automatically updates when dependencies change.
 
-```rip
+```coffee
 count := 0
 doubled ~= count * 2    # doubled always equals count * 2
 ```
@@ -105,7 +105,7 @@ doubled ~= count * 2    # doubled always equals count * 2
 
 The effect operator runs **side effects** when dependencies change. Dependencies are auto-tracked from reactive values read in the body.
 
-```rip
+```coffee
 ~> document.title = "Count: #{count}"
 ```
 
@@ -115,7 +115,7 @@ The effect operator runs **side effects** when dependencies change. Dependencies
 - **Controllable** — optionally assign to a variable to control the effect
 
 **Syntax:**
-```rip
+```coffee
 # Fire and forget (no assignment)
 ~> console.log count