rip-lang 3.14.5 → 3.15.1

package/README.md

@@ -9,7 +9,7 @@
 </p>
 
 <p align="center">
-  <a href="https://github.com/shreeve/rip-lang/commits/main"><img src="https://img.shields.io/badge/version-3.14.5-blue.svg" alt="Version"></a>
+  <a href="https://github.com/shreeve/rip-lang/commits/main"><img src="https://img.shields.io/badge/version-3.15.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-1%2C436%2F1%2C436-brightgreen.svg" alt="Tests"></a>
   <a href="LICENSE"><img src="https://img.shields.io/badge/license-MIT-green.svg" alt="License"></a>
@@ -66,8 +66,10 @@ Pre-built binaries and VS Code / Cursor extensions are published via GitHub Page
 
 **`ripdb`** — DuckDB extension that exposes a rip-db server as a first-class attached database:
 
+```bash
+duckdb -unsigned        # required for custom-repo extensions
+```
 ```sql
-SET allow_unsigned_extensions = true;
 INSTALL ripdb FROM 'https://shreeve.github.io/rip-lang/extensions/duckdb';
 LOAD ripdb;
 ```
@@ -349,7 +351,7 @@ The **body syntax is declarative**, not general Rip code. Five line forms are le
 
 **`:model` is where the pieces converge.** One declaration gives you a validator, a class with fields as enumerable own properties and methods/getters on the prototype, a chainable async query builder (`User.where(active: true).order("last_name").all!`), migration DDL that works standalone (`User.toSQL()` never touches the database), belongs-to/has-many accessors that resolve cross-module through the registry, and full shadow TypeScript with `ModelSchema<Instance, Data>` typing that propagates through schema algebra. Hydrated instances carry both snake_case and camelCase aliases on DB-derived columns (`order.user_id` and `order.userId` read the same slot), so raw SQL helpers and ORM access coexist cleanly. A single-function adapter interface (`adapter.query(sql, params)`) routes all database I/O, so tests use in-memory mocks and production uses rip-db without the ORM caring.
 
-**Schema algebra** — `.pick`, `.omit`, `.partial`, `.required`, `.extend` — always returns a new `:shape`. Field semantics (type, literal unions, constraints, inline transforms) carry through to the derived shape; instance behavior (methods, computed `~>`, eager-derived `!>`, hooks, and `@ensure` refinements) does not. `User.omit "password"` produces a validator for `User` minus the password field; it won't have `.find()` or the `beforeSave` hook, but field-level transforms (`email, -> it.email.toLowerCase()`) continue to fire on the derived shape exactly as they did on the original. This invariant is enforced both at runtime (ORM methods throw on derived shapes with a targeted diagnostic pointing at query projection) and at the TypeScript level (algebra generics are parameterized over `Data`, not `Instance`, so the derived types correctly omit methods and ORM surface). Internally, the whole feature is a compiler sidecar — 54% of the implementation lives in `src/schema.js` and touches the core compiler in under 100 lines of wiring. A four-layer lazy runtime (raw descriptor → normalized metadata → validator plan → ORM plan / DDL plan) means module load is cheap, migration scripts never build the ORM plan, and validator-only consumers never build the class machinery. The full reference is in [docs/RIP-SCHEMA.md](docs/RIP-SCHEMA.md).
+**Schema algebra** — `.pick`, `.omit`, `.partial`, `.required`, `.extend` — always returns a new `:shape`. Field semantics (type, literal unions, constraints, inline transforms) carry through to the derived shape; instance behavior (methods, computed `~>`, eager-derived `!>`, hooks, and `@ensure` refinements) does not. `User.omit "password"` produces a validator for `User` minus the password field; it won't have `.find()` or the `beforeSave` hook, but field-level transforms (`email, -> it.email.toLowerCase()`) continue to fire on the derived shape exactly as they did on the original. This invariant is enforced both at runtime (ORM methods throw on derived shapes with a targeted diagnostic pointing at query projection) and at the TypeScript level (algebra generics are parameterized over `Data`, not `Instance`, so the derived types correctly omit methods and ORM surface). Internally, the whole feature is a compiler sidecar — 54% of the implementation lives in `src/schema/schema.js` and touches the core compiler in under 100 lines of wiring. A four-layer lazy runtime (raw descriptor → normalized metadata → validator plan → ORM plan / DDL plan) means module load is cheap, migration scripts never build the ORM plan, and validator-only consumers never build the class machinery. The full reference is in [docs/RIP-SCHEMA.md](docs/RIP-SCHEMA.md).
 
 ---
 
@@ -365,9 +367,11 @@ Rip's reactivity is framework-agnostic — use it with React, Vue, Svelte, or va
 
 ---
 
-## Rip UI
+## Rip App
+
+Load `rip.min.js` (~88KB Brotli) — the Rip compiler and Rip App framework in one file. Components are `.rip` source files, compiled on demand, rendered with fine-grained reactivity. No build step. No bundler.
 
-Load `rip.min.js` (~54KB Brotli) — the Rip compiler and UI framework in one file. Components are `.rip` source files, compiled on demand, rendered with fine-grained reactivity. No build step. No bundler.
+(Rip UI is the separate widget package at `packages/ui/`. The two terms do not overlap.)
 
 ```html
 <script defer src="rip.min.js" data-mount="Home"></script>

package/bin/rip

@@ -5,6 +5,11 @@ import { execSync, spawnSync, spawn } from 'child_process';
 import { fileURLToPath } from 'url';
 import { dirname, basename, join } from 'path';
 import { Compiler, formatError } from '../src/compiler.js';
+// Side-effect imports — register CLI-side runtime providers. The browser
+// bundle imports a different schema loader so server-only fragments
+// (db-naming/orm/ddl) tree-shake out of docs/dist/rip.min.js.
+import '../src/types-emit.js';        // registers emitTypes for .d.ts output
+import '../src/schema/loader-server.js'; // registers full schema runtime
 import packageJson from '../package.json' with { type: 'json' };
 
 const __dirname = dirname(fileURLToPath(import.meta.url));

package/docs/AGENTS.md

@@ -37,7 +37,7 @@ App.mount()
 - `index.html` — playground
 - `demo.html` and `charts.html` — dashboard demos
 - `sierpinski.html` — CDN demo
-- `example/index.html` and `results/index.html` — app launchers / examples
+- `example/index.html` and `results/index.html` — app launchers / examples. `example/index.json` is generated from `docs/demo/` via `bun run bundle:demo` (the source-of-truth lives in `docs/demo/`, the JSON is the deployable artifact).
 - `ui/index.html` — widget gallery
 
 Static demos can be opened via `file://`. The playground and example app require `bun run serve`.

package/docs/RIP-LANG.md

@@ -105,8 +105,18 @@ colors = %w(red green blue)   # any delimiter: [] () {} <> || !! etc.
 
 # Objects
 user = {name: "Alice", age: 30}
-shorthand = {name, age}  # Same as {name: name, age: age}
-config = {api.host: "localhost", api.port: 3000}  # Dotted keys → flat string keys
+shorthand = {name, age}              # Same as {name: name, age: age}
+
+# Compound keys — dot- and hyphen-separated identifier chains collapse
+# into a single flat string key. Useful for config trees and DOM-style
+# attribute names without quote noise.
+config = {api.host: "localhost", api.port: 3000}     # → {'api.host': ..., 'api.port': ...}
+attrs  = {data-src: "/img.png", aria-label: "logo"}  # → {'data-src': ..., 'aria-label': ...}
+hosts  = {beta-site.amazon.com: 100}                 # → {'beta-site.amazon.com': 100}
+
+# No whitespace or newline is allowed on either side of `-` in a hyphen
+# key — that's how `data-src` stays a single key while `a - b` stays
+# subtraction. Dots are more permissive (whitespace either side is fine).
 
 # Map literals — real JavaScript Map with any key type
 table = *{
@@ -1460,7 +1470,7 @@ ids   = read 'ids', 'ids'       # "1,2,3" → [1, 2, 3]
 slug  = read 'slug', 'slug'     # URL-safe slug
 ```
 
-## Rip UI — Reactive Web Framework (built into rip-lang)
+## Rip App — Application Framework (built into rip-lang)
 
 Zero-build reactive framework. Ships the compiler to the browser and compiles `.rip` components on demand. File-based routing, unified reactive stash, and SSE hot reload.
 
@@ -2224,8 +2234,10 @@ a[/pat/, 1]    # regex extract
 a?             # existence check (a != null)
 a ?? b         # nullish coalescing
 
-# Dotted keys
-{a.b: 1}          # {'a.b': 1} — flat string key
+# Compound keys — dotted, hyphenated, or mixed (collapse to flat string keys)
+{a.b: 1}                       # {'a.b': 1}
+{data-src: 1}                  # {'data-src': 1} — no whitespace around `-`
+{beta-site.amazon.com: 100}    # {'beta-site.amazon.com': 100} — mixed
 
 # Word arrays
 %w[foo bar baz]   # ["foo", "bar", "baz"] — Ruby-style word literal

package/docs/RIP-SCHEMA.md

@@ -2324,7 +2324,7 @@ through this interface.
 ## 24. Compiler integration
 
 The schema keyword is implemented as a compiler sidecar in
-`src/schema.js`, alongside the existing type and component sidecars.
+`src/schema/schema.js`, alongside the existing type and component sidecars.
 This isolates the feature from the rest of the compiler: the main Rip
 grammar has two productions for the schema keyword (not hundreds), and
 the schema-specific body syntax never reaches the main parser.
@@ -2373,7 +2373,7 @@ binds to the instance correctly without special codegen.
 
 | File                 | Role                                                               |
 | -------------------- | ------------------------------------------------------------------ |
-| `src/schema.js`      | Sub-parser, `emitSchema`, Layer 1-4 runtime, shadow TS walker, `installSchemaSupport` |
+| `src/schema/schema.js`      | Sub-parser, `emitSchema`, Layer 1-4 runtime, shadow TS walker, `installSchemaSupport` |
 | `src/lexer.js`       | Hook point — calls `rewriteSchema()`; comment-token fix for `#` modifier |
 | `src/grammar/grammar.rip` | The one `Schema` production                                  |
 | `src/compiler.js`    | Dispatch for the `schema` s-expression head; preamble injection    |
@@ -2381,7 +2381,7 @@ binds to the instance correctly without special codegen.
 | `src/typecheck.js`   | `hasSchemas()` probe so schema-only files aren't `@ts-nocheck`d     |
 | `test/rip/schema.rip` | The test suite                                                    |
 
-The total wiring in the core compiler (outside `src/schema.js`) is under
+The total wiring in the core compiler (outside `src/schema/schema.js`) is under
 100 lines. That's the sidecar pattern working — the feature is big, but
 its footprint in the main compiler is small.
 
@@ -2405,7 +2405,7 @@ transactions, eager loading, scopes, and soft deletes — not yet; see
 
 **Does the runtime belong to `schema.js` or is it loaded separately?**
 It's inlined. When a file uses `schema`, the compiler injects a small
-preamble (under `SCHEMA_RUNTIME` in `src/schema.js`) that defines
+preamble (under `SCHEMA_RUNTIME` in `src/schema/schema.js`) that defines
 `SchemaError`, `__SchemaDef`, `__SchemaRegistry`, `Query`, and the
 helpers. No import statement, no package dependency, no bootstrap call.
 

package/docs/demo/README.md

@@ -0,0 +1,43 @@
+# Rip App Demo
+
+The canonical "everything in one file" demo of the Rip App framework. Six components covering layout, routing, reactive state, list rendering, and reusable component composition.
+
+## Layout
+
+```
+docs/demo/
+├── components/
+│   ├── _layout.rip   — root layout with nav + error boundary
+│   ├── index.rip     — Home page (file-based routing: / → index.rip)
+│   ├── counter.rip   — reactive state, := / ~> persistence to stash
+│   ├── todos.rip     — list rendering, computed values, event handlers
+│   ├── about.rip     — uses the Card component for content sections
+│   └── card.rip      — reusable component with @children
+└── css/
+    └── styles.css    — design tokens + component styles, no Tailwind
+```
+
+## Bundle to one JSON file
+
+```bash
+bun run bundle:demo
+# wraps:
+# bun scripts/bundle-app.js docs/demo -o docs/example/index.json -t "Rip App Demo"
+```
+
+Output: `docs/example/index.json` — a single ~17 KB file containing every component's raw `.rip` source plus all CSS, ready to ship to any static host. The launcher at `docs/example/index.html` fetches it once and runs the whole app from memory: no bundler, no build step, no per-component network requests.
+
+## Architecture
+
+This is the "burn a CD" deployment model for a Rip app. The browser loads:
+
+1. `docs/dist/rip.min.js` (~80 KB Brotli) — the compiler + framework + reactive runtime
+2. `docs/example/index.json` (~17 KB) — the entire app's source
+
+Then `<script type="text/rip">launch bundle: bundle</script>` mounts everything. Routing, reactivity, fine-grained DOM updates, all driven by code that compiles in the browser at mount time.
+
+## Iterating
+
+Edit any `.rip` file under `components/`, then re-run `bun run bundle:demo` to refresh the bundled JSON. The launcher HTML at `docs/example/` will pick up the new bundle on next load.
+
+CSS is concatenated alphabetically by filename. Add `.css` files under `css/` to extend the design.

package/docs/demo/components/_layout.rip

@@ -0,0 +1,28 @@
+# Root Layout (with error boundary and navigation indicator)
+
+export Layout = component
+  errorMsg := null
+
+  ~> localStorage.setItem '__rip_route', @router.path
+
+  onError: (err) ->
+    errorMsg = err.message
+
+  render
+    .app-layout
+      nav.app-nav
+        .nav-inner
+          a.nav-brand "Rip App"
+          .nav-links
+            a.('nav-link', @router.path is '/' and 'active') href: "#/", "Home"
+            a.('nav-link', @router.path is '/counter' and 'active') href: "#counter", "Counter"
+            a.('nav-link', @router.path is '/todos' and 'active') href: "#todos", "Todos"
+            a.('nav-link', @router.path is '/about' and 'active') href: "#about", "About"
+            if @router.navigating
+              span.nav-loading "Loading..."
+      main.app-main
+        if errorMsg
+          .error-banner
+            p "Something went wrong: #{errorMsg}"
+            button.btn @click: (-> errorMsg = null), "Dismiss"
+        #content

package/docs/demo/components/about.rip

@@ -0,0 +1,36 @@
+# About Page — uses the Card component for content sections
+
+export About = component
+
+  render
+    div
+      .page-header
+        h1.page-title "About Rip App"
+        p.page-subtitle "Zero-build reactive web apps!"
+
+      Card title: "The Idea"
+        p "Traditional frameworks build and bundle on the server, then ship static artifacts. Rip App ships the 40KB compiler to the browser instead. Components arrive as .rip source files, are compiled on demand, and render with fine-grained reactivity. No build step, no bundler, no configuration files."
+
+      Card title: "Two Keywords"
+        p "The component model adds exactly two keywords to the Rip language: component and render. Everything else — reactive state (:=), computed values (~=), effects (~>), methods, lifecycle hooks — is standard Rip syntax that already exists."
+
+      Card title: "Architecture"
+        p "Components live as source files in the unified stash. The Router maps URLs to components using file-based conventions (like Next.js). When you navigate, the Renderer compiles the matching .rip file and mounts the resulting component. Each reactive binding creates a direct DOM effect — no virtual DOM diffing."
+
+      Card title: "Stack"
+        .btn-group
+          .stat
+            span "Compiler "
+            span.stat-value "40KB"
+          .stat
+            span "Framework "
+            span.stat-value "~8KB"
+          .stat
+            span "Build step "
+            span.stat-value "None"
+          .stat
+            span "Dependencies "
+            span.stat-value "Zero"
+
+      Card title: "Modules"
+        p "The framework lives in one file: app.rip. It uses Rip's built-in reactive primitives directly — the same signals that power := and ~= in components. Deep reactive stash with path navigation. Component store for source management. File-based router mapping URLs to components. Renderer that compiles and mounts components with layout support."

package/docs/demo/components/card.rip

@@ -0,0 +1,10 @@
+# Card — reusable content card component
+
+export Card = component
+  title =! ""
+
+  render
+    div.card
+      if title
+        h3 "#{title}"
+      @children

package/docs/demo/components/counter.rip

@@ -0,0 +1,33 @@
+# Counter Page
+
+export Counter = component
+  count := @app.data.count or 0
+  step  := 1
+
+  ~> @app.data.count = count
+
+  increment: -> count += step
+  decrement: -> count -= step
+  reset:     -> count = 0
+
+  render
+    div
+      .page-header
+        h1.page-title "Counter"
+        p.page-subtitle "Reactive state — persists across reload"
+
+      .card
+        .counter-display "#{count}"
+
+        .counter-controls
+          button.btn @click: @decrement, "- #{step}"
+          button.btn @click: @reset, "Reset"
+          button.btn.btn-primary @click: @increment, "+ #{step}"
+
+      .card
+        .card-title "Step Size"
+        .btn-group
+          button.btn @click: (-> step = 1), "1"
+          button.btn @click: (-> step = 5), "5"
+          button.btn @click: (-> step = 10), "10"
+          button.btn @click: (-> step = 100), "100"

package/docs/demo/components/index.rip

@@ -0,0 +1,30 @@
+# Home Page
+
+export Home = component
+
+  render
+    div
+      .page-header
+        h1.page-title "Rip App Framework"
+        p.page-subtitle "Zero-build reactive web apps"
+
+      .feature-grid
+        .feature-card
+          .feature-icon "🗂"
+          .feature-name "Component Store"
+          .feature-desc "Component source files loaded on demand. Compiled in the browser."
+
+        .feature-card
+          .feature-icon "🔀"
+          .feature-name "File-Based Router"
+          .feature-desc "URLs map to components. Dynamic segments and nested layouts."
+
+        .feature-card
+          .feature-icon "⚡"
+          .feature-name "Reactive Stash"
+          .feature-desc "Deep state tree with path navigation. Every property tracked."
+
+        .feature-card
+          .feature-icon "🎯"
+          .feature-name "Fine-Grained Rendering"
+          .feature-desc "No virtual DOM. Direct DOM updates via reactive effects."

package/docs/demo/components/todos.rip

@@ -0,0 +1,48 @@
+# Todos Page
+
+export Todos = component
+  newTodo := ''
+  todos := @app.data.todos or []
+  nextId := (@app.data.nextId or 1)
+
+  ~> @app.data.todos = todos
+  ~> @app.data.nextId = nextId
+
+  remaining ~= todos.filter((t) -> not t.done).length
+
+  addTodo: ->
+    if newTodo.trim()
+      todos = [...todos, { id: nextId, text: newTodo.trim(), done: false }]
+      nextId++
+      newTodo = ''
+
+  deleteTodo: (id) ->
+    todos = todos.filter (t) -> t.id isnt id
+
+  clearAll: ->
+    todos = []
+
+  handleKey: (e) ->
+    if e.key is 'Enter'
+      @addTodo()
+
+  render
+    div
+      .page-header
+        h1.page-title "Todos"
+        p.page-subtitle "List rendering and state management"
+
+      .card
+        .todo-input-row
+          input.input type: "text", value <=> newTodo, placeholder: "What needs to be done?", @keydown: @handleKey
+          button.btn.btn-primary @click: @addTodo, "Add"
+
+        ul.todo-list
+          for todo in todos
+            li.todo-item
+              span.todo-text todo.text
+              button.todo-delete @click: (=> @deleteTodo(todo.id)), "x"
+
+        .todo-stats
+          span "#{remaining} remaining"
+          button.btn.btn-sm @click: @clearAll, "Clear all"