chore: bump version to 0.1.11

chore: bump version to 0.1.10
chore: update Cargo.lock
2026-02-20 19:36:11 -05:00 · 2026-02-20 19:32:56 -05:00 · 2026-02-20 19:32:27 -05:00 · 2026-02-20 19:29:44 -05:00 · 2026-02-20 19:21:26 -05:00 · 2026-02-20 18:46:51 -05:00
30 changed files with 7879 additions and 524 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -4,6 +4,11 @@
 # Claude Code project instructions
 CLAUDE.md

+# Build output
+_site/
+docs/*.html
+docs/*.css
+
 # Test binaries
 hello
 test_rc
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -42,15 +42,46 @@ When making changes:
 7. **Fix language limitations**: If you encounter parser/type system limitations, fix them (without regressions on guarantees or speed)
 8. **Git commits**: Always use `--no-gpg-sign` flag

-### Post-work checklist (run after each major piece of work)
+### Post-work checklist (run after each committable change)
+
+**MANDATORY: Run the full validation script after every committable change:**
+```bash
+./scripts/validate.sh
+```
+
+This script runs ALL of the following checks and will fail if any regress:
+1. `cargo check` — no Rust compilation errors
+2. `cargo test` — all Rust tests pass (currently 387)
+3. `cargo build --release` — release binary builds
+4. `lux test` on every package (path, frontmatter, xml, rss, markdown) — all 286 package tests pass
+5. `lux check` on every package — type checking + lint passes
+
+If `validate.sh` is not available or you need to run manually:
 ```bash
 nix develop --command cargo check       # No Rust errors
-nix develop --command cargo test        # All tests pass (currently 381)
-./target/release/lux check              # Type check + lint all .lux files
-./target/release/lux fmt                # Format all .lux files
-./target/release/lux lint               # Standalone lint pass
+nix develop --command cargo test        # All Rust tests pass
+nix develop --command cargo build --release  # Build release binary
+cd ../packages/path && ../../lang/target/release/lux test        # Package tests
+cd ../packages/frontmatter && ../../lang/target/release/lux test
+cd ../packages/xml && ../../lang/target/release/lux test
+cd ../packages/rss && ../../lang/target/release/lux test
+cd ../packages/markdown && ../../lang/target/release/lux test
 ```

+**Do NOT commit if any check fails.** Fix the issue first.
+
+### Commit after every piece of work
+**After completing each logical unit of work, commit immediately.** This is NOT optional — every fix, feature, or change MUST be committed right away. Do not let changes accumulate uncommitted across multiple features. Each commit should be a single logical change (one feature, one bugfix, etc.). Use `--no-gpg-sign` flag for all commits.
+
+**Commit workflow:**
+1. Make the change
+2. Run `./scripts/validate.sh` (all 13 checks must pass)
+3. `git add` the relevant files
+4. `git commit --no-gpg-sign -m "type: description"` (use conventional commits: fix/feat/chore/docs)
+5. Move on to the next task
+
+**Never skip committing.** If you fixed a bug, commit it. If you added a feature, commit it. If you updated docs, commit it. Do not batch unrelated changes into one commit.
+
 **IMPORTANT: Always verify Lux code you write:**
 - Run with interpreter: `./target/release/lux file.lux`
 - Compile to binary: `./target/release/lux compile file.lux`
@@ -68,10 +99,45 @@ nix develop --command cargo test        # All tests pass (currently 381)
 | `lux serve` | `lux s` | Static file server |
 | `lux compile` | `lux c` | Compile to binary |

+## Documenting Lux Language Errors
+
+When working on any major task that involves writing Lux code, **document every language error, limitation, or surprising behavior** you encounter. This log is optimized for LLM consumption so future sessions can avoid repeating mistakes.
+
+**File:** Maintain an `ISSUES.md` in the relevant project directory (e.g., `~/src/blu-site/ISSUES.md`).
+
+**Format for each entry:**
+```markdown
+## Issue N: <Short descriptive title>
+
+**Category**: Parser limitation | Type checker gap | Missing feature | Runtime error | Documentation gap
+**Severity**: High | Medium | Low
+**Status**: Open | **Fixed** (commit hash or version)
+
+<1-2 sentence description of the problem>
+
+**Reproduction:**
+```lux
+// Minimal code that triggers the issue
+```
+
+**Error message:** `<exact error text>`
+
+**Workaround:** <how to accomplish the goal despite the limitation>
+
+**Fix:** <if fixed, what was changed and where>
+```
+
+**Rules:**
+- Add new issues as you encounter them during any task
+- When a previously documented issue gets fixed, update its status to **Fixed** and note the commit/version
+- Remove entries that are no longer relevant (e.g., the feature was redesigned entirely)
+- Keep the summary table at the bottom of ISSUES.md in sync with the entries
+- Do NOT duplicate issues already documented -- check existing entries first
+
 ## Code Quality

 - Fix all compiler warnings before committing
- Ensure all tests pass (currently 381 tests)
+- Ensure all tests pass (currently 387 tests)
 - Add new tests when adding features
 - Keep examples and documentation in sync

--- a/Cargo.lock
+++ b/Cargo.lock
@@ -135,16 +135,6 @@ dependencies = [
 "libc",
 ]

-[[package]]
-name = "core-foundation"
-version = "0.10.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b2a6cd9ae233e7f62ba4e9353e81a88df7fc8a5987b8d445b4d90c879bd156f6"
-dependencies = [
- "core-foundation-sys",
- "libc",
-]
-
 [[package]]
 name = "core-foundation-sys"
 version = "0.8.7"
@@ -297,21 +287,6 @@ version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"

-[[package]]
-name = "foreign-types"
-version = "0.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1"
-dependencies = [
- "foreign-types-shared",
-]
-
-[[package]]
-name = "foreign-types-shared"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b"
-
 [[package]]
 name = "form_urlencoded"
 version = "1.2.2"
@@ -417,6 +392,12 @@ dependencies = [
 "wasip3",
 ]

+[[package]]
+name = "glob"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280"
+
 [[package]]
 name = "h2"
 version = "0.3.27"
@@ -552,16 +533,17 @@ dependencies = [
 ]

 [[package]]
-name = "hyper-tls"
-version = "0.5.0"
+name = "hyper-rustls"
+version = "0.24.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d6183ddfa99b85da61a140bea0efc93fdf56ceaa041b37d553518030827f9905"
+checksum = "ec3efd23720e2049821a693cbc7e65ea87c72f1c58ff2f9522ff332b1491e590"
 dependencies = [
- "bytes",
+ "futures-util",
+ "http",
 "hyper",
- "native-tls",
+ "rustls",
 "tokio",
- "tokio-native-tls",
+ "tokio-rustls",
 ]

 [[package]]
@@ -794,8 +776,9 @@ dependencies = [

 [[package]]
 name = "lux"
-version = "0.1.0"
+version = "0.1.9"
 dependencies = [
+ "glob",
 "lsp-server",
 "lsp-types",
 "postgres",
@@ -843,23 +826,6 @@ dependencies = [
 "windows-sys 0.61.2",
 ]

-[[package]]
-name = "native-tls"
-version = "0.2.16"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9d5d26952a508f321b4d3d2e80e78fc2603eaefcdf0c30783867f19586518bdc"
-dependencies = [
- "libc",
- "log",
- "openssl",
- "openssl-probe",
- "openssl-sys",
- "schannel",
- "security-framework",
- "security-framework-sys",
- "tempfile",
-]
-
 [[package]]
 name = "nibble_vec"
 version = "0.1.0"
@@ -905,50 +871,6 @@ version = "1.21.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"

-[[package]]
-name = "openssl"
-version = "0.10.75"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08838db121398ad17ab8531ce9de97b244589089e290a384c900cb9ff7434328"
-dependencies = [
- "bitflags 2.10.0",
- "cfg-if",
- "foreign-types",
- "libc",
- "once_cell",
- "openssl-macros",
- "openssl-sys",
-]
-
-[[package]]
-name = "openssl-macros"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "openssl-probe"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7c87def4c32ab89d880effc9e097653c8da5d6ef28e6b539d313baaacfbafcbe"
-
-[[package]]
-name = "openssl-sys"
-version = "0.9.111"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "82cab2d520aa75e3c58898289429321eb788c3106963d0dc886ec7a5f4adc321"
-dependencies = [
- "cc",
- "libc",
- "pkg-config",
- "vcpkg",
-]
-
 [[package]]
 name = "parking_lot"
 version = "0.12.5"
@@ -1203,15 +1125,15 @@ dependencies = [
 "http",
 "http-body",
 "hyper",
- "hyper-tls",
+ "hyper-rustls",
 "ipnet",
 "js-sys",
 "log",
 "mime",
- "native-tls",
 "once_cell",
 "percent-encoding",
 "pin-project-lite",
+ "rustls",
 "rustls-pemfile",
 "serde",
 "serde_json",
@@ -1219,15 +1141,30 @@ dependencies = [
 "sync_wrapper",
 "system-configuration",
 "tokio",
- "tokio-native-tls",
+ "tokio-rustls",
 "tower-service",
 "url",
 "wasm-bindgen",
 "wasm-bindgen-futures",
 "web-sys",
+ "webpki-roots",
 "winreg",
 ]

+[[package]]
+name = "ring"
+version = "0.17.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4689e6c2294d81e88dc6261c768b63bc4fcdb852be6d1352498b114f61383b7"
+dependencies = [
+ "cc",
+ "cfg-if",
+ "getrandom 0.2.17",
+ "libc",
+ "untrusted",
+ "windows-sys 0.52.0",
+]
+
 [[package]]
 name = "rusqlite"
 version = "0.31.0"
@@ -1255,6 +1192,18 @@ dependencies = [
 "windows-sys 0.61.2",
 ]

+[[package]]
+name = "rustls"
+version = "0.21.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f56a14d1f48b391359b22f731fd4bd7e43c97f3c50eee276f3aa09c94784d3e"
+dependencies = [
+ "log",
+ "ring",
+ "rustls-webpki",
+ "sct",
+]
+
 [[package]]
 name = "rustls-pemfile"
 version = "1.0.4"
@@ -1264,6 +1213,16 @@ dependencies = [
 "base64 0.21.7",
 ]

+[[package]]
+name = "rustls-webpki"
+version = "0.101.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b6275d1ee7a1cd780b64aca7726599a1dbc893b1e64144529e55c3c2f745765"
+dependencies = [
+ "ring",
+ "untrusted",
+]
+
 [[package]]
 name = "rustversion"
 version = "1.0.22"
@@ -1298,15 +1257,6 @@ version = "1.0.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9774ba4a74de5f7b1c1451ed6cd5285a32eddb5cccb8cc655a4e50009e06477f"

-[[package]]
-name = "schannel"
-version = "0.1.28"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "891d81b926048e76efe18581bf793546b4c0eaf8448d72be8de2bbee5fd166e1"
-dependencies = [
- "windows-sys 0.61.2",
-]
-
 [[package]]
 name = "scopeguard"
 version = "1.2.0"
@@ -1314,26 +1264,13 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"

 [[package]]
-name = "security-framework"
-version = "3.6.0"
+name = "sct"
+version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d17b898a6d6948c3a8ee4372c17cb384f90d2e6e912ef00895b14fd7ab54ec38"
+checksum = "da046153aa2352493d6cb7da4b6e5c0c057d8a1d0a9aa8560baffdd945acd414"
 dependencies = [
- "bitflags 2.10.0",
- "core-foundation 0.10.1",
- "core-foundation-sys",
- "libc",
- "security-framework-sys",
-]
-
-[[package]]
-name = "security-framework-sys"
-version = "2.16.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "321c8673b092a9a42605034a9879d73cb79101ed5fd117bc9a597b89b4e9e61a"
-dependencies = [
- "core-foundation-sys",
- "libc",
+ "ring",
+ "untrusted",
 ]

 [[package]]
@@ -1521,7 +1458,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ba3a3adc5c275d719af8cb4272ea1c4a6d668a777f37e115f6d11ddbc1c8e0e7"
 dependencies = [
 "bitflags 1.3.2",
- "core-foundation 0.9.4",
+ "core-foundation",
 "system-configuration-sys",
 ]

@@ -1619,16 +1556,6 @@ dependencies = [
 "windows-sys 0.61.2",
 ]

-[[package]]
-name = "tokio-native-tls"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bbae76ab933c85776efabc971569dd6119c580d8f5d448769dec1764bf796ef2"
-dependencies = [
- "native-tls",
- "tokio",
-]
-
 [[package]]
 name = "tokio-postgres"
 version = "0.7.16"
@@ -1655,6 +1582,16 @@ dependencies = [
 "whoami",
 ]

+[[package]]
+name = "tokio-rustls"
+version = "0.24.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c28327cf380ac148141087fbfb9de9d7bd4e84ab5d2c28fbc911d753de8a7081"
+dependencies = [
+ "rustls",
+ "tokio",
+]
+
 [[package]]
 name = "tokio-util"
 version = "0.7.18"
@@ -1750,6 +1687,12 @@ version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"

+[[package]]
+name = "untrusted"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
+
 [[package]]
 name = "url"
 version = "2.5.8"
@@ -1941,6 +1884,12 @@ dependencies = [
 "wasm-bindgen",
 ]

+[[package]]
+name = "webpki-roots"
+version = "0.25.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f20c57d8d7db6d3b86154206ae5d8fba62dd39573114de97c2cb0578251f8e1"
+
 [[package]]
 name = "whoami"
 version = "2.1.1"
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "lux"
-version = "0.1.0"
+version = "0.1.11"
 edition = "2021"
 description = "A functional programming language with first-class effects, schema evolution, and behavioral types"
 license = "MIT"
@@ -13,10 +13,11 @@ lsp-types = "0.94"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 rand = "0.8"
-reqwest = { version = "0.11", features = ["blocking", "json"] }
+reqwest = { version = "0.11", default-features = false, features = ["blocking", "json", "rustls-tls"] }
 tiny_http = "0.12"
 rusqlite = { version = "0.31", features = ["bundled"] }
 postgres = "0.19"
+glob = "0.3"


 [dev-dependencies]
--- a/PACKAGES.md
+++ b/PACKAGES.md
@@ -0,0 +1,367 @@
+# Lux Package Ecosystem Plan
+
+## Current State
+
+### Stdlib (built-in)
+| Module | Coverage |
+|--------|----------|
+| String | Comprehensive (split, join, trim, indexOf, replace, etc.) |
+| List | Good (map, filter, fold, head, tail, concat, range, find, any, all, take, drop) |
+| Option | Basic (map, flatMap, getOrElse, isSome, isNone) |
+| Result | Basic (map, flatMap, getOrElse, isOk, isErr) |
+| Math | Basic (abs, min, max, sqrt, pow, floor, ceil, round) |
+| Json | Comprehensive (parse, stringify, get, typed extractors, constructors) |
+| File | Good (read, write, append, exists, delete, readDir, isDir, mkdir) |
+| Console | Good (print, read, readLine, readInt) |
+| Process | Good (exec, execStatus, env, args, exit, cwd) |
+| Http | Basic (get, post, put, delete, setHeader) |
+| HttpServer | Basic (listen, accept, respond) |
+| Time | Minimal (now, sleep) |
+| Random | Basic (int, float, bool) |
+| Sql | Good (SQLite: open, query, execute, transactions) |
+| Postgres | Good (connect, query, execute, transactions) |
+| Schema | Niche (versioned data migration) |
+| Test | Good (assert, assertEqual, assertTrue) |
+| Concurrent | Experimental (spawn, await, yield, cancel) |
+| Channel | Experimental (create, send, receive) |
+
+### Registry (pkgs.lux) - 3 packages
+| Package | Version | Notes |
+|---------|---------|-------|
+| json | 1.0.0 | Wraps stdlib Json with convenience functions (getPath, getString, etc.) |
+| http-client | 0.1.0 | Wraps stdlib Http with JSON helpers, URL encoding |
+| testing | 0.1.0 | Wraps stdlib Test with describe/it structure |
+
+---
+
+## Gap Analysis
+
+### What's Missing vs Other Languages
+
+Compared to ecosystems like Rust/cargo, Go, Python, Elm, Gleam:
+
+| Category | Gap | Impact | Notes |
+|----------|-----|--------|-------|
+| **Collections** | No HashMap, Set, Queue, Stack | Critical | List-of-pairs with O(n) lookup is the only option |
+| **Sorting** | No List.sort or List.sortBy | High | Must implement insertion sort manually |
+| **Date/Time** | Only `Time.now()` (epoch ms), no parsing/formatting | High | blu-site does string-based date formatting manually |
+| **Markdown** | No markdown parser | High | blu-site has 300+ lines of hand-rolled markdown |
+| **XML/RSS** | No XML generation | High | Can't generate RSS feeds or sitemaps |
+| **Regex** | No pattern matching on strings | High | Character-by-character scanning required |
+| **Path** | No file path utilities | Medium | basename/dirname manually reimplemented |
+| **YAML/TOML** | No config file parsing (beyond JSON) | Medium | Frontmatter parsing is manual |
+| **Template** | No string templating | Medium | HTML built via raw string concatenation |
+| **URL** | No URL parsing/encoding | Medium | http-client has basic urlEncode but no parser |
+| **Crypto** | No hashing (SHA256, etc.) | Medium | Can't do checksums, content hashing |
+| **Base64** | No encoding/decoding | Low | Needed for data URIs, some auth |
+| **CSV** | No CSV parsing | Low | Common data format |
+| **UUID** | No UUID generation | Low | Useful for IDs |
+| **Logging** | No structured logging | Low | Just Console.print |
+| **CLI** | No argument parsing library | Low | Manual arg handling |
+
+### What Should Be Stdlib vs Package
+
+**Should be stdlib additions** (too fundamental to be packages):
+- HashMap / Map type (requires runtime support)
+- List.sort / List.sortBy (fundamental operation)
+- Better Time module (date parsing, formatting)
+- Regex (needs runtime/C support for performance)
+- Path module (cross-platform file path handling)
+
+**Should be packages** (application-level, opinionated, composable):
+- markdown
+- xml
+- rss/atom
+- frontmatter
+- template
+- csv
+- crypto
+- ssg (static site generator framework)
+
+---
+
+## Priority Package Plans
+
+Ordered by what unblocks blu-site fixes first, then general ecosystem value.
+
+---
+
+### Package 1: `markdown` (Priority: HIGHEST)
+
+**Why:** The 300-line markdown parser in blu-site's main.lux is general-purpose code that belongs in a reusable package. It's also the most complex part of blu-site and has known bugs (e.g., `### ` inside list items renders literally).
+
+**Scope:**
+```
+markdown/
+  lux.toml
+  lib.lux          # Public API: parse, parseInline
+  src/
+    inline.lux     # Inline parsing (bold, italic, links, images, code)
+    block.lux      # Block parsing (headings, lists, code blocks, blockquotes, hr)
+    types.lux      # AST types (optional - could emit HTML directly)
+```
+
+**Public API:**
+```lux
+// Convert markdown string to HTML string
+pub fn toHtml(markdown: String): String
+
+// Convert inline markdown only (no blocks)
+pub fn inlineToHtml(text: String): String
+
+// Escape HTML entities
+pub fn escapeHtml(s: String): String
+```
+
+**Improvements over current blu-site code:**
+- Fix heading-inside-list-item rendering (`- ### Title` should work)
+- Support nested lists (currently flat only)
+- Support reference-style links `[text][ref]`
+- Handle edge cases (empty lines in code blocks, nested blockquotes)
+- Proper HTML entity escaping in more contexts
+
+**Depends on:** Nothing (pure string processing)
+
+**Estimated size:** ~400-500 lines of Lux
+
+---
+
+### Package 2: `xml` (Priority: HIGH)
+
+**Why:** Needed for RSS/Atom feed generation, sitemap.xml, and robots.txt generation. General-purpose XML builder that doesn't try to parse XML (which would need regex), just emits it.
+
+**Scope:**
+```
+xml/
+  lux.toml
+  lib.lux          # Public API: element, document, serialize
+```
+
+**Public API:**
+```lux
+type XmlNode =
+    | Element(String, List<XmlAttr>, List<XmlNode>)
+    | Text(String)
+    | CData(String)
+    | Comment(String)
+    | Declaration(String, String)  // version, encoding
+
+type XmlAttr =
+    | Attr(String, String)
+
+// Build an XML element
+pub fn element(tag: String, attrs: List<XmlAttr>, children: List<XmlNode>): XmlNode
+
+// Build a text node (auto-escapes)
+pub fn text(content: String): XmlNode
+
+// Build a CDATA section
+pub fn cdata(content: String): XmlNode
+
+// Serialize XML tree to string
+pub fn serialize(node: XmlNode): String
+
+// Serialize with XML declaration header
+pub fn document(version: String, encoding: String, root: XmlNode): String
+
+// Convenience: self-closing element
+pub fn selfClosing(tag: String, attrs: List<XmlAttr>): XmlNode
+```
+
+**Depends on:** Nothing
+
+**Estimated size:** ~150-200 lines
+
+---
+
+### Package 3: `rss` (Priority: HIGH)
+
+**Why:** Directly needed for blu-site's #6 priority fix (add RSS feed). Builds on `xml` package.
+
+**Scope:**
+```
+rss/
+  lux.toml         # depends on xml
+  lib.lux          # Public API: feed, item, toXml, toAtom
+```
+
+**Public API:**
+```lux
+type FeedInfo =
+    | FeedInfo(String, String, String, String, String)
+    // title, link, description, language, lastBuildDate
+
+type FeedItem =
+    | FeedItem(String, String, String, String, String, String)
+    // title, link, description, pubDate, guid, categories (comma-separated)
+
+// Generate RSS 2.0 XML string
+pub fn toRss(info: FeedInfo, items: List<FeedItem>): String
+
+// Generate Atom 1.0 XML string
+pub fn toAtom(info: FeedInfo, items: List<FeedItem>): String
+```
+
+**Depends on:** `xml`
+
+**Estimated size:** ~100-150 lines
+
+---
+
+### Package 4: `frontmatter` (Priority: HIGH)
+
+**Why:** blu-site has ~50 lines of fragile frontmatter parsing. This is a common need for any content-driven Lux project. The current parser uses `String.indexOf(line, ": ")` which breaks on values containing `: `.
+
+**Scope:**
+```
+frontmatter/
+  lux.toml
+  lib.lux          # Public API: parse
+```
+
+**Public API:**
+```lux
+type FrontmatterResult =
+    | FrontmatterResult(List<(String, String)>, String)
+    // key-value pairs, remaining body
+
+// Parse frontmatter from a string (--- delimited YAML-like header)
+pub fn parse(content: String): FrontmatterResult
+
+// Get a value by key from parsed frontmatter
+pub fn get(pairs: List<(String, String)>, key: String): Option<String>
+
+// Get a value or default
+pub fn getOrDefault(pairs: List<(String, String)>, key: String, default: String): String
+
+// Parse a space-separated tag string into a list
+pub fn parseTags(tagString: String): List<String>
+```
+
+**Improvements over current blu-site code:**
+- Handle values with `: ` in them (only split on first `: `)
+- Handle multi-line values (indented continuation)
+- Handle quoted values with embedded newlines
+- Strip quotes from values consistently
+
+**Depends on:** Nothing
+
+**Estimated size:** ~100-150 lines
+
+---
+
+### Package 5: `path` (Priority: MEDIUM)
+
+**Why:** blu-site manually implements `basename` and `dirname`. Any file-processing Lux program needs these. Tiny but universally useful.
+
+**Scope:**
+```
+path/
+  lux.toml
+  lib.lux
+```
+
+**Public API:**
+```lux
+// Get filename from path: "/foo/bar.txt" -> "bar.txt"
+pub fn basename(p: String): String
+
+// Get directory from path: "/foo/bar.txt" -> "/foo"
+pub fn dirname(p: String): String
+
+// Get file extension: "file.txt" -> "txt", "file" -> ""
+pub fn extension(p: String): String
+
+// Remove file extension: "file.txt" -> "file"
+pub fn stem(p: String): String
+
+// Join path segments: join("foo", "bar") -> "foo/bar"
+pub fn join(a: String, b: String): String
+
+// Normalize path: "foo//bar/../baz" -> "foo/baz"
+pub fn normalize(p: String): String
+
+// Check if path is absolute
+pub fn isAbsolute(p: String): Bool
+```
+
+**Depends on:** Nothing
+
+**Estimated size:** ~80-120 lines
+
+---
+
+### Package 6: `sitemap` (Priority: MEDIUM)
+
+**Why:** Directly needed for blu-site's #9 priority fix. Simple package that generates sitemap.xml.
+
+**Scope:**
+```
+sitemap/
+  lux.toml         # depends on xml
+  lib.lux
+```
+
+**Public API:**
+```lux
+type SitemapEntry =
+    | SitemapEntry(String, String, String, String)
+    // url, lastmod (ISO date), changefreq, priority
+
+// Generate sitemap.xml string
+pub fn generate(entries: List<SitemapEntry>): String
+
+// Generate a simple robots.txt pointing to the sitemap
+pub fn robotsTxt(sitemapUrl: String): String
+```
+
+**Depends on:** `xml`
+
+**Estimated size:** ~50-70 lines
+
+---
+
+### Package 7: `ssg` (Priority: LOW - future)
+
+**Why:** Once markdown, frontmatter, rss, sitemap, and path packages exist, the remaining logic in blu-site's main.lux is generic SSG framework code: read content dirs, parse posts, sort by date, generate section indexes, generate tag pages, copy static assets. This could be extracted into a framework package that other Lux users could use to build their own static sites.
+
+**This should wait** until the foundation packages above are stable and battle-tested through blu-site usage.
+
+---
+
+## Non-Package Stdlib Improvements Needed
+
+These gaps are too fundamental to be packages and should be added to the Lux language itself:
+
+### HashMap (Critical)
+Every package above that needs key-value lookups (frontmatter, xml attributes, etc.) is working around the lack of HashMap with `List<(String, String)>`. This is O(n) per lookup and makes code verbose. A stdlib `Map` module would transform the ecosystem.
+
+### List.sort / List.sortBy (High)
+blu-site implements insertion sort manually. Every content-driven app needs sorting. This should be a stdlib function.
+
+### Time.format / Time.parse (High)
+blu-site manually parses "2025-01-15" by substring extraction and maps month numbers to names. A proper date/time library (even just ISO 8601 parsing and basic formatting) would help every package above.
+
+---
+
+## Implementation Order
+
+```
+Phase 1 (unblock blu-site fixes):
+  1. markdown     - extract from blu-site, fix bugs, publish
+  2. frontmatter  - extract from blu-site, improve robustness
+  3. path         - tiny, universally useful
+  4. xml          - needed by rss and sitemap
+
+Phase 2 (complete blu-site features):
+  5. rss          - depends on xml
+  6. sitemap      - depends on xml
+
+Phase 3 (ecosystem growth):
+  7. template     - string templating (mustache-like)
+  8. csv          - data processing
+  9. cli          - argument parsing
+  10. ssg         - framework extraction from blu-site
+```
+
+Each package should be developed in its own directory under `~/src/`, published to the git.qrty.ink registry, and tested by integrating it into blu-site.
--- a/README.md
+++ b/README.md
@@ -2,15 +2,22 @@

 A functional programming language with first-class effects, schema evolution, and behavioral types.

-## Vision
+## Philosophy

-Most programming languages treat three critical concerns as afterthoughts:
+**Make the important things visible.**

-1. **Effects** — What can this code do? (Hidden, untraceable, untestable)
-2. **Data Evolution** — Types change, data persists. (Manual migrations, runtime failures)
-3. **Behavioral Properties** — Is this idempotent? Does it terminate? (Comments and hope)
+Most languages hide what matters most: what code can do (effects), how data changes over time (schema evolution), and what guarantees functions provide (behavioral properties). Lux makes all three first-class, compiler-checked language features.

-Lux makes these first-class language features. The compiler knows what your code does, how your data evolves, and what properties your functions guarantee.
+| Principle | What it means |
+|-----------|--------------|
+| **Explicit over implicit** | Effects in types — see what code does |
+| **Composition over configuration** | No DI frameworks — effects compose naturally |
+| **Safety without ceremony** | Type inference + explicit signatures where they matter |
+| **Practical over academic** | Familiar syntax, ML semantics, no monads |
+| **One right way** | Opinionated formatter, integrated tooling, built-in test framework |
+| **Tools are the language** | `lux fmt/lint/check/test/compile` — one binary, not seven tools |
+
+See [docs/PHILOSOPHY.md](./docs/PHILOSOPHY.md) for the full philosophy with language comparisons and design rationale.

 ## Core Principles

--- a/build.rs
+++ b/build.rs
@@ -0,0 +1,38 @@
+use std::path::PathBuf;
+
+fn main() {
+    // Capture the absolute C compiler path at build time so the binary is self-contained.
+    // This is critical for Nix builds where cc/gcc live in /nix/store paths.
+    let cc_path = std::env::var("CC").ok()
+        .filter(|s| !s.is_empty())
+        .and_then(|s| resolve_absolute(&s))
+        .or_else(|| find_in_path("cc"))
+        .or_else(|| find_in_path("gcc"))
+        .or_else(|| find_in_path("clang"))
+        .unwrap_or_default();
+
+    println!("cargo:rustc-env=LUX_CC_PATH={}", cc_path);
+    println!("cargo:rerun-if-env-changed=CC");
+    println!("cargo:rerun-if-env-changed=PATH");
+}
+
+/// Resolve a command name to its absolute path by searching PATH.
+fn find_in_path(cmd: &str) -> Option<String> {
+    let path_var = std::env::var("PATH").ok()?;
+    for dir in path_var.split(':') {
+        let candidate = PathBuf::from(dir).join(cmd);
+        if candidate.is_file() {
+            return Some(candidate.to_string_lossy().into_owned());
+        }
+    }
+    None
+}
+
+/// If the path is already absolute and exists, return it. Otherwise search PATH.
+fn resolve_absolute(cmd: &str) -> Option<String> {
+    let p = PathBuf::from(cmd);
+    if p.is_absolute() && p.is_file() {
+        return Some(cmd.to_string());
+    }
+    find_in_path(cmd)
+}
--- a/docs/PHILOSOPHY.md
+++ b/docs/PHILOSOPHY.md
@@ -0,0 +1,449 @@
+# The Lux Philosophy
+
+## In One Sentence
+
+**Make the important things visible.**
+
+## The Three Pillars
+
+Most programming languages hide the things that matter most in production:
+
+1. **What can this code do?** — Side effects are invisible in function signatures
+2. **How does data change over time?** — Schema evolution is a deployment problem, not a language one
+3. **What guarantees does this code provide?** — Properties like idempotency live in comments and hope
+
+Lux makes all three first-class, compiler-checked language features.
+
+---
+
+## Core Principles
+
+### 1. Explicit Over Implicit
+
+Every function signature tells you what it does:
+
+```lux
+fn processOrder(order: Order): Receipt with {Database, Email, Logger}
+```
+
+You don't need to read the body, trace call chains, or check documentation. The signature *is* the documentation. Code review becomes: "should this function really send emails?"
+
+**What this means in practice:**
+- Effects are declared in types, not hidden behind interfaces
+- No dependency injection frameworks — just swap handlers
+- No mocking libraries — test with different effect implementations
+- No "spooky action at a distance" — if a function can fail, its type says so
+
+**How this compares:**
+| Language | Side effects | Lux equivalent |
+|----------|-------------|----------------|
+| JavaScript | Anything, anywhere, silently | `with {Console, Http, File}` |
+| Python | Implicit, discovered by reading code | Effect declarations in signature |
+| Java | Checked exceptions (partial), DI frameworks | Effects + handlers |
+| Go | Return error values (partial) | `with {Fail}` or `Result` |
+| Rust | `unsafe` blocks, `Result`/`Option` | Effects for I/O, Result for values |
+| Haskell | Monad transformers (explicit but heavy) | Effects (explicit and lightweight) |
+| Koka | Algebraic effects (similar) | Same family, more familiar syntax |
+
+### 2. Composition Over Configuration
+
+Things combine naturally without glue code:
+
+```lux
+// Multiple effects compose by listing them
+fn sync(id: UserId): User with {Database, Http, Logger} = ...
+
+// Handlers compose by providing them
+run sync(id) with {
+    Database = postgres(conn),
+    Http = realHttp,
+    Logger = consoleLogger
+}
+```
+
+No monad transformers. No middleware stacks. No factory factories. Effects are sets; they union naturally.
+
+**What this means in practice:**
+- Functions compose with `|>` (pipes)
+- Effects compose by set union
+- Types compose via generics and ADTs
+- Tests compose by handler substitution
+
+### 3. Safety Without Ceremony
+
+The type system catches errors at compile time, but doesn't make you fight it:
+
+```lux
+// Type inference keeps code clean
+let x = 42                    // Int, inferred
+let names = ["Alice", "Bob"]  // List<String>, inferred
+
+// But function signatures are always explicit
+fn greet(name: String): String = "Hello, {name}"
+```
+
+**The balance:**
+- Function signatures: always annotated (documentation + API contract)
+- Local bindings: inferred (reduces noise in implementation)
+- Effects: declared or inferred (explicit at boundaries, lightweight inside)
+- Behavioral properties: opt-in (`is pure`, `is total` — add when valuable)
+
+### 4. Practical Over Academic
+
+Lux borrows from the best of programming language research, but wraps it in familiar syntax:
+
+```lux
+// This is algebraic effects. But it reads like normal code.
+fn main(): Unit with {Console} = {
+    Console.print("What's your name?")
+    let name = Console.readLine()
+    Console.print("Hello, {name}!")
+}
+```
+
+Compare with Haskell's equivalent:
+```haskell
+main :: IO ()
+main = do
+    putStrLn "What's your name?"
+    name <- getLine
+    putStrLn ("Hello, " ++ name ++ "!")
+```
+
+Both are explicit about effects. Lux chooses syntax that reads like imperative code while maintaining the same guarantees.
+
+**What this means in practice:**
+- ML-family semantics, C-family appearance
+- No monads to learn (effects replace them)
+- No category theory prerequisites
+- The learning curve is: functions → types → effects (days, not months)
+
+### 5. One Right Way
+
+Like Go and Python, Lux favors having one obvious way to do things:
+
+- **One formatter** (`lux fmt`) — opinionated, not configurable, ends all style debates
+- **One test framework** (built-in `Test` effect) — no framework shopping
+- **One way to handle effects** — declare, handle, compose
+- **One package manager** (`lux pkg`) — integrated, not bolted on
+
+This is a deliberate rejection of the JavaScript/Ruby approach where every project assembles its own stack from dozens of competing libraries.
+
+### 6. Tools Are Part of the Language
+
+The compiler, linter, formatter, LSP, package manager, and test runner are one thing, not seven:
+
+```bash
+lux fmt        # Format
+lux lint       # Lint (with --explain for education)
+lux check      # Type check + lint
+lux test       # Run tests
+lux compile    # Build a binary
+lux serve      # Serve files
+lux --lsp      # Editor integration
+```
+
+This follows Go's philosophy: a language is its toolchain. The formatter knows the AST. The linter knows the type system. The LSP knows the effects. They're not afterthoughts.
+
+---
+
+## Design Decisions and Their Reasons
+
+### Why algebraic effects instead of monads?
+
+Monads are powerful but have poor ergonomics for composition. Combining `IO`, `State`, and `Error` in Haskell requires monad transformers — a notoriously difficult concept. Effects compose naturally:
+
+```lux
+// Just list the effects you need. No transformers.
+fn app(): Unit with {Console, File, Http, Time} = ...
+```
+
+### Why not just `async/await`?
+
+`async/await` solves one effect (concurrency). Effects solve all of them: I/O, state, randomness, failure, concurrency, logging, databases. One mechanism, universally applicable.
+
+### Why require function type annotations?
+
+Three reasons:
+1. **Documentation**: Every function signature is self-documenting
+2. **Error messages**: Inference failures produce confusing errors; annotations localize them
+3. **API stability**: Changing a function body shouldn't silently change its type
+
+### Why an opinionated formatter?
+
+Style debates waste engineering time. `gofmt` proved that an opinionated, non-configurable formatter eliminates an entire category of bikeshedding. `lux fmt` does the same.
+
+### Why immutable by default?
+
+Mutable state is the root of most concurrency bugs and many logic bugs. Immutability makes code easier to reason about. When you need state, the `State` effect makes it explicit and trackable.
+
+### Why behavioral types?
+
+Properties like "this function is idempotent" or "this function always terminates" are critical for correctness but typically live in comments. Making them part of the type system means:
+- The compiler can verify them (or generate property tests)
+- Callers can require them (`where F is idempotent`)
+- They serve as machine-readable documentation
+
+---
+
+## Comparison with Popular Languages
+
+### JavaScript / TypeScript (SO #1 / #6 by usage)
+
+| Aspect | JavaScript/TypeScript | Lux |
+|--------|----------------------|-----|
+| **Type system** | Optional/gradual (TS) | Required, Hindley-Milner |
+| **Side effects** | Anywhere, implicit | Declared in types |
+| **Testing** | Mock libraries (Jest, etc.) | Swap effect handlers |
+| **Formatting** | Prettier (configurable) | `lux fmt` (opinionated) |
+| **Package management** | npm (massive ecosystem) | `lux pkg` (small ecosystem) |
+| **Paradigm** | Multi-paradigm | Functional-first |
+| **Null safety** | Optional chaining (partial) | `Option<T>`, no null |
+| **Error handling** | try/catch (unchecked) | `Result<T, E>` + `Fail` effect |
+| **Shared** | Familiar syntax, first-class functions, closures, string interpolation |
+
+**What Lux learns from JS/TS:** Familiar syntax matters. String interpolation, arrow functions, and readable code lower the barrier to entry.
+
+**What Lux rejects:** Implicit `any`, unchecked exceptions, the "pick your own adventure" toolchain.
+
+### Python (SO #4 by usage, #1 most desired)
+
+| Aspect | Python | Lux |
+|--------|--------|-----|
+| **Type system** | Optional (type hints) | Required, static |
+| **Side effects** | Implicit | Explicit |
+| **Performance** | Slow (interpreted) | Faster (compiled to C) |
+| **Syntax** | Whitespace-significant | Braces/keywords |
+| **Immutability** | Mutable by default | Immutable by default |
+| **Tooling** | Fragmented (black, ruff, mypy, pytest...) | Unified (`lux` binary) |
+| **Shared** | Clean syntax philosophy, "one way to do it", readability focus |
+
+**What Lux learns from Python:** Readability counts. The Zen of Python's emphasis on one obvious way to do things resonates with Lux's design.
+
+**What Lux rejects:** Dynamic typing, mutable-by-default, fragmented tooling.
+
+### Rust (SO #1 most admired)
+
+| Aspect | Rust | Lux |
+|--------|------|-----|
+| **Memory** | Ownership/borrowing (manual) | Reference counting (automatic) |
+| **Type system** | Traits, generics, lifetimes | ADTs, effects, generics |
+| **Side effects** | Implicit (except `unsafe`) | Explicit (effect system) |
+| **Error handling** | `Result<T, E>` + `?` | `Result<T, E>` + `Fail` effect |
+| **Performance** | Zero-cost, systems-level | Good, not systems-level |
+| **Learning curve** | Steep (ownership) | Moderate (effects) |
+| **Pattern matching** | Excellent, exhaustive | Excellent, exhaustive |
+| **Shared** | ADTs, pattern matching, `Option`/`Result`, no null, immutable by default, strong type system |
+
+**What Lux learns from Rust:** ADTs with exhaustive matching, `Option`/`Result` instead of null/exceptions, excellent error messages, integrated tooling (cargo model).
+
+**What Lux rejects:** Ownership complexity (Lux uses GC/RC instead), lifetimes, `unsafe`.
+
+### Go (SO #13 by usage, #11 most admired)
+
+| Aspect | Go | Lux |
+|--------|-----|-----|
+| **Type system** | Structural, simple | HM inference, ADTs |
+| **Side effects** | Implicit | Explicit |
+| **Error handling** | Multiple returns (`val, err`) | `Result<T, E>` + effects |
+| **Formatting** | `gofmt` (opinionated) | `lux fmt` (opinionated) |
+| **Tooling** | All-in-one (`go` binary) | All-in-one (`lux` binary) |
+| **Concurrency** | Goroutines + channels | `Concurrent` + `Channel` effects |
+| **Generics** | Added late, limited | First-class from day one |
+| **Shared** | Opinionated formatter, unified tooling, practical philosophy |
+
+**What Lux learns from Go:** Unified toolchain, opinionated formatting, simplicity as a feature, fast compilation.
+
+**What Lux rejects:** Verbose error handling (`if err != nil`), no ADTs, no generics (historically), nil.
+
+### Java / C# (SO #7 / #8 by usage)
+
+| Aspect | Java/C# | Lux |
+|--------|---------|-----|
+| **Paradigm** | OOP-first | FP-first |
+| **Effects** | DI frameworks (Spring, etc.) | Language-level effects |
+| **Testing** | Mock frameworks (Mockito, etc.) | Handler swapping |
+| **Null safety** | Nullable (Java), nullable ref types (C#) | `Option<T>` |
+| **Boilerplate** | High (getters, setters, factories) | Low (records, inference) |
+| **Shared** | Static typing, generics, pattern matching (recent), established ecosystems |
+
+**What Lux learns from Java/C#:** Enterprise needs (database effects, HTTP, serialization) matter. Testability is a first-class concern.
+
+**What Lux rejects:** OOP ceremony, DI frameworks, null, boilerplate.
+
+### Haskell / OCaml / Elm (FP family)
+
+| Aspect | Haskell | Elm | Lux |
+|--------|---------|-----|-----|
+| **Effects** | Monads + transformers | Cmd/Sub (Elm Architecture) | Algebraic effects |
+| **Learning curve** | Steep | Moderate | Moderate |
+| **Error messages** | Improving | Excellent | Good (aspiring to Elm-quality) |
+| **Practical focus** | Academic-leaning | Web-focused | General-purpose |
+| **Syntax** | Unique | Unique | Familiar (C-family feel) |
+| **Shared** | Immutability, ADTs, pattern matching, type inference, no null |
+
+**What Lux learns from Haskell:** Effects must be explicit. Types must be powerful. Purity matters.
+
+**What Lux learns from Elm:** Error messages should teach. Tooling should be integrated. Simplicity beats power.
+
+**What Lux rejects (from Haskell):** Monad transformers, academic syntax, steep learning curve.
+
+### Gleam / Elixir (SO #2 / #3 most admired, 2025)
+
+| Aspect | Gleam | Elixir | Lux |
+|--------|-------|--------|-----|
+| **Type system** | Static, HM | Dynamic | Static, HM |
+| **Effects** | No special tracking | Implicit | First-class |
+| **Concurrency** | BEAM (built-in) | BEAM (built-in) | Effect-based |
+| **Error handling** | `Result` | Pattern matching on tuples | `Result` + `Fail` effect |
+| **Shared** | Friendly errors, pipe operator, functional style, immutability |
+
+**What Lux learns from Gleam:** Friendly developer experience, clear error messages, and pragmatic FP resonate with developers.
+
+---
+
+## Tooling Philosophy Audit
+
+### Does the linter follow the philosophy?
+
+**Yes, strongly.** The linter embodies "make the important things visible":
+
+- `could-be-pure`: Nudges users toward declaring purity — making guarantees visible
+- `could-be-total`: Same for termination
+- `unnecessary-effect-decl`: Keeps effect signatures honest — don't claim effects you don't use
+- `unused-variable/import/function`: Keeps code focused — everything visible should be meaningful
+- `single-arm-match` / `manual-map-option`: Teaches idiomatic patterns
+
+The category system (correctness > suspicious > idiom > style > pedantic) reflects the philosophy of being practical, not academic: real bugs are errors, style preferences are opt-in.
+
+### Does the formatter follow the philosophy?
+
+**Yes, with one gap.** The formatter is opinionated and non-configurable, matching the "one right way" principle. It enforces consistent style across all Lux code.
+
+**Gap:** `max_width` and `trailing_commas` are declared in `FormatConfig` but never used. This is harmless but inconsistent — either remove the unused config or implement line wrapping.
+
+### Does the type checker follow the philosophy?
+
+**Yes.** The type checker embodies every core principle:
+- Effects are tracked and verified in function types
+- Behavioral properties are checked where possible
+- Error messages include context and suggestions
+- Type inference reduces ceremony while maintaining safety
+
+---
+
+## What Could Be Improved
+
+### High-value additions (improve experience significantly, low verbosity cost)
+
+1. **Pipe-friendly standard library**
+   - Currently: `List.map(myList, fn(x: Int): Int => x * 2)`
+   - Better: Allow `myList |> List.map(fn(x: Int): Int => x * 2)`
+   - Many languages (Elixir, F#, Gleam) make the pipe operator the primary composition tool. If the first argument of stdlib functions is always the data, pipes become natural. This is a **library convention**, not a language change.
+   - **LLM impact:** Pipe chains are easier for LLMs to generate and read — linear data flow with no nesting.
+   - **Human impact:** Reduces cognitive load. Reading left-to-right matches how humans think about data transformation.
+
+2. **Exhaustive `match` warnings for non-enum types**
+   - The linter warns about `wildcard-on-small-enum`, but could also warn when a match on `Option` or `Result` uses a wildcard instead of handling both cases explicitly.
+   - **Both audiences:** Prevents subtle bugs where new variants are silently caught by `_`.
+
+3. **Error message improvements toward Elm quality**
+   - Current errors show the right information but could be more conversational and suggest fixes more consistently.
+   - Example improvement: When a function is called with wrong argument count, show the expected signature and highlight which argument is wrong.
+   - **LLM impact:** Structured error messages with clear "expected X, got Y" patterns are easier for LLMs to parse and fix.
+   - **Human impact:** Friendly errors reduce frustration, especially for beginners.
+
+4. **`let ... else` for fallible destructuring**
+   - Rust's `let ... else` pattern handles the "unwrap or bail" case elegantly:
+     ```lux
+     let Some(value) = maybeValue else return defaultValue
+     ```
+   - Currently requires a full `match` expression for this common pattern.
+   - **Both audiences:** Reduces boilerplate for the most common Option/Result handling pattern.
+
+5. **Trait/typeclass system for overloading**
+   - Currently `toString`, `==`, and similar operations are built-in. A trait system would let users define their own:
+     ```lux
+     trait Show<T> { fn show(value: T): String }
+     impl Show<User> { fn show(u: User): String = "User({u.name})" }
+     ```
+   - **Note:** This exists partially. Expanding it would enable more generic programming without losing explicitness.
+   - **LLM impact:** Traits provide clear, greppable contracts. LLMs can generate trait impls from examples.
+
+### Medium-value additions (good improvements, some verbosity cost)
+
+6. **Named arguments or builder pattern for records**
+   - When functions take many parameters, the linter already warns at 5+. Named arguments or record-punning would help:
+     ```lux
+     fn createUser({ name, email, age }: UserConfig): User = ...
+     createUser({ name: "Alice", email: "alice@ex.com", age: 30 })
+     ```
+   - **Trade-off:** Adds syntax, but the linter already pushes users toward records for many params.
+
+7. **Async/concurrent effect sugar**
+   - The `Concurrent` effect exists but could benefit from syntactic sugar:
+     ```lux
+     let (a, b) = concurrent {
+         fetch("/api/users"),
+         fetch("/api/posts")
+     }
+     ```
+   - **Trade-off:** Adds syntax, but concurrent code is important enough to warrant it.
+
+8. **Module-level documentation with `///` doc comments**
+   - The `missing-doc-comment` lint exists, but the doc generation system could be enhanced with richer doc comments that include examples, parameter descriptions, and effect documentation.
+   - **LLM impact:** Structured documentation is the single highest-value feature for LLM code understanding.
+
+### Lower-value or risky additions (consider carefully)
+
+9. **Type inference for function return types**
+   - Would reduce ceremony: `fn double(x: Int) = x * 2` instead of `fn double(x: Int): Int = x * 2`
+   - **Risk:** Violates the "function signatures are documentation" principle. A body change could silently change the API. Current approach is the right trade-off.
+
+10. **Operator overloading**
+    - Tempting for numeric types, but quickly leads to the C++ problem where `+` could mean anything.
+    - **Risk:** Violates "make the important things visible" — you can't tell what `a + b` does.
+    - **Better:** Keep operators for built-in numeric types. Use named functions for everything else.
+
+11. **Macros**
+    - Powerful but drastically complicate tooling, error messages, and readability.
+    - **Risk:** Rust's macro system is powerful but produces some of the worst error messages in the language.
+    - **Better:** Solve specific problems with language features (effects, generics) rather than a general metaprogramming escape hatch.
+
+---
+
+## The LLM Perspective
+
+Lux has several properties that make it unusually well-suited for LLM-assisted programming:
+
+1. **Effect signatures are machine-readable contracts.** An LLM reading `fn f(): T with {Database, Logger}` knows exactly what capabilities to provide when generating handler code.
+
+2. **Behavioral properties are verifiable assertions.** `is pure`, `is idempotent` give LLMs clear constraints to check their own output against.
+
+3. **The opinionated formatter eliminates style ambiguity.** LLMs don't need to guess indentation, brace style, or naming conventions — `lux fmt` handles it.
+
+4. **Exhaustive pattern matching forces completeness.** LLMs that generate `match` expressions are reminded by the compiler when they miss cases.
+
+5. **Small, consistent standard library.** `List.map`, `String.split`, `Option.map` — uniform `Module.function` convention is easy to learn from few examples.
+
+6. **Effect-based testing needs no framework knowledge.** An LLM doesn't need to know Jest, pytest, or JUnit — just swap handlers.
+
+**What would help LLMs more:**
+- Structured error output (JSON mode) for programmatic error fixing
+- Example-rich documentation that LLMs can learn patterns from
+- A canonical set of "Lux patterns" (like Go's proverbs) that encode best practices in memorable form
+
+---
+
+## Summary
+
+Lux's philosophy can be compressed to five words: **Make the important things visible.**
+
+This manifests as:
+- **Effects in types** — see what code does
+- **Properties in types** — see what code guarantees
+- **Versions in types** — see how data evolves
+- **One tool for everything** — see how to build
+- **One format for all** — see consistent style
+
+The language is in the sweet spot between Haskell's rigor and Python's practicality, with Go's tooling philosophy and Elm's developer experience aspirations. It doesn't try to be everything — it tries to make the things that matter most in real software visible, composable, and verifiable.
--- a/flake.nix
+++ b/flake.nix
@@ -14,6 +14,7 @@
        pkgs = import nixpkgs { inherit system overlays; };
        rustToolchain = pkgs.rust-bin.stable.latest.default.override {
          extensions = [ "rust-src" "rust-analyzer" ];
+          targets = [ "x86_64-unknown-linux-musl" ];
        };
      in
      {
@@ -22,8 +23,8 @@
            rustToolchain
            cargo-watch
            cargo-edit
-            pkg-config
-            openssl
+            # Static builds
+            pkgsStatic.stdenv.cc
            # Benchmark tools
            hyperfine
            poop
@@ -43,7 +44,7 @@
            printf "\n"
            printf "  \033[1;35m╦  ╦ ╦╦ ╦\033[0m\n"
            printf "  \033[1;35m║  ║ ║╔╣\033[0m\n"
-            printf "  \033[1;35m╩═╝╚═╝╩ ╩\033[0m  v0.1.0\n"
+            printf "  \033[1;35m╩═╝╚═╝╩ ╩\033[0m  v0.1.11\n"
            printf "\n"
            printf "  Functional language with first-class effects\n"
            printf "\n"
@@ -61,18 +62,47 @@

        packages.default = pkgs.rustPlatform.buildRustPackage {
          pname = "lux";
-          version = "0.1.0";
+          version = "0.1.11";
          src = ./.;
          cargoLock.lockFile = ./Cargo.lock;

-          nativeBuildInputs = [ pkgs.pkg-config ];
-          buildInputs = [ pkgs.openssl ];
-
          doCheck = false;
        };

-        # Benchmark scripts
+        packages.static = let
+          muslPkgs = import nixpkgs {
+            inherit system;
+            crossSystem = {
+              config = "x86_64-unknown-linux-musl";
+              isStatic = true;
+            };
+          };
+        in muslPkgs.rustPlatform.buildRustPackage {
+          pname = "lux";
+          version = "0.1.11";
+          src = ./.;
+          cargoLock.lockFile = ./Cargo.lock;
+
+          CARGO_BUILD_TARGET = "x86_64-unknown-linux-musl";
+          CARGO_BUILD_RUSTFLAGS = "-C target-feature=+crt-static";
+
+          doCheck = false;
+
+          postInstall = ''
+            $STRIP $out/bin/lux 2>/dev/null || true
+          '';
+        };
+
        apps = {
+          # Release automation
+          release = {
+            type = "app";
+            program = toString (pkgs.writeShellScript "lux-release" ''
+              exec ${self}/scripts/release.sh "$@"
+            '');
+          };
+
+          # Benchmark scripts
          # Run hyperfine benchmark comparison
          bench = {
            type = "app";
--- a/projects/lux-compiler/ast.lux
+++ b/projects/lux-compiler/ast.lux
@@ -0,0 +1,225 @@
+// Lux AST — Self-hosted Abstract Syntax Tree definitions
+//
+// Direct translation of src/ast.rs into Lux ADTs.
+// These types represent the parsed structure of a Lux program.
+//
+// Naming conventions to avoid collisions:
+//   Ex = Expr variant, Pat = Pattern, Te = TypeExpr
+//   Td = TypeDef, Vf = VariantFields, Op = Operator
+//   Decl = Declaration, St = Statement
+
+// === Source Location ===
+
+type Span = | Span(Int, Int)
+
+// === Identifiers ===
+
+type Ident = | Ident(String, Span)
+
+// === Visibility ===
+
+type Visibility = | Public | Private
+
+// === Schema Evolution ===
+
+type Version = | Version(Int, Span)
+
+type VersionConstraint =
+    | VcExact(Version)
+    | VcAtLeast(Version)
+    | VcLatest(Span)
+
+// === Behavioral Types ===
+
+type BehavioralProperty =
+    | BpPure
+    | BpTotal
+    | BpIdempotent
+    | BpDeterministic
+    | BpCommutative
+
+// === Trait Bound (needed before WhereClause) ===
+
+type TraitBound = | TraitBound(Ident, List<TypeExpr>, Span)
+
+// === Trait Constraint (needed before WhereClause) ===
+
+type TraitConstraint = | TraitConstraint(Ident, List<TraitBound>, Span)
+
+// === Where Clauses ===
+
+type WhereClause =
+    | WcProperty(Ident, BehavioralProperty, Span)
+    | WcResult(Expr, Span)
+    | WcTrait(TraitConstraint)
+
+// === Module Path ===
+
+type ModulePath = | ModulePath(List<Ident>, Span)
+
+// === Import ===
+
+// path, alias, items, wildcard, span
+type ImportDecl = | ImportDecl(ModulePath, Option<Ident>, Option<List<Ident>>, Bool, Span)
+
+// === Program ===
+
+type Program = | Program(List<ImportDecl>, List<Declaration>)
+
+// === Declarations ===
+
+type Declaration =
+    | DeclFunction(FunctionDecl)
+    | DeclEffect(EffectDecl)
+    | DeclType(TypeDecl)
+    | DeclHandler(HandlerDecl)
+    | DeclLet(LetDecl)
+    | DeclTrait(TraitDecl)
+    | DeclImpl(ImplDecl)
+
+// === Parameter ===
+
+type Parameter = | Parameter(Ident, TypeExpr, Span)
+
+// === Effect Operation ===
+
+type EffectOp = | EffectOp(Ident, List<Parameter>, TypeExpr, Span)
+
+// === Record Field ===
+
+type RecordField = | RecordField(Ident, TypeExpr, Span)
+
+// === Variant Fields ===
+
+type VariantFields =
+    | VfUnit
+    | VfTuple(List<TypeExpr>)
+    | VfRecord(List<RecordField>)
+
+// === Variant ===
+
+type Variant = | Variant(Ident, VariantFields, Span)
+
+// === Migration ===
+
+type Migration = | Migration(Version, Expr, Span)
+
+// === Handler Impl ===
+
+// op_name, params, resume, body, span
+type HandlerImpl = | HandlerImpl(Ident, List<Ident>, Option<Ident>, Expr, Span)
+
+// === Impl Method ===
+
+// name, params, return_type, body, span
+type ImplMethod = | ImplMethod(Ident, List<Parameter>, Option<TypeExpr>, Expr, Span)
+
+// === Trait Method ===
+
+// name, type_params, params, return_type, default_impl, span
+type TraitMethod = | TraitMethod(Ident, List<Ident>, List<Parameter>, TypeExpr, Option<Expr>, Span)
+
+// === Type Expressions ===
+
+type TypeExpr =
+    | TeNamed(Ident)
+    | TeApp(TypeExpr, List<TypeExpr>)
+    | TeFunction(List<TypeExpr>, TypeExpr, List<Ident>)
+    | TeTuple(List<TypeExpr>)
+    | TeRecord(List<RecordField>)
+    | TeUnit
+    | TeVersioned(TypeExpr, VersionConstraint)
+
+// === Literal ===
+
+type LiteralKind =
+    | LitInt(Int)
+    | LitFloat(String)
+    | LitString(String)
+    | LitChar(Char)
+    | LitBool(Bool)
+    | LitUnit
+
+type Literal = | Literal(LiteralKind, Span)
+
+// === Binary Operators ===
+
+type BinaryOp =
+    | OpAdd | OpSub | OpMul | OpDiv | OpMod
+    | OpEq | OpNe | OpLt | OpLe | OpGt | OpGe
+    | OpAnd | OpOr
+    | OpPipe | OpConcat
+
+// === Unary Operators ===
+
+type UnaryOp = | OpNeg | OpNot
+
+// === Statements ===
+
+type Statement =
+    | StExpr(Expr)
+    | StLet(Ident, Option<TypeExpr>, Expr, Span)
+
+// === Match Arms ===
+
+type MatchArm = | MatchArm(Pattern, Option<Expr>, Expr, Span)
+
+// === Patterns ===
+
+type Pattern =
+    | PatWildcard(Span)
+    | PatVar(Ident)
+    | PatLiteral(Literal)
+    | PatConstructor(Ident, List<Pattern>, Span)
+    | PatRecord(List<(Ident, Pattern)>, Span)
+    | PatTuple(List<Pattern>, Span)
+
+// === Function Declaration ===
+// visibility, doc, name, type_params, params, return_type, effects, properties, where_clauses, body, span
+type FunctionDecl = | FunctionDecl(Visibility, Option<String>, Ident, List<Ident>, List<Parameter>, TypeExpr, List<Ident>, List<BehavioralProperty>, List<WhereClause>, Expr, Span)
+
+// === Effect Declaration ===
+// doc, name, type_params, operations, span
+type EffectDecl = | EffectDecl(Option<String>, Ident, List<Ident>, List<EffectOp>, Span)
+
+// === Type Declaration ===
+// visibility, doc, name, type_params, version, definition, migrations, span
+type TypeDecl = | TypeDecl(Visibility, Option<String>, Ident, List<Ident>, Option<Version>, TypeDef, List<Migration>, Span)
+
+// === Handler Declaration ===
+// name, params, effect, implementations, span
+type HandlerDecl = | HandlerDecl(Ident, List<Parameter>, Ident, List<HandlerImpl>, Span)
+
+// === Let Declaration ===
+// visibility, doc, name, typ, value, span
+type LetDecl = | LetDecl(Visibility, Option<String>, Ident, Option<TypeExpr>, Expr, Span)
+
+// === Trait Declaration ===
+// visibility, doc, name, type_params, super_traits, methods, span
+type TraitDecl = | TraitDecl(Visibility, Option<String>, Ident, List<Ident>, List<TraitBound>, List<TraitMethod>, Span)
+
+// === Impl Declaration ===
+// type_params, constraints, trait_name, trait_args, target_type, methods, span
+type ImplDecl = | ImplDecl(List<Ident>, List<TraitConstraint>, Ident, List<TypeExpr>, TypeExpr, List<ImplMethod>, Span)
+
+// === Expressions ===
+
+type Expr =
+    | ExLiteral(Literal)
+    | ExVar(Ident)
+    | ExBinaryOp(BinaryOp, Expr, Expr, Span)
+    | ExUnaryOp(UnaryOp, Expr, Span)
+    | ExCall(Expr, List<Expr>, Span)
+    | ExEffectOp(Ident, Ident, List<Expr>, Span)
+    | ExField(Expr, Ident, Span)
+    | ExTupleIndex(Expr, Int, Span)
+    | ExLambda(List<Parameter>, Option<TypeExpr>, List<Ident>, Expr, Span)
+    | ExLet(Ident, Option<TypeExpr>, Expr, Expr, Span)
+    | ExIf(Expr, Expr, Expr, Span)
+    | ExMatch(Expr, List<MatchArm>, Span)
+    | ExBlock(List<Statement>, Expr, Span)
+    | ExRecord(Option<Expr>, List<(Ident, Expr)>, Span)
+    | ExTuple(List<Expr>, Span)
+    | ExList(List<Expr>, Span)
+    | ExRun(Expr, List<(Ident, Expr)>, Span)
+    | ExResume(Expr, Span)
--- a/projects/lux-compiler/lexer.lux
+++ b/projects/lux-compiler/lexer.lux
@@ -0,0 +1,512 @@
+// Lux Lexer — Self-hosted lexer for the Lux language
+//
+// This is the first component of the Lux-in-Lux compiler.
+// It tokenizes Lux source code into a list of tokens.
+//
+// Design:
+//   - Recursive descent character scanning
+//   - Immutable state (ParseState tracks chars + position)
+//   - Pattern matching for all token types
+
+// === Token types ===
+
+type TokenKind =
+    // Literals
+    | TkInt(Int)
+    | TkFloat(String)
+    | TkString(String)
+    | TkChar(Char)
+    | TkBool(Bool)
+    // Identifiers
+    | TkIdent(String)
+    // Keywords
+    | TkFn | TkLet | TkIf | TkThen | TkElse | TkMatch
+    | TkWith | TkEffect | TkHandler | TkRun | TkResume
+    | TkType | TkImport | TkPub | TkAs | TkFrom
+    | TkTrait | TkImpl | TkFor
+    // Behavioral
+    | TkIs | TkPure | TkTotal | TkIdempotent
+    | TkDeterministic | TkCommutative
+    | TkWhere | TkAssume
+    // Operators
+    | TkPlus | TkMinus | TkStar | TkSlash | TkPercent
+    | TkEq | TkEqEq | TkNe | TkLt | TkLe | TkGt | TkGe
+    | TkAnd | TkOr | TkNot
+    | TkPipe | TkPipeGt | TkArrow | TkThinArrow
+    | TkDot | TkColon | TkColonColon | TkComma | TkSemi | TkAt
+    // Delimiters
+    | TkLParen | TkRParen | TkLBrace | TkRBrace
+    | TkLBracket | TkRBracket
+    // Special
+    | TkUnderscore | TkNewline | TkEof
+    // Doc comment
+    | TkDocComment(String)
+
+type Token =
+    | Token(TokenKind, Int, Int)  // kind, start, end
+
+type LexState =
+    | LexState(List<Char>, Int)  // chars, position
+
+type LexResult =
+    | LexOk(Token, LexState)
+    | LexErr(String, Int)
+
+// === Character utilities ===
+
+fn peek(state: LexState): Option<Char> =
+    match state {
+        LexState(chars, pos) => List.get(chars, pos)
+    }
+
+fn peekAt(state: LexState, offset: Int): Option<Char> =
+    match state {
+        LexState(chars, pos) => List.get(chars, pos + offset)
+    }
+
+fn advance(state: LexState): LexState =
+    match state {
+        LexState(chars, pos) => LexState(chars, pos + 1)
+    }
+
+fn position(state: LexState): Int =
+    match state { LexState(_, pos) => pos }
+
+fn isDigit(c: Char): Bool =
+    c == '0' || c == '1' || c == '2' || c == '3' || c == '4' ||
+    c == '5' || c == '6' || c == '7' || c == '8' || c == '9'
+
+fn isAlpha(c: Char): Bool =
+    (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_'
+
+fn isAlphaNumeric(c: Char): Bool =
+    isAlpha(c) || isDigit(c)
+
+fn isWhitespace(c: Char): Bool =
+    c == ' ' || c == '\t' || c == '\r'
+
+// === Core lexing ===
+
+fn skipLineComment(state: LexState): LexState =
+    match peek(state) {
+        None => state,
+        Some(c) =>
+            if c == '\n' then state
+            else skipLineComment(advance(state))
+    }
+
+fn skipWhitespaceAndComments(state: LexState): LexState =
+    match peek(state) {
+        None => state,
+        Some(c) =>
+            if isWhitespace(c) then
+                skipWhitespaceAndComments(advance(state))
+            else if c == '/' then
+                match peekAt(state, 1) {
+                    Some('/') =>
+                        // Check for doc comment (///)
+                        match peekAt(state, 2) {
+                            Some('/') => state,  // Don't skip doc comments
+                            _ => skipWhitespaceAndComments(skipLineComment(advance(advance(state))))
+                        },
+                    _ => state
+                }
+            else state
+    }
+
+// Collect identifier characters
+fn collectIdent(state: LexState, acc: List<Char>): (List<Char>, LexState) =
+    match peek(state) {
+        None => (acc, state),
+        Some(c) =>
+            if isAlphaNumeric(c) then
+                collectIdent(advance(state), List.concat(acc, [c]))
+            else (acc, state)
+    }
+
+// Collect number characters (digits only)
+fn collectDigits(state: LexState, acc: List<Char>): (List<Char>, LexState) =
+    match peek(state) {
+        None => (acc, state),
+        Some(c) =>
+            if isDigit(c) then
+                collectDigits(advance(state), List.concat(acc, [c]))
+            else (acc, state)
+    }
+
+// Convert list of digit chars to int
+fn charsToInt(chars: List<Char>): Int =
+    List.fold(chars, 0, fn(acc, c) => acc * 10 + charToDigit(c))
+
+fn charToDigit(c: Char): Int =
+    if c == '0' then 0
+    else if c == '1' then 1
+    else if c == '2' then 2
+    else if c == '3' then 3
+    else if c == '4' then 4
+    else if c == '5' then 5
+    else if c == '6' then 6
+    else if c == '7' then 7
+    else if c == '8' then 8
+    else 9
+
+// Map identifier string to keyword token or ident
+fn identToToken(name: String): TokenKind =
+    if name == "fn" then TkFn
+    else if name == "let" then TkLet
+    else if name == "if" then TkIf
+    else if name == "then" then TkThen
+    else if name == "else" then TkElse
+    else if name == "match" then TkMatch
+    else if name == "with" then TkWith
+    else if name == "effect" then TkEffect
+    else if name == "handler" then TkHandler
+    else if name == "run" then TkRun
+    else if name == "resume" then TkResume
+    else if name == "type" then TkType
+    else if name == "true" then TkBool(true)
+    else if name == "false" then TkBool(false)
+    else if name == "import" then TkImport
+    else if name == "pub" then TkPub
+    else if name == "as" then TkAs
+    else if name == "from" then TkFrom
+    else if name == "trait" then TkTrait
+    else if name == "impl" then TkImpl
+    else if name == "for" then TkFor
+    else if name == "is" then TkIs
+    else if name == "pure" then TkPure
+    else if name == "total" then TkTotal
+    else if name == "idempotent" then TkIdempotent
+    else if name == "deterministic" then TkDeterministic
+    else if name == "commutative" then TkCommutative
+    else if name == "where" then TkWhere
+    else if name == "assume" then TkAssume
+    else TkIdent(name)
+
+// Lex a string literal (after opening quote consumed)
+fn lexStringBody(state: LexState, acc: List<Char>): (List<Char>, LexState) =
+    match peek(state) {
+        None => (acc, state),
+        Some(c) =>
+            if c == '"' then (acc, advance(state))
+            else if c == '\\' then
+                match peekAt(state, 1) {
+                    Some('n') => lexStringBody(advance(advance(state)), List.concat(acc, ['\n'])),
+                    Some('t') => lexStringBody(advance(advance(state)), List.concat(acc, ['\t'])),
+                    Some('\\') => lexStringBody(advance(advance(state)), List.concat(acc, ['\\'])),
+                    Some('"') => lexStringBody(advance(advance(state)), List.concat(acc, ['"'])),
+                    _ => lexStringBody(advance(state), List.concat(acc, [c]))
+                }
+            else lexStringBody(advance(state), List.concat(acc, [c]))
+    }
+
+// Lex a char literal (after opening quote consumed)
+fn lexCharLiteral(state: LexState): LexResult =
+    let start = position(state) - 1;
+    match peek(state) {
+        None => LexErr("Unexpected end of input in char literal", start),
+        Some(c) =>
+            if c == '\\' then
+                match peekAt(state, 1) {
+                    Some('n') =>
+                        match peekAt(state, 2) {
+                            Some('\'') => LexOk(Token(TkChar('\n'), start, position(state) + 3), advance(advance(advance(state)))),
+                            _ => LexErr("Expected closing quote", position(state))
+                        },
+                    Some('t') =>
+                        match peekAt(state, 2) {
+                            Some('\'') => LexOk(Token(TkChar('\t'), start, position(state) + 3), advance(advance(advance(state)))),
+                            _ => LexErr("Expected closing quote", position(state))
+                        },
+                    Some('\\') =>
+                        match peekAt(state, 2) {
+                            Some('\'') => LexOk(Token(TkChar('\\'), start, position(state) + 3), advance(advance(advance(state)))),
+                            _ => LexErr("Expected closing quote", position(state))
+                        },
+                    _ => LexErr("Unknown escape sequence", position(state))
+                }
+            else
+                match peekAt(state, 1) {
+                    Some('\'') => LexOk(Token(TkChar(c), start, position(state) + 2), advance(advance(state))),
+                    _ => LexErr("Expected closing quote", position(state))
+                }
+    }
+
+// Collect doc comment text (after /// consumed)
+fn collectDocComment(state: LexState, acc: List<Char>): (List<Char>, LexState) =
+    match peek(state) {
+        None => (acc, state),
+        Some(c) =>
+            if c == '\n' then (acc, state)
+            else collectDocComment(advance(state), List.concat(acc, [c]))
+    }
+
+// Lex a single token
+fn lexToken(state: LexState): LexResult =
+    let state = skipWhitespaceAndComments(state);
+    let start = position(state);
+    match peek(state) {
+        None => LexOk(Token(TkEof, start, start), state),
+        Some(c) =>
+            if c == '\n' then
+                LexOk(Token(TkNewline, start, start + 1), advance(state))
+            // Numbers
+            else if isDigit(c) then
+                let result = collectDigits(state, []);
+                match result {
+                    (digits, nextState) =>
+                        // Check for float
+                        match peek(nextState) {
+                            Some('.') =>
+                                match peekAt(nextState, 1) {
+                                    Some(d) =>
+                                        if isDigit(d) then
+                                            let fracResult = collectDigits(advance(nextState), []);
+                                            match fracResult {
+                                                (fracDigits, finalState) =>
+                                                    let intPart = String.join(List.map(digits, fn(ch) => String.fromChar(ch)), "");
+                                                    let fracPart = String.join(List.map(fracDigits, fn(ch) => String.fromChar(ch)), "");
+                                                    LexOk(Token(TkFloat(intPart + "." + fracPart), start, position(finalState)), finalState)
+                                            }
+                                        else
+                                            LexOk(Token(TkInt(charsToInt(digits)), start, position(nextState)), nextState),
+                                    None =>
+                                        LexOk(Token(TkInt(charsToInt(digits)), start, position(nextState)), nextState)
+                                },
+                            _ => LexOk(Token(TkInt(charsToInt(digits)), start, position(nextState)), nextState)
+                        }
+                }
+            // Identifiers and keywords
+            else if isAlpha(c) then
+                let result = collectIdent(state, []);
+                match result {
+                    (chars, nextState) =>
+                        let name = String.join(List.map(chars, fn(ch) => String.fromChar(ch)), "");
+                        LexOk(Token(identToToken(name), start, position(nextState)), nextState)
+                }
+            // String literals
+            else if c == '"' then
+                let result = lexStringBody(advance(state), []);
+                match result {
+                    (chars, nextState) =>
+                        let str = String.join(List.map(chars, fn(ch) => String.fromChar(ch)), "");
+                        LexOk(Token(TkString(str), start, position(nextState)), nextState)
+                }
+            // Char literals
+            else if c == '\'' then
+                lexCharLiteral(advance(state))
+            // Doc comments (///)
+            else if c == '/' then
+                match peekAt(state, 1) {
+                    Some('/') =>
+                        match peekAt(state, 2) {
+                            Some('/') =>
+                                // Skip the "/// " prefix
+                                let docState = advance(advance(advance(state)));
+                                let docState = match peek(docState) {
+                                    Some(' ') => advance(docState),
+                                    _ => docState
+                                };
+                                let result = collectDocComment(docState, []);
+                                match result {
+                                    (chars, nextState) =>
+                                        let text = String.join(List.map(chars, fn(ch) => String.fromChar(ch)), "");
+                                        LexOk(Token(TkDocComment(text), start, position(nextState)), nextState)
+                                },
+                            _ => LexOk(Token(TkSlash, start, start + 1), advance(state))
+                        },
+                    _ => LexOk(Token(TkSlash, start, start + 1), advance(state))
+                }
+            // Two-character operators
+            else if c == '=' then
+                match peekAt(state, 1) {
+                    Some('=') => LexOk(Token(TkEqEq, start, start + 2), advance(advance(state))),
+                    Some('>') => LexOk(Token(TkArrow, start, start + 2), advance(advance(state))),
+                    _ => LexOk(Token(TkEq, start, start + 1), advance(state))
+                }
+            else if c == '!' then
+                match peekAt(state, 1) {
+                    Some('=') => LexOk(Token(TkNe, start, start + 2), advance(advance(state))),
+                    _ => LexOk(Token(TkNot, start, start + 1), advance(state))
+                }
+            else if c == '<' then
+                match peekAt(state, 1) {
+                    Some('=') => LexOk(Token(TkLe, start, start + 2), advance(advance(state))),
+                    _ => LexOk(Token(TkLt, start, start + 1), advance(state))
+                }
+            else if c == '>' then
+                match peekAt(state, 1) {
+                    Some('=') => LexOk(Token(TkGe, start, start + 2), advance(advance(state))),
+                    _ => LexOk(Token(TkGt, start, start + 1), advance(state))
+                }
+            else if c == '&' then
+                match peekAt(state, 1) {
+                    Some('&') => LexOk(Token(TkAnd, start, start + 2), advance(advance(state))),
+                    _ => LexErr("Expected '&&'", start)
+                }
+            else if c == '|' then
+                match peekAt(state, 1) {
+                    Some('|') => LexOk(Token(TkOr, start, start + 2), advance(advance(state))),
+                    Some('>') => LexOk(Token(TkPipeGt, start, start + 2), advance(advance(state))),
+                    _ => LexOk(Token(TkPipe, start, start + 1), advance(state))
+                }
+            else if c == '-' then
+                match peekAt(state, 1) {
+                    Some('>') => LexOk(Token(TkThinArrow, start, start + 2), advance(advance(state))),
+                    _ => LexOk(Token(TkMinus, start, start + 1), advance(state))
+                }
+            else if c == ':' then
+                match peekAt(state, 1) {
+                    Some(':') => LexOk(Token(TkColonColon, start, start + 2), advance(advance(state))),
+                    _ => LexOk(Token(TkColon, start, start + 1), advance(state))
+                }
+            // Single-character tokens
+            else if c == '+' then LexOk(Token(TkPlus, start, start + 1), advance(state))
+            else if c == '*' then LexOk(Token(TkStar, start, start + 1), advance(state))
+            else if c == '%' then LexOk(Token(TkPercent, start, start + 1), advance(state))
+            else if c == '.' then LexOk(Token(TkDot, start, start + 1), advance(state))
+            else if c == ',' then LexOk(Token(TkComma, start, start + 1), advance(state))
+            else if c == ';' then LexOk(Token(TkSemi, start, start + 1), advance(state))
+            else if c == '@' then LexOk(Token(TkAt, start, start + 1), advance(state))
+            else if c == '(' then LexOk(Token(TkLParen, start, start + 1), advance(state))
+            else if c == ')' then LexOk(Token(TkRParen, start, start + 1), advance(state))
+            else if c == '{' then LexOk(Token(TkLBrace, start, start + 1), advance(state))
+            else if c == '}' then LexOk(Token(TkRBrace, start, start + 1), advance(state))
+            else if c == '[' then LexOk(Token(TkLBracket, start, start + 1), advance(state))
+            else if c == ']' then LexOk(Token(TkRBracket, start, start + 1), advance(state))
+            else if c == '_' then
+                // Check if it's just underscore or start of ident
+                match peekAt(state, 1) {
+                    Some(next) =>
+                        if isAlphaNumeric(next) then
+                            let result = collectIdent(state, []);
+                            match result {
+                                (chars, nextState) =>
+                                    let name = String.join(List.map(chars, fn(ch) => String.fromChar(ch)), "");
+                                    LexOk(Token(TkIdent(name), start, position(nextState)), nextState)
+                            }
+                        else LexOk(Token(TkUnderscore, start, start + 1), advance(state)),
+                    None => LexOk(Token(TkUnderscore, start, start + 1), advance(state))
+                }
+            else LexErr("Unexpected character: " + String.fromChar(c), start)
+    }
+
+// Lex all tokens from source
+fn lexAll(state: LexState, acc: List<Token>): List<Token> =
+    match lexToken(state) {
+        LexErr(msg, pos) =>
+            // On error, skip the character and continue
+            List.concat(acc, [Token(TkEof, pos, pos)]),
+        LexOk(token, nextState) =>
+            match token {
+                Token(TkEof, _, _) => List.concat(acc, [token]),
+                Token(TkNewline, _, _) =>
+                    // Skip consecutive newlines
+                    lexAll(nextState, List.concat(acc, [token])),
+                _ => lexAll(nextState, List.concat(acc, [token]))
+            }
+    }
+
+// Public API: tokenize a source string
+fn tokenize(source: String): List<Token> =
+    let chars = String.chars(source);
+    let state = LexState(chars, 0);
+    lexAll(state, [])
+
+// === Token display ===
+
+fn tokenKindToString(kind: TokenKind): String =
+    match kind {
+        TkInt(n) => "Int(" + toString(n) + ")",
+        TkFloat(s) => "Float(" + s + ")",
+        TkString(s) => "String(\"" + s + "\")",
+        TkChar(c) => "Char('" + String.fromChar(c) + "')",
+        TkBool(b) => if b then "true" else "false",
+        TkIdent(name) => "Ident(" + name + ")",
+        TkFn => "fn", TkLet => "let", TkIf => "if",
+        TkThen => "then", TkElse => "else", TkMatch => "match",
+        TkWith => "with", TkEffect => "effect", TkHandler => "handler",
+        TkRun => "run", TkResume => "resume", TkType => "type",
+        TkImport => "import", TkPub => "pub", TkAs => "as",
+        TkFrom => "from", TkTrait => "trait", TkImpl => "impl", TkFor => "for",
+        TkIs => "is", TkPure => "pure", TkTotal => "total",
+        TkIdempotent => "idempotent", TkDeterministic => "deterministic",
+        TkCommutative => "commutative", TkWhere => "where", TkAssume => "assume",
+        TkPlus => "+", TkMinus => "-", TkStar => "*", TkSlash => "/",
+        TkPercent => "%", TkEq => "=", TkEqEq => "==", TkNe => "!=",
+        TkLt => "<", TkLe => "<=", TkGt => ">", TkGe => ">=",
+        TkAnd => "&&", TkOr => "||", TkNot => "!",
+        TkPipe => "|", TkPipeGt => "|>",
+        TkArrow => "=>", TkThinArrow => "->",
+        TkDot => ".", TkColon => ":", TkColonColon => "::",
+        TkComma => ",", TkSemi => ";", TkAt => "@",
+        TkLParen => "(", TkRParen => ")", TkLBrace => "{", TkRBrace => "}",
+        TkLBracket => "[", TkRBracket => "]",
+        TkUnderscore => "_", TkNewline => "\\n", TkEof => "EOF",
+        TkDocComment(text) => "DocComment(\"" + text + "\")",
+        _ => "?"
+    }
+
+fn tokenToString(token: Token): String =
+    match token {
+        Token(kind, start, end) =>
+            tokenKindToString(kind) + " [" + toString(start) + ".." + toString(end) + "]"
+    }
+
+// === Tests ===
+
+fn printTokens(tokens: List<Token>): Unit with {Console} =
+    match List.head(tokens) {
+        None => Console.print(""),
+        Some(t) => {
+            Console.print("  " + tokenToString(t));
+            match List.tail(tokens) {
+                Some(rest) => printTokens(rest),
+                None => Console.print("")
+            }
+        }
+    }
+
+fn testLexer(label: String, source: String): Unit with {Console} = {
+    Console.print("--- " + label + " ---");
+    Console.print("  Input: \"" + source + "\"");
+    let tokens = tokenize(source);
+    printTokens(tokens)
+}
+
+fn main(): Unit with {Console} = {
+    Console.print("=== Lux Self-Hosted Lexer ===");
+    Console.print("");
+
+    // Basic tokens
+    testLexer("numbers", "42 3");
+    Console.print("");
+
+    // Identifiers and keywords
+    testLexer("keywords", "fn main let x");
+    Console.print("");
+
+    // Operators
+    testLexer("operators", "a + b == c");
+    Console.print("");
+
+    // String literal
+    testLexer("string", "\"hello world\"");
+    Console.print("");
+
+    // Function declaration
+    testLexer("function", "fn add(a: Int, b: Int): Int = a + b");
+    Console.print("");
+
+    // Behavioral properties
+    testLexer("behavioral", "fn add(a: Int): Int is pure = a");
+    Console.print("");
+
+    // Complex expression
+    testLexer("complex", "let result = if x > 0 then x else 0 - x");
+    Console.print("");
+
+    Console.print("=== Lexer test complete ===")
+}
+
+let _ = run main() with {}
--- a/scripts/release.sh
+++ b/scripts/release.sh
@@ -0,0 +1,213 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Lux Release Script
+# Builds a static binary, generates changelog, and creates a Gitea release.
+#
+# Usage:
+#   ./scripts/release.sh              # auto-bump patch (0.2.0 → 0.2.1)
+#   ./scripts/release.sh patch        # same as above
+#   ./scripts/release.sh minor        # bump minor (0.2.0 → 0.3.0)
+#   ./scripts/release.sh major        # bump major (0.2.0 → 1.0.0)
+#   ./scripts/release.sh v1.2.3       # explicit version
+#
+# Environment:
+#   GITEA_TOKEN - API token for git.qrty.ink (prompted if not set)
+#   GITEA_URL   - Gitea instance URL (default: https://git.qrty.ink)
+
+# cd to repo root (directory containing this script's parent)
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+cd "$SCRIPT_DIR/.."
+
+GITEA_URL="${GITEA_URL:-https://git.qrty.ink}"
+REPO_OWNER="blu"
+REPO_NAME="lux"
+API_BASE="$GITEA_URL/api/v1"
+
+# Colors
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+CYAN='\033[0;36m'
+BOLD='\033[1m'
+NC='\033[0m'
+
+info()  { printf "${CYAN}::${NC} %s\n" "$1"; }
+ok()    { printf "${GREEN}ok${NC} %s\n" "$1"; }
+warn()  { printf "${YELLOW}!!${NC} %s\n" "$1"; }
+err()   { printf "${RED}error:${NC} %s\n" "$1" >&2; exit 1; }
+
+# --- Determine version ---
+CURRENT=$(grep '^version' Cargo.toml | head -1 | sed 's/.*"\(.*\)".*/\1/')
+BUMP="${1:-patch}"
+
+bump_version() {
+    local ver="$1" part="$2"
+    IFS='.' read -r major minor patch <<< "$ver"
+    case "$part" in
+        major) echo "$((major + 1)).0.0" ;;
+        minor) echo "$major.$((minor + 1)).0" ;;
+        patch) echo "$major.$minor.$((patch + 1))" ;;
+        *)     echo "$part" ;;  # treat as explicit version
+    esac
+}
+
+case "$BUMP" in
+    major|minor|patch)
+        VERSION=$(bump_version "$CURRENT" "$BUMP")
+        info "Bumping $BUMP: $CURRENT → $VERSION"
+        ;;
+    *)
+        # Explicit version — strip v prefix if present
+        VERSION="${BUMP#v}"
+        info "Explicit version: $VERSION"
+        ;;
+esac
+
+TAG="v$VERSION"
+
+# --- Check for clean working tree ---
+if [ -n "$(git status --porcelain)" ]; then
+    warn "Working tree has uncommitted changes:"
+    git status --short
+    printf "\n"
+    read -rp "Continue anyway? [y/N] " confirm
+    [[ "$confirm" =~ ^[Yy]$ ]] || exit 1
+fi
+
+# --- Check if tag already exists ---
+if git rev-parse "$TAG" >/dev/null 2>&1; then
+    err "Tag $TAG already exists. Choose a different version."
+fi
+
+# --- Update version in source files ---
+if [ "$VERSION" != "$CURRENT" ]; then
+    info "Updating version in Cargo.toml and flake.nix..."
+    sed -i "0,/^version = \"$CURRENT\"/s//version = \"$VERSION\"/" Cargo.toml
+    sed -i "s/version = \"$CURRENT\";/version = \"$VERSION\";/g" flake.nix
+    sed -i "s/v$CURRENT/v$VERSION/g" flake.nix
+    git add Cargo.toml flake.nix
+    git commit --no-gpg-sign -m "chore: bump version to $VERSION"
+    ok "Version updated and committed"
+fi
+
+# --- Generate changelog ---
+info "Generating changelog..."
+LAST_TAG=$(git describe --tags --abbrev=0 2>/dev/null || echo "")
+if [ -n "$LAST_TAG" ]; then
+    RANGE="$LAST_TAG..HEAD"
+    info "Changes since $LAST_TAG:"
+else
+    RANGE="HEAD"
+    info "First release — summarizing recent commits:"
+fi
+
+CHANGELOG=$(git log "$RANGE" --pretty=format:"- %s" --no-merges 2>/dev/null | head -50 || true)
+if [ -z "$CHANGELOG" ]; then
+    CHANGELOG="- Initial release"
+fi
+
+# --- Build static binary ---
+info "Building static binary (nix build .#static)..."
+nix build .#static
+BINARY="result/bin/lux"
+if [ ! -f "$BINARY" ]; then
+    err "Static binary not found at $BINARY"
+fi
+
+BINARY_SIZE=$(ls -lh "$BINARY" | awk '{print $5}')
+BINARY_TYPE=$(file "$BINARY" | sed 's/.*: //')
+ok "Binary: $BINARY_SIZE, $BINARY_TYPE"
+
+# --- Prepare release artifact ---
+ARTIFACT="/tmp/lux-${TAG}-linux-x86_64"
+cp "$BINARY" "$ARTIFACT"
+chmod +x "$ARTIFACT"
+
+# --- Show release summary ---
+printf "\n"
+printf "${BOLD}═══ Release Summary ═══${NC}\n"
+printf "\n"
+printf "  ${BOLD}Tag:${NC}      %s\n" "$TAG"
+printf "  ${BOLD}Binary:${NC}   %s (%s)\n" "lux-${TAG}-linux-x86_64" "$BINARY_SIZE"
+printf "  ${BOLD}Commit:${NC}   %s\n" "$(git rev-parse --short HEAD)"
+printf "\n"
+printf "${BOLD}Changelog:${NC}\n"
+printf "%s\n" "$CHANGELOG"
+printf "\n"
+
+# --- Confirm ---
+read -rp "Create release $TAG? [y/N] " confirm
+[[ "$confirm" =~ ^[Yy]$ ]] || { info "Aborted."; exit 0; }
+
+# --- Get Gitea token ---
+if [ -z "${GITEA_TOKEN:-}" ]; then
+    printf "\n"
+    info "Gitea API token required (create at $GITEA_URL/user/settings/applications)"
+    read -rsp "Token: " GITEA_TOKEN
+    printf "\n"
+fi
+
+if [ -z "$GITEA_TOKEN" ]; then
+    err "No token provided"
+fi
+
+# --- Create and push tag ---
+info "Creating tag $TAG..."
+git tag -a "$TAG" -m "Release $TAG" --no-sign
+ok "Tag created"
+
+info "Pushing tag to origin..."
+git push origin "$TAG"
+ok "Tag pushed"
+
+# --- Create Gitea release ---
+info "Creating release on Gitea..."
+
+RELEASE_BODY=$(printf "## Lux %s\n\n### Changes\n\n%s\n\n### Installation\n\n\`\`\`bash\ncurl -Lo lux %s/%s/%s/releases/download/%s/lux-linux-x86_64\nchmod +x lux\n./lux --version\n\`\`\`" \
+    "$TAG" "$CHANGELOG" "$GITEA_URL" "$REPO_OWNER" "$REPO_NAME" "$TAG")
+
+RELEASE_JSON=$(jq -n \
+    --arg tag "$TAG" \
+    --arg name "Lux $TAG" \
+    --arg body "$RELEASE_BODY" \
+    '{tag_name: $tag, name: $name, body: $body, draft: false, prerelease: false}')
+
+RELEASE_RESPONSE=$(curl -s -X POST \
+    "$API_BASE/repos/$REPO_OWNER/$REPO_NAME/releases" \
+    -H "Authorization: token $GITEA_TOKEN" \
+    -H "Content-Type: application/json" \
+    -d "$RELEASE_JSON")
+
+RELEASE_ID=$(echo "$RELEASE_RESPONSE" | jq -r '.id // empty')
+if [ -z "$RELEASE_ID" ]; then
+    echo "$RELEASE_RESPONSE" | jq . 2>/dev/null || echo "$RELEASE_RESPONSE"
+    err "Failed to create release"
+fi
+ok "Release created (id: $RELEASE_ID)"
+
+# --- Upload binary ---
+info "Uploading binary..."
+UPLOAD_RESPONSE=$(curl -s -X POST \
+    "$API_BASE/repos/$REPO_OWNER/$REPO_NAME/releases/$RELEASE_ID/assets?name=lux-linux-x86_64" \
+    -H "Authorization: token $GITEA_TOKEN" \
+    -H "Content-Type: application/octet-stream" \
+    --data-binary "@$ARTIFACT")
+
+ASSET_NAME=$(echo "$UPLOAD_RESPONSE" | jq -r '.name // empty')
+if [ -z "$ASSET_NAME" ]; then
+    echo "$UPLOAD_RESPONSE" | jq . 2>/dev/null || echo "$UPLOAD_RESPONSE"
+    err "Failed to upload binary"
+fi
+ok "Binary uploaded: $ASSET_NAME"
+
+# --- Done ---
+printf "\n"
+printf "${GREEN}${BOLD}Release $TAG published!${NC}\n"
+printf "\n"
+printf "  ${BOLD}URL:${NC} %s/%s/%s/releases/tag/%s\n" "$GITEA_URL" "$REPO_OWNER" "$REPO_NAME" "$TAG"
+printf "  ${BOLD}Download:${NC} %s/%s/%s/releases/download/%s/lux-linux-x86_64\n" "$GITEA_URL" "$REPO_OWNER" "$REPO_NAME" "$TAG"
+printf "\n"
+
+# Cleanup
+rm -f "$ARTIFACT"
--- a/scripts/validate.sh
+++ b/scripts/validate.sh
@@ -0,0 +1,211 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Lux Full Validation Script
+# Runs all checks: Rust tests, package tests, type checking, example compilation.
+# Run after every committable change to ensure no regressions.
+
+# cd to repo root (directory containing this script's parent)
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+cd "$SCRIPT_DIR/.."
+
+LUX="$(pwd)/target/release/lux"
+PACKAGES_DIR="$(pwd)/../packages"
+PROJECTS_DIR="$(pwd)/projects"
+EXAMPLES_DIR="$(pwd)/examples"
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+CYAN='\033[0;36m'
+BOLD='\033[1m'
+NC='\033[0m'
+
+FAILED=0
+TOTAL=0
+
+step() {
+    TOTAL=$((TOTAL + 1))
+    printf "${CYAN}[%d]${NC} %s... " "$TOTAL" "$1"
+}
+
+ok() { printf "${GREEN}ok${NC} %s\n" "${1:-}"; }
+fail() { printf "${RED}FAIL${NC} %s\n" "${1:-}"; FAILED=$((FAILED + 1)); }
+
+# --- Rust checks ---
+step "cargo check"
+if nix develop --command cargo check 2>/dev/null; then ok; else fail; fi
+
+step "cargo test"
+OUTPUT=$(nix develop --command cargo test 2>&1 || true)
+RESULT=$(echo "$OUTPUT" | grep "test result:" || echo "no result")
+if echo "$RESULT" | grep -q "0 failed"; then ok "$RESULT"; else fail "$RESULT"; fi
+
+# --- Build release binary ---
+step "cargo build --release"
+if nix develop --command cargo build --release 2>/dev/null; then ok; else fail; fi
+
+# --- Package tests ---
+for pkg in path frontmatter xml rss markdown; do
+    PKG_DIR="$PACKAGES_DIR/$pkg"
+    if [ -d "$PKG_DIR" ]; then
+        step "lux test ($pkg)"
+        OUTPUT=$(cd "$PKG_DIR" && "$LUX" test 2>&1 || true)
+        RESULT=$(echo "$OUTPUT" | grep "passed" | tail -1 || echo "no result")
+        if echo "$RESULT" | grep -q "passed"; then ok "$RESULT"; else fail "$RESULT"; fi
+    fi
+done
+
+# --- Lux check on packages ---
+for pkg in path frontmatter xml rss markdown; do
+    PKG_DIR="$PACKAGES_DIR/$pkg"
+    if [ -d "$PKG_DIR" ]; then
+        step "lux check ($pkg)"
+        OUTPUT=$(cd "$PKG_DIR" && "$LUX" check 2>&1 || true)
+        RESULT=$(echo "$OUTPUT" | grep "passed" | tail -1 || echo "no result")
+        if echo "$RESULT" | grep -q "passed"; then ok; else fail "$RESULT"; fi
+    fi
+done
+
+# --- Project checks ---
+for proj_dir in "$PROJECTS_DIR"/*/; do
+    proj=$(basename "$proj_dir")
+    if [ -f "$proj_dir/main.lux" ]; then
+        step "lux check (project: $proj)"
+        OUTPUT=$("$LUX" check "$proj_dir/main.lux" 2>&1 || true)
+        if echo "$OUTPUT" | grep -qi "error"; then fail; else ok; fi
+    fi
+    # Check any standalone .lux files in the project
+    for lux_file in "$proj_dir"/*.lux; do
+        [ -f "$lux_file" ] || continue
+        fname=$(basename "$lux_file")
+        [ "$fname" = "main.lux" ] && continue
+        step "lux check (project: $proj/$fname)"
+        OUTPUT=$("$LUX" check "$lux_file" 2>&1 || true)
+        if echo "$OUTPUT" | grep -qi "error"; then fail; else ok; fi
+    done
+done
+
+# === Compilation & Interpreter Checks ===
+
+# --- Interpreter: examples ---
+# Skip: http_api, http, http_router, http_server (network), postgres_demo (db),
+#        random, property_testing (Random effect), shell (Process), json (File I/O),
+#        file_io (File I/O), test_math, test_lists (Test effect), stress_shared_rc,
+#        test_rc_comparison (internal tests), modules/* (need cwd)
+INTERP_SKIP="http_api http http_router http_server postgres_demo random property_testing shell json file_io test_math test_lists stress_shared_rc test_rc_comparison"
+for f in "$EXAMPLES_DIR"/*.lux; do
+    name=$(basename "$f" .lux)
+    skip=false
+    for s in $INTERP_SKIP; do [ "$name" = "$s" ] && skip=true; done
+    $skip && continue
+    step "interpreter (examples/$name)"
+    if timeout 10 "$LUX" "$f" >/dev/null 2>&1; then ok; else fail; fi
+done
+
+# --- Interpreter: examples/standard ---
+# Skip: guessing_game (reads stdin)
+for f in "$EXAMPLES_DIR"/standard/*.lux; do
+    [ -f "$f" ] || continue
+    name=$(basename "$f" .lux)
+    [ "$name" = "guessing_game" ] && continue
+    step "interpreter (standard/$name)"
+    if timeout 10 "$LUX" "$f" >/dev/null 2>&1; then ok; else fail; fi
+done
+
+# --- Interpreter: examples/showcase ---
+# Skip: task_manager (parse error in current version)
+for f in "$EXAMPLES_DIR"/showcase/*.lux; do
+    [ -f "$f" ] || continue
+    name=$(basename "$f" .lux)
+    [ "$name" = "task_manager" ] && continue
+    step "interpreter (showcase/$name)"
+    if timeout 10 "$LUX" "$f" >/dev/null 2>&1; then ok; else fail; fi
+done
+
+# --- Interpreter: projects ---
+# Skip: guessing-game (Random), rest-api (HttpServer)
+PROJ_INTERP_SKIP="guessing-game rest-api"
+for proj_dir in "$PROJECTS_DIR"/*/; do
+    proj=$(basename "$proj_dir")
+    [ -f "$proj_dir/main.lux" ] || continue
+    skip=false
+    for s in $PROJ_INTERP_SKIP; do [ "$proj" = "$s" ] && skip=true; done
+    $skip && continue
+    step "interpreter (project: $proj)"
+    if timeout 10 "$LUX" "$proj_dir/main.lux" >/dev/null 2>&1; then ok; else fail; fi
+done
+
+# --- JS compilation: examples ---
+# Skip files that fail JS compilation (unsupported features)
+JS_SKIP="http_api http http_router postgres_demo property_testing json test_lists test_rc_comparison"
+for f in "$EXAMPLES_DIR"/*.lux; do
+    name=$(basename "$f" .lux)
+    skip=false
+    for s in $JS_SKIP; do [ "$name" = "$s" ] && skip=true; done
+    $skip && continue
+    step "compile JS (examples/$name)"
+    if "$LUX" compile "$f" --target js -o /tmp/lux_validate.js >/dev/null 2>&1; then ok; else fail; fi
+done
+
+# --- JS compilation: examples/standard ---
+# Skip: stdlib_demo (uses String.toUpper not in JS backend)
+for f in "$EXAMPLES_DIR"/standard/*.lux; do
+    [ -f "$f" ] || continue
+    name=$(basename "$f" .lux)
+    [ "$name" = "stdlib_demo" ] && continue
+    step "compile JS (standard/$name)"
+    if "$LUX" compile "$f" --target js -o /tmp/lux_validate.js >/dev/null 2>&1; then ok; else fail; fi
+done
+
+# --- JS compilation: examples/showcase ---
+# Skip: task_manager (unsupported features)
+for f in "$EXAMPLES_DIR"/showcase/*.lux; do
+    [ -f "$f" ] || continue
+    name=$(basename "$f" .lux)
+    [ "$name" = "task_manager" ] && continue
+    step "compile JS (showcase/$name)"
+    if "$LUX" compile "$f" --target js -o /tmp/lux_validate.js >/dev/null 2>&1; then ok; else fail; fi
+done
+
+# --- JS compilation: projects ---
+# Skip: json-parser, rest-api (unsupported features)
+JS_PROJ_SKIP="json-parser rest-api"
+for proj_dir in "$PROJECTS_DIR"/*/; do
+    proj=$(basename "$proj_dir")
+    [ -f "$proj_dir/main.lux" ] || continue
+    skip=false
+    for s in $JS_PROJ_SKIP; do [ "$proj" = "$s" ] && skip=true; done
+    $skip && continue
+    step "compile JS (project: $proj)"
+    if "$LUX" compile "$proj_dir/main.lux" --target js -o /tmp/lux_validate.js >/dev/null 2>&1; then ok; else fail; fi
+done
+
+# --- C compilation: examples ---
+# Only compile examples known to work with C backend
+C_EXAMPLES="hello factorial pipelines tailcall jit_test"
+for name in $C_EXAMPLES; do
+    f="$EXAMPLES_DIR/$name.lux"
+    [ -f "$f" ] || continue
+    step "compile C (examples/$name)"
+    if "$LUX" compile "$f" -o /tmp/lux_validate_bin >/dev/null 2>&1; then ok; else fail; fi
+done
+
+# --- C compilation: examples/standard ---
+C_STD_EXAMPLES="hello_world factorial fizzbuzz primes guessing_game"
+for name in $C_STD_EXAMPLES; do
+    f="$EXAMPLES_DIR/standard/$name.lux"
+    [ -f "$f" ] || continue
+    step "compile C (standard/$name)"
+    if "$LUX" compile "$f" -o /tmp/lux_validate_bin >/dev/null 2>&1; then ok; else fail; fi
+done
+
+# --- Cleanup ---
+rm -f /tmp/lux_validate.js /tmp/lux_validate_bin
+
+# --- Summary ---
+printf "\n${BOLD}═══ Validation Summary ═══${NC}\n"
+if [ $FAILED -eq 0 ]; then
+    printf "${GREEN}All %d checks passed.${NC}\n" "$TOTAL"
+else
+    printf "${RED}%d/%d checks failed.${NC}\n" "$FAILED" "$TOTAL"
+    exit 1
+fi
--- a/src/ast.rs
+++ b/src/ast.rs
@@ -221,6 +221,10 @@ pub enum Declaration {
    Trait(TraitDecl),
    /// Trait implementation: impl Trait for Type { ... }
    Impl(ImplDecl),
+    /// Extern function declaration (FFI): extern fn name(params): ReturnType
+    ExternFn(ExternFnDecl),
+    /// Extern let declaration (FFI): extern let name: Type
+    ExternLet(ExternLetDecl),
 }

 /// Function declaration
@@ -428,6 +432,34 @@ pub struct ImplMethod {
    pub span: Span,
 }

+/// Extern function declaration (FFI)
+#[derive(Debug, Clone)]
+pub struct ExternFnDecl {
+    pub visibility: Visibility,
+    /// Documentation comment
+    pub doc: Option<String>,
+    pub name: Ident,
+    pub type_params: Vec<Ident>,
+    pub params: Vec<Parameter>,
+    pub return_type: TypeExpr,
+    /// Optional JS name override: extern fn foo(...): T = "jsFoo"
+    pub js_name: Option<String>,
+    pub span: Span,
+}
+
+/// Extern let declaration (FFI)
+#[derive(Debug, Clone)]
+pub struct ExternLetDecl {
+    pub visibility: Visibility,
+    /// Documentation comment
+    pub doc: Option<String>,
+    pub name: Ident,
+    pub typ: TypeExpr,
+    /// Optional JS name override: extern let foo: T = "window.foo"
+    pub js_name: Option<String>,
+    pub span: Span,
+}
+
 /// Type expressions
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum TypeExpr {
@@ -499,6 +531,12 @@ pub enum Expr {
        field: Ident,
        span: Span,
    },
+    /// Tuple index access: tuple.0, tuple.1
+    TupleIndex {
+        object: Box<Expr>,
+        index: usize,
+        span: Span,
+    },
    /// Lambda: fn(x, y) => x + y  or  fn(x: Int): Int => x + 1
    Lambda {
        params: Vec<Parameter>,
@@ -535,7 +573,9 @@ pub enum Expr {
        span: Span,
    },
    /// Record literal: { name: "Alice", age: 30 }
+    /// With optional spread: { ...base, name: "Bob" }
    Record {
+        spread: Option<Box<Expr>>,
        fields: Vec<(Ident, Expr)>,
        span: Span,
    },
@@ -563,6 +603,7 @@ impl Expr {
            Expr::Call { span, .. } => *span,
            Expr::EffectOp { span, .. } => *span,
            Expr::Field { span, .. } => *span,
+            Expr::TupleIndex { span, .. } => *span,
            Expr::Lambda { span, .. } => *span,
            Expr::Let { span, .. } => *span,
            Expr::If { span, .. } => *span,
@@ -615,6 +656,7 @@ pub enum BinaryOp {
    Or,
    // Other
    Pipe,   // |>
+    Concat, // ++
 }

 impl fmt::Display for BinaryOp {
@@ -634,6 +676,7 @@ impl fmt::Display for BinaryOp {
            BinaryOp::And => write!(f, "&&"),
            BinaryOp::Or => write!(f, "||"),
            BinaryOp::Pipe => write!(f, "|>"),
+            BinaryOp::Concat => write!(f, "++"),
        }
    }
 }
@@ -686,8 +729,9 @@ pub enum Pattern {
    Var(Ident),
    /// Literal: 42, "hello", true
    Literal(Literal),
-    /// Constructor: Some(x), None, Ok(v)
+    /// Constructor: Some(x), None, Ok(v), module.Constructor(x)
    Constructor {
+        module: Option<Ident>,
        name: Ident,
        fields: Vec<Pattern>,
        span: Span,
--- a/src/codegen/c_backend.rs
+++ b/src/codegen/c_backend.rs
--- a/src/codegen/js_backend.rs
+++ b/src/codegen/js_backend.rs
@@ -69,6 +69,12 @@ pub struct JsBackend {
    has_handlers: bool,
    /// Variable substitutions for let binding
    var_substitutions: HashMap<String, String>,
+    /// Effects actually used in the program (for tree-shaking runtime)
+    used_effects: HashSet<String>,
+    /// Extern function names mapped to their JS names
+    extern_fns: HashMap<String, String>,
+    /// Extern let names mapped to their JS names
+    extern_lets: HashMap<String, String>,
 }

 impl JsBackend {
@@ -90,6 +96,9 @@ impl JsBackend {
            effectful_functions: HashSet::new(),
            has_handlers: false,
            var_substitutions: HashMap::new(),
+            used_effects: HashSet::new(),
+            extern_fns: HashMap::new(),
+            extern_lets: HashMap::new(),
        }
    }

@@ -97,9 +106,6 @@ impl JsBackend {
    pub fn generate(&mut self, program: &Program) -> Result<String, JsGenError> {
        self.output.clear();

-        // Emit runtime helpers
-        self.emit_runtime();
-
        // First pass: collect all function names, types, and effects
        for decl in &program.declarations {
            match decl {
@@ -112,10 +118,31 @@ impl JsBackend {
                Declaration::Type(t) => {
                    self.collect_type(t)?;
                }
+                Declaration::ExternFn(ext) => {
+                    let js_name = ext
+                        .js_name
+                        .clone()
+                        .unwrap_or_else(|| ext.name.name.clone());
+                    self.extern_fns.insert(ext.name.name.clone(), js_name);
+                    self.functions.insert(ext.name.name.clone());
+                }
+                Declaration::ExternLet(ext) => {
+                    let js_name = ext
+                        .js_name
+                        .clone()
+                        .unwrap_or_else(|| ext.name.name.clone());
+                    self.extern_lets.insert(ext.name.name.clone(), js_name);
+                }
                _ => {}
            }
        }

+        // Collect used effects for tree-shaking
+        self.collect_used_effects(program);
+
+        // Emit runtime helpers (tree-shaken based on used effects)
+        self.emit_runtime();
+
        // Emit type constructors
        for decl in &program.declarations {
            if let Declaration::Type(t) = decl {
@@ -163,32 +190,181 @@ impl JsBackend {
        Ok(self.output.clone())
    }

-    /// Emit the minimal Lux runtime
+    /// Collect all effects used in the program for runtime tree-shaking
+    fn collect_used_effects(&mut self, program: &Program) {
+        for decl in &program.declarations {
+            match decl {
+                Declaration::Function(f) => {
+                    for effect in &f.effects {
+                        self.used_effects.insert(effect.name.clone());
+                    }
+                    self.collect_effects_from_expr(&f.body);
+                }
+                Declaration::Let(l) => {
+                    self.collect_effects_from_expr(&l.value);
+                }
+                Declaration::Handler(h) => {
+                    self.used_effects.insert(h.effect.name.clone());
+                    for imp in &h.implementations {
+                        self.collect_effects_from_expr(&imp.body);
+                    }
+                }
+                _ => {}
+            }
+        }
+    }
+
+    /// Recursively collect effect names from an expression
+    fn collect_effects_from_expr(&mut self, expr: &Expr) {
+        match expr {
+            Expr::EffectOp { effect, args, .. } => {
+                self.used_effects.insert(effect.name.clone());
+                for arg in args {
+                    self.collect_effects_from_expr(arg);
+                }
+            }
+            Expr::Run { expr, handlers, .. } => {
+                self.collect_effects_from_expr(expr);
+                for (effect, handler) in handlers {
+                    self.used_effects.insert(effect.name.clone());
+                    self.collect_effects_from_expr(handler);
+                }
+            }
+            Expr::Call { func, args, .. } => {
+                self.collect_effects_from_expr(func);
+                for arg in args {
+                    self.collect_effects_from_expr(arg);
+                }
+            }
+            Expr::Lambda { body, effects, .. } => {
+                for effect in effects {
+                    self.used_effects.insert(effect.name.clone());
+                }
+                self.collect_effects_from_expr(body);
+            }
+            Expr::Let { value, body, .. } => {
+                self.collect_effects_from_expr(value);
+                self.collect_effects_from_expr(body);
+            }
+            Expr::If { condition, then_branch, else_branch, .. } => {
+                self.collect_effects_from_expr(condition);
+                self.collect_effects_from_expr(then_branch);
+                self.collect_effects_from_expr(else_branch);
+            }
+            Expr::Match { scrutinee, arms, .. } => {
+                self.collect_effects_from_expr(scrutinee);
+                for arm in arms {
+                    self.collect_effects_from_expr(&arm.body);
+                    if let Some(guard) = &arm.guard {
+                        self.collect_effects_from_expr(guard);
+                    }
+                }
+            }
+            Expr::Block { statements, result, .. } => {
+                for stmt in statements {
+                    match stmt {
+                        Statement::Expr(e) => self.collect_effects_from_expr(e),
+                        Statement::Let { value, .. } => self.collect_effects_from_expr(value),
+                    }
+                }
+                self.collect_effects_from_expr(result);
+            }
+            Expr::BinaryOp { left, right, .. } => {
+                self.collect_effects_from_expr(left);
+                self.collect_effects_from_expr(right);
+            }
+            Expr::UnaryOp { operand, .. } => {
+                self.collect_effects_from_expr(operand);
+            }
+            Expr::Field { object, .. } => {
+                self.collect_effects_from_expr(object);
+            }
+            Expr::TupleIndex { object, .. } => {
+                self.collect_effects_from_expr(object);
+            }
+            Expr::Record { spread, fields, .. } => {
+                if let Some(s) = spread {
+                    self.collect_effects_from_expr(s);
+                }
+                for (_, expr) in fields {
+                    self.collect_effects_from_expr(expr);
+                }
+            }
+            Expr::Tuple { elements, .. } | Expr::List { elements, .. } => {
+                for el in elements {
+                    self.collect_effects_from_expr(el);
+                }
+            }
+            Expr::Resume { value, .. } => {
+                self.collect_effects_from_expr(value);
+            }
+            Expr::Literal(_) | Expr::Var(_) => {}
+        }
+    }
+
+    /// Emit the Lux runtime, tree-shaken based on used effects
    fn emit_runtime(&mut self) {
+        let uses_console = self.used_effects.contains("Console");
+        let uses_random = self.used_effects.contains("Random");
+        let uses_time = self.used_effects.contains("Time");
+        let uses_http = self.used_effects.contains("Http");
+        let uses_dom = self.used_effects.contains("Dom");
+        let uses_html = self.used_effects.contains("Html") || uses_dom;
+
        self.writeln("// Lux Runtime");
        self.writeln("const Lux = {");
        self.indent += 1;

-        // Option helpers
+        // Core helpers — always emitted
        self.writeln("Some: (value) => ({ tag: \"Some\", value }),");
        self.writeln("None: () => ({ tag: \"None\" }),");
        self.writeln("");
-
-        // Result helpers
        self.writeln("Ok: (value) => ({ tag: \"Ok\", value }),");
        self.writeln("Err: (error) => ({ tag: \"Err\", error }),");
        self.writeln("");
-
-        // List helpers
        self.writeln("Cons: (head, tail) => [head, ...tail],");
        self.writeln("Nil: () => [],");
        self.writeln("");

-        // Default handlers for effects
+        // Default handlers — only include effects that are used
        self.writeln("defaultHandlers: {");
        self.indent += 1;

-        // Console effect
+        if uses_console {
+            self.emit_console_handler();
+        }
+        if uses_random {
+            self.emit_random_handler();
+        }
+        if uses_time {
+            self.emit_time_handler();
+        }
+        if uses_http {
+            self.emit_http_handler();
+        }
+        if uses_dom {
+            self.emit_dom_handler();
+        }
+
+        self.indent -= 1;
+        self.writeln("},");
+
+        // HTML rendering — only if Html or Dom effects are used
+        if uses_html {
+            self.emit_html_helpers();
+        }
+
+        // TEA runtime — only if Dom is used
+        if uses_dom {
+            self.emit_tea_runtime();
+        }
+
+        self.indent -= 1;
+        self.writeln("};");
+        self.writeln("");
+    }
+
+    fn emit_console_handler(&mut self) {
        self.writeln("Console: {");
        self.indent += 1;
        self.writeln("print: (msg) => console.log(msg),");
@@ -207,8 +383,9 @@ impl JsBackend {
        self.writeln("readInt: () => parseInt(Lux.defaultHandlers.Console.readLine(), 10)");
        self.indent -= 1;
        self.writeln("},");
+    }

-        // Random effect
+    fn emit_random_handler(&mut self) {
        self.writeln("Random: {");
        self.indent += 1;
        self.writeln("int: (min, max) => Math.floor(Math.random() * (max - min + 1)) + min,");
@@ -216,16 +393,18 @@ impl JsBackend {
        self.writeln("float: () => Math.random()");
        self.indent -= 1;
        self.writeln("},");
+    }

-        // Time effect
+    fn emit_time_handler(&mut self) {
        self.writeln("Time: {");
        self.indent += 1;
        self.writeln("now: () => Date.now(),");
        self.writeln("sleep: (ms) => new Promise(resolve => setTimeout(resolve, ms))");
        self.indent -= 1;
        self.writeln("},");
+    }

-        // Http effect (browser/Node compatible)
+    fn emit_http_handler(&mut self) {
        self.writeln("Http: {");
        self.indent += 1;
        self.writeln("get: async (url) => {");
@@ -287,8 +466,9 @@ impl JsBackend {
        self.writeln("}");
        self.indent -= 1;
        self.writeln("},");
+    }

-        // Dom effect (browser only - stubs for Node.js)
+    fn emit_dom_handler(&mut self) {
        self.writeln("Dom: {");
        self.indent += 1;

@@ -316,7 +496,6 @@ impl JsBackend {
        self.indent -= 1;
        self.writeln("},");

-        // Element creation
        self.writeln("createElement: (tag) => {");
        self.indent += 1;
        self.writeln("if (typeof document === 'undefined') return null;");
@@ -331,7 +510,6 @@ impl JsBackend {
        self.indent -= 1;
        self.writeln("},");

-        // DOM manipulation
        self.writeln("appendChild: (parent, child) => {");
        self.indent += 1;
        self.writeln("if (parent && child) parent.appendChild(child);");
@@ -356,7 +534,6 @@ impl JsBackend {
        self.indent -= 1;
        self.writeln("},");

-        // Content
        self.writeln("setTextContent: (el, text) => {");
        self.indent += 1;
        self.writeln("if (el) el.textContent = text;");
@@ -381,7 +558,6 @@ impl JsBackend {
        self.indent -= 1;
        self.writeln("},");

-        // Attributes
        self.writeln("setAttribute: (el, name, value) => {");
        self.indent += 1;
        self.writeln("if (el) el.setAttribute(name, value);");
@@ -408,7 +584,6 @@ impl JsBackend {
        self.indent -= 1;
        self.writeln("},");

-        // Classes
        self.writeln("addClass: (el, className) => {");
        self.indent += 1;
        self.writeln("if (el) el.classList.add(className);");
@@ -433,7 +608,6 @@ impl JsBackend {
        self.indent -= 1;
        self.writeln("},");

-        // Styles
        self.writeln("setStyle: (el, property, value) => {");
        self.indent += 1;
        self.writeln("if (el) el.style[property] = value;");
@@ -446,7 +620,6 @@ impl JsBackend {
        self.indent -= 1;
        self.writeln("},");

-        // Form elements
        self.writeln("getValue: (el) => {");
        self.indent += 1;
        self.writeln("return el ? el.value : '';");
@@ -471,7 +644,6 @@ impl JsBackend {
        self.indent -= 1;
        self.writeln("},");

-        // Events
        self.writeln("addEventListener: (el, event, handler) => {");
        self.indent += 1;
        self.writeln("if (el) el.addEventListener(event, handler);");
@@ -484,7 +656,6 @@ impl JsBackend {
        self.indent -= 1;
        self.writeln("},");

-        // Focus
        self.writeln("focus: (el) => {");
        self.indent += 1;
        self.writeln("if (el && el.focus) el.focus();");
@@ -497,7 +668,6 @@ impl JsBackend {
        self.indent -= 1;
        self.writeln("},");

-        // Document
        self.writeln("getBody: () => {");
        self.indent += 1;
        self.writeln("if (typeof document === 'undefined') return null;");
@@ -512,7 +682,6 @@ impl JsBackend {
        self.indent -= 1;
        self.writeln("},");

-        // Window
        self.writeln("getWindow: () => {");
        self.indent += 1;
        self.writeln("if (typeof window === 'undefined') return null;");
@@ -545,7 +714,6 @@ impl JsBackend {
        self.indent -= 1;
        self.writeln("},");

-        // Scroll
        self.writeln("scrollTo: (x, y) => {");
        self.indent += 1;
        self.writeln("if (typeof window !== 'undefined') window.scrollTo(x, y);");
@@ -558,7 +726,6 @@ impl JsBackend {
        self.indent -= 1;
        self.writeln("},");

-        // Dimensions
        self.writeln("getBoundingClientRect: (el) => {");
        self.indent += 1;
        self.writeln("if (!el) return { top: 0, left: 0, width: 0, height: 0, right: 0, bottom: 0 };");
@@ -574,13 +741,11 @@ impl JsBackend {
        self.indent -= 1;
        self.writeln("}");

-        self.indent -= 1;
-        self.writeln("}");
-
        self.indent -= 1;
        self.writeln("},");
+    }

-        // HTML rendering helpers
+    fn emit_html_helpers(&mut self) {
        self.writeln("");
        self.writeln("// HTML rendering");
        self.writeln("renderHtml: (node) => {");
@@ -682,8 +847,9 @@ impl JsBackend {
        self.writeln("return el;");
        self.indent -= 1;
        self.writeln("},");
+    }

-        // TEA (The Elm Architecture) runtime
+    fn emit_tea_runtime(&mut self) {
        self.writeln("");
        self.writeln("// The Elm Architecture (TEA) runtime");
        self.writeln("app: (config) => {");
@@ -727,7 +893,6 @@ impl JsBackend {
        self.indent -= 1;
        self.writeln("},");

-        // Simple app (for string-based views like the counter example)
        self.writeln("");
        self.writeln("// Simple TEA app (string-based view)");
        self.writeln("simpleApp: (config) => {");
@@ -757,7 +922,6 @@ impl JsBackend {
        self.indent -= 1;
        self.writeln("},");

-        // Diff and patch (basic implementation for view_deps optimization)
        self.writeln("");
        self.writeln("// Basic diff - checks if model fields changed");
        self.writeln("hasChanged: (oldModel, newModel, ...paths) => {");
@@ -777,11 +941,7 @@ impl JsBackend {
        self.writeln("}");
        self.writeln("return false;");
        self.indent -= 1;
-        self.writeln("}");
-
-        self.indent -= 1;
-        self.writeln("};");
-        self.writeln("");
+        self.writeln("},");
    }

    /// Collect type information from a type declaration
@@ -888,7 +1048,8 @@ impl JsBackend {
        let prev_has_handlers = self.has_handlers;
        self.has_handlers = is_effectful;

-        // Clear var substitutions for this function
+        // Save and clear var substitutions for this function scope
+        let saved_substitutions = self.var_substitutions.clone();
        self.var_substitutions.clear();

        // Emit function body
@@ -896,6 +1057,7 @@ impl JsBackend {
        self.writeln(&format!("return {};", body_code));

        self.has_handlers = prev_has_handlers;
+        self.var_substitutions = saved_substitutions;

        self.indent -= 1;
        self.writeln("}");
@@ -909,13 +1071,16 @@ impl JsBackend {
        let val = self.emit_expr(&let_decl.value)?;
        let var_name = &let_decl.name.name;

-        // Check if this is a run expression (often results in undefined)
-        // We still want to execute it for its side effects
+        if var_name == "_" {
+            // Wildcard binding: just execute for side effects
+            self.writeln(&format!("{};", val));
+        } else {
            self.writeln(&format!("const {} = {};", var_name, val));

            // Register the variable for future use
            self.var_substitutions
                .insert(var_name.clone(), var_name.clone());
+        }

        Ok(())
    }
@@ -942,6 +1107,9 @@ impl JsBackend {
                } else if self.functions.contains(&ident.name) {
                    // Function reference (used as value)
                    Ok(self.mangle_name(&ident.name))
+                } else if let Some(js_name) = self.extern_lets.get(&ident.name) {
+                    // Extern let: use JS name directly (no mangling)
+                    Ok(js_name.clone())
                } else {
                    Ok(self.escape_js_keyword(&ident.name))
                }
@@ -954,12 +1122,17 @@ impl JsBackend {
                let r = self.emit_expr(right)?;

                // Check for string concatenation
-                if matches!(op, BinaryOp::Add) {
+                if matches!(op, BinaryOp::Add | BinaryOp::Concat) {
                    if self.is_string_expr(left) || self.is_string_expr(right) {
                        return Ok(format!("({} + {})", l, r));
                    }
                }

+                // ++ on lists: use .concat()
+                if matches!(op, BinaryOp::Concat) {
+                    return Ok(format!("{}.concat({})", l, r));
+                }
+
                let op_str = match op {
                    BinaryOp::Add => "+",
                    BinaryOp::Sub => "-",
@@ -974,6 +1147,7 @@ impl JsBackend {
                    BinaryOp::Ge => ">=",
                    BinaryOp::And => "&&",
                    BinaryOp::Or => "||",
+                    BinaryOp::Concat => unreachable!("handled above"),
                    BinaryOp::Pipe => {
                        // Pipe operator: x |> f becomes f(x)
                        return Ok(format!("{}({})", r, l));
@@ -1034,6 +1208,11 @@ impl JsBackend {
                name, value, body, ..
            } => {
                let val = self.emit_expr(value)?;
+
+                if name.name == "_" {
+                    // Wildcard binding: just execute for side effects
+                    self.writeln(&format!("{};", val));
+                } else {
                    let var_name = format!("{}_{}", name.name, self.fresh_name());

                    self.writeln(&format!("const {} = {};", var_name, val));
@@ -1041,11 +1220,14 @@ impl JsBackend {
                    // Add substitution
                    self.var_substitutions
                        .insert(name.name.clone(), var_name.clone());
+                }

                let body_result = self.emit_expr(body)?;

                // Remove substitution
+                if name.name != "_" {
                    self.var_substitutions.remove(&name.name);
+                }

                Ok(body_result)
            }
@@ -1057,6 +1239,31 @@ impl JsBackend {
                        if module_name.name == "List" {
                            return self.emit_list_operation(&field.name, args);
                        }
+                        if module_name.name == "Map" {
+                            return self.emit_map_operation(&field.name, args);
+                        }
+                    }
+                }
+
+                // Int/Float module operations
+                if let Expr::Field { object, field, .. } = func.as_ref() {
+                    if let Expr::Var(module_name) = object.as_ref() {
+                        if module_name.name == "Int" {
+                            let arg = self.emit_expr(&args[0])?;
+                            match field.name.as_str() {
+                                "toFloat" => return Ok(arg),
+                                "toString" => return Ok(format!("String({})", arg)),
+                                _ => {}
+                            }
+                        }
+                        if module_name.name == "Float" {
+                            let arg = self.emit_expr(&args[0])?;
+                            match field.name.as_str() {
+                                "toInt" => return Ok(format!("Math.trunc({})", arg)),
+                                "toString" => return Ok(format!("String({})", arg)),
+                                _ => {}
+                            }
+                        }
                    }
                }

@@ -1066,6 +1273,10 @@ impl JsBackend {
                        let arg = self.emit_expr(&args[0])?;
                        return Ok(format!("String({})", arg));
                    }
+                    if ident.name == "print" {
+                        let arg = self.emit_expr(&args[0])?;
+                        return Ok(format!("console.log({})", arg));
+                    }
                }

                let arg_strs: Result<Vec<_>, _> = args.iter().map(|a| self.emit_expr(a)).collect();
@@ -1142,6 +1353,26 @@ impl JsBackend {
                    return self.emit_math_operation(&operation.name, args);
                }

+                // Special case: Int module operations
+                if effect.name == "Int" {
+                    let arg = self.emit_expr(&args[0])?;
+                    match operation.name.as_str() {
+                        "toFloat" => return Ok(arg), // JS numbers are already floats
+                        "toString" => return Ok(format!("String({})", arg)),
+                        _ => {}
+                    }
+                }
+
+                // Special case: Float module operations
+                if effect.name == "Float" {
+                    let arg = self.emit_expr(&args[0])?;
+                    match operation.name.as_str() {
+                        "toInt" => return Ok(format!("Math.trunc({})", arg)),
+                        "toString" => return Ok(format!("String({})", arg)),
+                        _ => {}
+                    }
+                }
+
                // Special case: Result module operations (not an effect)
                if effect.name == "Result" {
                    return self.emit_result_operation(&operation.name, args);
@@ -1152,6 +1383,11 @@ impl JsBackend {
                    return self.emit_json_operation(&operation.name, args);
                }

+                // Special case: Map module operations (not an effect)
+                if effect.name == "Map" {
+                    return self.emit_map_operation(&operation.name, args);
+                }
+
                // Special case: Html module operations (not an effect)
                if effect.name == "Html" {
                    return self.emit_html_operation(&operation.name, args);
@@ -1197,18 +1433,39 @@ impl JsBackend {
                    param_names
                };

-                // Save handler state
+                // Save state
                let prev_has_handlers = self.has_handlers;
+                let saved_substitutions = self.var_substitutions.clone();
                self.has_handlers = !effects.is_empty();

+                // Register lambda params as themselves (override any outer substitutions)
+                for p in &all_params {
+                    self.var_substitutions.insert(p.clone(), p.clone());
+                }
+
+                // Capture any statements emitted during body evaluation
+                let output_start = self.output.len();
+                let prev_indent = self.indent;
+                self.indent += 1;
+
                let body_code = self.emit_expr(body)?;
+                self.writeln(&format!("return {};", body_code));

+                // Extract body statements and restore output
+                let body_statements = self.output[output_start..].to_string();
+                self.output.truncate(output_start);
+                self.indent = prev_indent;
+
+                // Restore state
                self.has_handlers = prev_has_handlers;
+                self.var_substitutions = saved_substitutions;

+                let indent_str = "    ".repeat(self.indent);
                Ok(format!(
-                    "(function({}) {{ return {}; }})",
+                    "(function({}) {{\n{}{}}})",
                    all_params.join(", "),
-                    body_code
+                    body_statements,
+                    indent_str,
                ))
            }

@@ -1228,27 +1485,36 @@ impl JsBackend {
                        }
                        Statement::Let { name, value, .. } => {
                            let val = self.emit_expr(value)?;
-                            let var_name = format!("{}_{}", name.name, self.fresh_name());
+                            if name.name == "_" {
+                                self.writeln(&format!("{};", val));
+                            } else {
+                                let var_name =
+                                    format!("{}_{}", name.name, self.fresh_name());
                                self.writeln(&format!("const {} = {};", var_name, val));
                                self.var_substitutions
                                    .insert(name.name.clone(), var_name.clone());
                            }
                        }
                    }
+                }

                // Emit result
                self.emit_expr(result)
            }

-            Expr::Record { fields, .. } => {
-                let field_strs: Result<Vec<_>, _> = fields
-                    .iter()
-                    .map(|(name, expr)| {
+            Expr::Record {
+                spread, fields, ..
+            } => {
+                let mut parts = Vec::new();
+                if let Some(spread_expr) = spread {
+                    let spread_code = self.emit_expr(spread_expr)?;
+                    parts.push(format!("...{}", spread_code));
+                }
+                for (name, expr) in fields {
                    let val = self.emit_expr(expr)?;
-                        Ok(format!("{}: {}", name.name, val))
-                    })
-                    .collect();
-                Ok(format!("{{ {} }}", field_strs?.join(", ")))
+                    parts.push(format!("{}: {}", name.name, val));
+                }
+                Ok(format!("{{ {} }}", parts.join(", ")))
            }

            Expr::Tuple { elements, .. } => {
@@ -1268,6 +1534,11 @@ impl JsBackend {
                Ok(format!("{}.{}", obj, field.name))
            }

+            Expr::TupleIndex { object, index, .. } => {
+                let obj = self.emit_expr(object)?;
+                Ok(format!("{}[{}]", obj, index))
+            }
+
            Expr::Run {
                expr, handlers, ..
            } => {
@@ -1565,6 +1836,79 @@ impl JsBackend {
                    end, start, start
                ))
            }
+            "sort" => {
+                let list = self.emit_expr(&args[0])?;
+                Ok(format!(
+                    "[...{}].sort((a, b) => a < b ? -1 : a > b ? 1 : 0)",
+                    list
+                ))
+            }
+            "sortBy" => {
+                let list = self.emit_expr(&args[0])?;
+                let func = self.emit_expr(&args[1])?;
+                Ok(format!("[...{}].sort({})", list, func))
+            }
+            "find" => {
+                let list = self.emit_expr(&args[0])?;
+                let pred = self.emit_expr(&args[1])?;
+                Ok(format!(
+                    "((__l) => {{ const __r = __l.find({}); return __r !== undefined ? Lux.Some(__r) : Lux.None(); }})({})",
+                    pred, list
+                ))
+            }
+            "findIndex" => {
+                let list = self.emit_expr(&args[0])?;
+                let pred = self.emit_expr(&args[1])?;
+                Ok(format!(
+                    "((__l) => {{ const __i = __l.findIndex({}); return __i !== -1 ? Lux.Some(__i) : Lux.None(); }})({})",
+                    pred, list
+                ))
+            }
+            "any" => {
+                let list = self.emit_expr(&args[0])?;
+                let pred = self.emit_expr(&args[1])?;
+                Ok(format!("{}.some({})", list, pred))
+            }
+            "all" => {
+                let list = self.emit_expr(&args[0])?;
+                let pred = self.emit_expr(&args[1])?;
+                Ok(format!("{}.every({})", list, pred))
+            }
+            "zip" => {
+                let list1 = self.emit_expr(&args[0])?;
+                let list2 = self.emit_expr(&args[1])?;
+                Ok(format!(
+                    "((__a, __b) => __a.slice(0, Math.min(__a.length, __b.length)).map((__x, __i) => [__x, __b[__i]]))({})",
+                    format!("{}, {}", list1, list2)
+                ))
+            }
+            "flatten" => {
+                let list = self.emit_expr(&args[0])?;
+                Ok(format!("{}.flat()", list))
+            }
+            "contains" => {
+                let list = self.emit_expr(&args[0])?;
+                let elem = self.emit_expr(&args[1])?;
+                Ok(format!(
+                    "{}.some(__x => JSON.stringify(__x) === JSON.stringify({}))",
+                    list, elem
+                ))
+            }
+            "take" => {
+                let list = self.emit_expr(&args[0])?;
+                let n = self.emit_expr(&args[1])?;
+                Ok(format!("{}.slice(0, Math.max(0, {}))", list, n))
+            }
+            "drop" => {
+                let list = self.emit_expr(&args[0])?;
+                let n = self.emit_expr(&args[1])?;
+                Ok(format!("{}.slice(Math.max(0, {}))", list, n))
+            }
+            "forEach" => {
+                let list = self.emit_expr(&args[0])?;
+                let func = self.emit_expr(&args[1])?;
+                Ok(format!("({}.forEach({}), undefined)", list, func))
+            }
            _ => Err(JsGenError {
                message: format!("Unknown List operation: {}", operation),
                span: None,
@@ -2062,6 +2406,86 @@ impl JsBackend {
        }
    }

+    /// Emit Map module operations using JS Map
+    fn emit_map_operation(
+        &mut self,
+        operation: &str,
+        args: &[Expr],
+    ) -> Result<String, JsGenError> {
+        match operation {
+            "new" => Ok("new Map()".to_string()),
+            "set" => {
+                let map = self.emit_expr(&args[0])?;
+                let key = self.emit_expr(&args[1])?;
+                let val = self.emit_expr(&args[2])?;
+                Ok(format!(
+                    "(function() {{ var m = new Map({}); m.set({}, {}); return m; }})()",
+                    map, key, val
+                ))
+            }
+            "get" => {
+                let map = self.emit_expr(&args[0])?;
+                let key = self.emit_expr(&args[1])?;
+                Ok(format!(
+                    "({0}.has({1}) ? Lux.Some({0}.get({1})) : Lux.None())",
+                    map, key
+                ))
+            }
+            "contains" => {
+                let map = self.emit_expr(&args[0])?;
+                let key = self.emit_expr(&args[1])?;
+                Ok(format!("{}.has({})", map, key))
+            }
+            "remove" => {
+                let map = self.emit_expr(&args[0])?;
+                let key = self.emit_expr(&args[1])?;
+                Ok(format!(
+                    "(function() {{ var m = new Map({}); m.delete({}); return m; }})()",
+                    map, key
+                ))
+            }
+            "keys" => {
+                let map = self.emit_expr(&args[0])?;
+                Ok(format!("Array.from({}.keys()).sort()", map))
+            }
+            "values" => {
+                let map = self.emit_expr(&args[0])?;
+                Ok(format!(
+                    "Array.from({0}.entries()).sort(function(a,b) {{ return a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0; }}).map(function(e) {{ return e[1]; }})",
+                    map
+                ))
+            }
+            "size" => {
+                let map = self.emit_expr(&args[0])?;
+                Ok(format!("{}.size", map))
+            }
+            "isEmpty" => {
+                let map = self.emit_expr(&args[0])?;
+                Ok(format!("({}.size === 0)", map))
+            }
+            "fromList" => {
+                let list = self.emit_expr(&args[0])?;
+                Ok(format!("new Map({}.map(function(t) {{ return [t[0], t[1]]; }}))", list))
+            }
+            "toList" => {
+                let map = self.emit_expr(&args[0])?;
+                Ok(format!(
+                    "Array.from({}.entries()).sort(function(a,b) {{ return a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0; }})",
+                    map
+                ))
+            }
+            "merge" => {
+                let m1 = self.emit_expr(&args[0])?;
+                let m2 = self.emit_expr(&args[1])?;
+                Ok(format!("new Map([...{}, ...{}])", m1, m2))
+            }
+            _ => Err(JsGenError {
+                message: format!("Unknown Map operation: {}", operation),
+                span: None,
+            }),
+        }
+    }
+
    /// Emit Html module operations for type-safe HTML construction
    fn emit_html_operation(
        &mut self,
@@ -2333,7 +2757,7 @@ impl JsBackend {
                }
            }
            Expr::BinaryOp { op, left, right, .. } => {
-                matches!(op, BinaryOp::Add)
+                matches!(op, BinaryOp::Add | BinaryOp::Concat)
                    && (self.is_string_expr(left) || self.is_string_expr(right))
            }
            _ => false,
@@ -2384,6 +2808,10 @@ impl JsBackend {

    /// Mangle a Lux name to a valid JavaScript name
    fn mangle_name(&self, name: &str) -> String {
+        // Extern functions use their JS name directly (no mangling)
+        if let Some(js_name) = self.extern_fns.get(name) {
+            return js_name.clone();
+        }
        format!("{}_lux", name)
    }

@@ -3732,7 +4160,7 @@ line3"

    #[test]
    fn test_js_runtime_generated() {
-        // Test that the Lux runtime is properly generated
+        // Test that the Lux runtime core is always generated
        use crate::parser::Parser;

        let source = r#"
@@ -3743,21 +4171,51 @@ line3"
        let mut backend = JsBackend::new();
        let js_code = backend.generate(&program).expect("Should generate");

-        // Check that Lux runtime includes key functions
+        // Core runtime is always present
        assert!(js_code.contains("const Lux = {"), "Lux object should be defined");
        assert!(js_code.contains("Some:"), "Option Some should be defined");
        assert!(js_code.contains("None:"), "Option None should be defined");
-        assert!(js_code.contains("renderHtml:"), "renderHtml should be defined");
-        assert!(js_code.contains("renderToDom:"), "renderToDom should be defined");
-        assert!(js_code.contains("escapeHtml:"), "escapeHtml should be defined");
-        assert!(js_code.contains("app:"), "TEA app should be defined");
-        assert!(js_code.contains("simpleApp:"), "simpleApp should be defined");
-        assert!(js_code.contains("hasChanged:"), "hasChanged should be defined");
+
+        // Console-only program should NOT include Dom, Html, or TEA sections
+        assert!(!js_code.contains("Dom:"), "Dom handler should not be in Console-only program");
+        assert!(!js_code.contains("renderHtml:"), "renderHtml should not be in Console-only program");
+        assert!(!js_code.contains("app:"), "TEA app should not be in Console-only program");
+        assert!(!js_code.contains("Http:"), "Http should not be in Console-only program");
+
+        // Console should be present
+        assert!(js_code.contains("Console:"), "Console handler should exist");
+    }
+
+    #[test]
+    fn test_js_runtime_tree_shaking_all_effects() {
+        // Test that all effects are included when all are used
+        use crate::parser::Parser;
+
+        let source = r#"
+            fn main(): Unit with {Console, Dom} = {
+                Console.print("Hello")
+                let _ = Dom.getElementById("app")
+                ()
+            }
+        "#;
+
+        let program = Parser::parse_source(source).expect("Should parse");
+        let mut backend = JsBackend::new();
+        let js_code = backend.generate(&program).expect("Should generate");
+
+        assert!(js_code.contains("Console:"), "Console handler should exist");
+        assert!(js_code.contains("Dom:"), "Dom handler should exist");
+        assert!(js_code.contains("renderHtml:"), "renderHtml should be defined when Dom is used");
+        assert!(js_code.contains("renderToDom:"), "renderToDom should be defined when Dom is used");
+        assert!(js_code.contains("escapeHtml:"), "escapeHtml should be defined when Dom is used");
+        assert!(js_code.contains("app:"), "TEA app should be defined when Dom is used");
+        assert!(js_code.contains("simpleApp:"), "simpleApp should be defined when Dom is used");
+        assert!(js_code.contains("hasChanged:"), "hasChanged should be defined when Dom is used");
    }

    #[test]
    fn test_js_runtime_default_handlers() {
-        // Test that default handlers are properly generated
+        // Test that only used effect handlers are generated
        use crate::parser::Parser;

        let source = r#"
@@ -3768,12 +4226,12 @@ line3"
        let mut backend = JsBackend::new();
        let js_code = backend.generate(&program).expect("Should generate");

-        // Check that default handlers include all effects
+        // Only Console should be present
        assert!(js_code.contains("Console:"), "Console handler should exist");
-        assert!(js_code.contains("Random:"), "Random handler should exist");
-        assert!(js_code.contains("Time:"), "Time handler should exist");
-        assert!(js_code.contains("Http:"), "Http handler should exist");
-        assert!(js_code.contains("Dom:"), "Dom handler should exist");
+        assert!(!js_code.contains("Random:"), "Random handler should not exist in Console-only program");
+        assert!(!js_code.contains("Time:"), "Time handler should not exist in Console-only program");
+        assert!(!js_code.contains("Http:"), "Http handler should not exist in Console-only program");
+        assert!(!js_code.contains("Dom:"), "Dom handler should not exist in Console-only program");
    }

    #[test]
--- a/src/exhaustiveness.rs
+++ b/src/exhaustiveness.rs
@@ -333,11 +333,13 @@ mod tests {
    fn test_option_exhaustive() {
        let patterns = vec![
            Pattern::Constructor {
+                module: None,
                name: make_ident("None"),
                fields: vec![],
                span: span(),
            },
            Pattern::Constructor {
+                module: None,
                name: make_ident("Some"),
                fields: vec![Pattern::Wildcard(span())],
                span: span(),
@@ -352,6 +354,7 @@ mod tests {
    #[test]
    fn test_option_missing_none() {
        let patterns = vec![Pattern::Constructor {
+            module: None,
            name: make_ident("Some"),
            fields: vec![Pattern::Wildcard(span())],
            span: span(),
@@ -391,11 +394,13 @@ mod tests {
    fn test_result_exhaustive() {
        let patterns = vec![
            Pattern::Constructor {
+                module: None,
                name: make_ident("Ok"),
                fields: vec![Pattern::Wildcard(span())],
                span: span(),
            },
            Pattern::Constructor {
+                module: None,
                name: make_ident("Err"),
                fields: vec![Pattern::Wildcard(span())],
                span: span(),
--- a/src/formatter.rs
+++ b/src/formatter.rs
@@ -3,9 +3,9 @@
 //! Formats Lux source code according to standard style guidelines.

 use crate::ast::{
-    BehavioralProperty, BinaryOp, Declaration, EffectDecl, Expr, FunctionDecl, HandlerDecl,
-    ImplDecl, ImplMethod, LetDecl, Literal, LiteralKind, Pattern, Program, Statement, TraitDecl,
-    TypeDecl, TypeDef, TypeExpr, UnaryOp, VariantFields,
+    BehavioralProperty, BinaryOp, Declaration, EffectDecl, ExternFnDecl, ExternLetDecl, Expr, FunctionDecl,
+    HandlerDecl, ImplDecl, ImplMethod, LetDecl, Literal, LiteralKind, Pattern, Program, Statement,
+    TraitDecl, TypeDecl, TypeDef, TypeExpr, UnaryOp, VariantFields, Visibility,
 };
 use crate::lexer::Lexer;
 use crate::parser::Parser;
@@ -103,9 +103,77 @@ impl Formatter {
            Declaration::Handler(h) => self.format_handler(h),
            Declaration::Trait(t) => self.format_trait(t),
            Declaration::Impl(i) => self.format_impl(i),
+            Declaration::ExternFn(e) => self.format_extern_fn(e),
+            Declaration::ExternLet(e) => self.format_extern_let(e),
        }
    }

+    fn format_extern_fn(&mut self, ext: &ExternFnDecl) {
+        let indent = self.indent();
+        self.write(&indent);
+
+        if ext.visibility == Visibility::Public {
+            self.write("pub ");
+        }
+
+        self.write("extern fn ");
+        self.write(&ext.name.name);
+
+        // Type parameters
+        if !ext.type_params.is_empty() {
+            self.write("<");
+            self.write(
+                &ext.type_params
+                    .iter()
+                    .map(|p| p.name.clone())
+                    .collect::<Vec<_>>()
+                    .join(", "),
+            );
+            self.write(">");
+        }
+
+        // Parameters
+        self.write("(");
+        let params: Vec<String> = ext
+            .params
+            .iter()
+            .map(|p| format!("{}: {}", p.name.name, self.format_type_expr(&p.typ)))
+            .collect();
+        self.write(&params.join(", "));
+        self.write("): ");
+
+        // Return type
+        self.write(&self.format_type_expr(&ext.return_type));
+
+        // Optional JS name
+        if let Some(js_name) = &ext.js_name {
+            self.write(&format!(" = \"{}\"", js_name));
+        }
+
+        self.newline();
+    }
+
+    fn format_extern_let(&mut self, ext: &ExternLetDecl) {
+        let indent = self.indent();
+        self.write(&indent);
+
+        if ext.visibility == Visibility::Public {
+            self.write("pub ");
+        }
+
+        self.write("extern let ");
+        self.write(&ext.name.name);
+        self.write(": ");
+        self.write(&self.format_type_expr(&ext.typ));
+
+        // Optional JS name
+        if let Some(js_name) = &ext.js_name {
+            self.write(&format!(" = \"{}\"", js_name));
+        }
+
+        self.newline();
+    }
+
    fn format_function(&mut self, func: &FunctionDecl) {
        let indent = self.indent();
        self.write(&indent);
@@ -598,6 +666,9 @@ impl Formatter {
            Expr::Field { object, field, .. } => {
                format!("{}.{}", self.format_expr(object), field.name)
            }
+            Expr::TupleIndex { object, index, .. } => {
+                format!("{}.{}", self.format_expr(object), index)
+            }
            Expr::If { condition, then_branch, else_branch, .. } => {
                format!(
                    "if {} then {} else {}",
@@ -685,15 +756,17 @@ impl Formatter {
                        .join(", ")
                )
            }
-            Expr::Record { fields, .. } => {
-                format!(
-                    "{{ {} }}",
-                    fields
-                        .iter()
-                        .map(|(name, val)| format!("{}: {}", name.name, self.format_expr(val)))
-                        .collect::<Vec<_>>()
-                        .join(", ")
-                )
+            Expr::Record {
+                spread, fields, ..
+            } => {
+                let mut parts = Vec::new();
+                if let Some(spread_expr) = spread {
+                    parts.push(format!("...{}", self.format_expr(spread_expr)));
+                }
+                for (name, val) in fields {
+                    parts.push(format!("{}: {}", name.name, self.format_expr(val)));
+                }
+                format!("{{ {} }}", parts.join(", "))
            }
            Expr::EffectOp { effect, operation, args, .. } => {
                format!(
@@ -728,7 +801,30 @@ impl Formatter {
        match &lit.kind {
            LiteralKind::Int(n) => n.to_string(),
            LiteralKind::Float(f) => format!("{}", f),
-            LiteralKind::String(s) => format!("\"{}\"", s.replace('\\', "\\\\").replace('"', "\\\"")),
+            LiteralKind::String(s) => {
+                if s.contains('\n') {
+                    // Use triple-quoted multiline string
+                    let tab = " ".repeat(self.config.indent_size);
+                    let base_indent = tab.repeat(self.indent_level);
+                    let content_indent = tab.repeat(self.indent_level + 1);
+                    let lines: Vec<&str> = s.split('\n').collect();
+                    let mut result = String::from("\"\"\"\n");
+                    for line in &lines {
+                        if line.is_empty() {
+                            result.push('\n');
+                        } else {
+                            result.push_str(&content_indent);
+                            result.push_str(&line.replace('{', "\\{").replace('}', "\\}"));
+                            result.push('\n');
+                        }
+                    }
+                    result.push_str(&base_indent);
+                    result.push_str("\"\"\"");
+                    result
+                } else {
+                    format!("\"{}\"", s.replace('\\', "\\\\").replace('"', "\\\"").replace('{', "\\{").replace('}', "\\}"))
+                }
+            },
            LiteralKind::Char(c) => format!("'{}'", c),
            LiteralKind::Bool(b) => b.to_string(),
            LiteralKind::Unit => "()".to_string(),
@@ -750,6 +846,7 @@ impl Formatter {
            BinaryOp::Ge => ">=",
            BinaryOp::And => "&&",
            BinaryOp::Or => "||",
+            BinaryOp::Concat => "++",
            BinaryOp::Pipe => "|>",
        }
    }
@@ -766,12 +863,22 @@ impl Formatter {
            Pattern::Wildcard(_) => "_".to_string(),
            Pattern::Var(ident) => ident.name.clone(),
            Pattern::Literal(lit) => self.format_literal(lit),
-            Pattern::Constructor { name, fields, .. } => {
+            Pattern::Constructor {
+                module,
+                name,
+                fields,
+                ..
+            } => {
+                let prefix = match module {
+                    Some(m) => format!("{}.", m.name),
+                    None => String::new(),
+                };
                if fields.is_empty() {
-                    name.name.clone()
+                    format!("{}{}", prefix, name.name)
                } else {
                    format!(
-                        "{}({})",
+                        "{}{}({})",
+                        prefix,
                        name.name,
                        fields
                            .iter()
--- a/src/interpreter.rs
+++ b/src/interpreter.rs
@@ -28,6 +28,8 @@ pub enum BuiltinFn {
    ListGet,
    ListRange,
    ListForEach,
+    ListSort,
+    ListSortBy,

    // String operations
    StringSplit,
@@ -74,14 +76,21 @@ pub enum BuiltinFn {
    MathFloor,
    MathCeil,
    MathRound,
+    MathSin,
+    MathCos,
+    MathAtan2,

    // Additional List operations
    ListIsEmpty,
    ListFind,
+    ListFindIndex,
    ListAny,
    ListAll,
    ListTake,
    ListDrop,
+    ListZip,
+    ListFlatten,
+    ListContains,

    // Additional String operations
    StringStartsWith,
@@ -95,6 +104,12 @@ pub enum BuiltinFn {
    StringLastIndexOf,
    StringRepeat,

+    // Int/Float operations
+    IntToString,
+    IntToFloat,
+    FloatToString,
+    FloatToInt,
+
    // JSON operations
    JsonParse,
    JsonStringify,
@@ -115,6 +130,20 @@ pub enum BuiltinFn {
    JsonString,
    JsonArray,
    JsonObject,
+
+    // Map operations
+    MapNew,
+    MapSet,
+    MapGet,
+    MapContains,
+    MapRemove,
+    MapKeys,
+    MapValues,
+    MapSize,
+    MapIsEmpty,
+    MapFromList,
+    MapToList,
+    MapMerge,
 }

 /// Runtime value
@@ -129,6 +158,7 @@ pub enum Value {
    List(Vec<Value>),
    Tuple(Vec<Value>),
    Record(HashMap<String, Value>),
+    Map(HashMap<String, Value>),
    Function(Rc<Closure>),
    Handler(Rc<HandlerValue>),
    /// Built-in function
@@ -146,6 +176,11 @@ pub enum Value {
    },
    /// JSON value (for JSON parsing/manipulation)
    Json(serde_json::Value),
+    /// Extern function (FFI — only callable from JS backend)
+    ExternFn {
+        name: String,
+        arity: usize,
+    },
 }

 impl Value {
@@ -160,12 +195,14 @@ impl Value {
            Value::List(_) => "List",
            Value::Tuple(_) => "Tuple",
            Value::Record(_) => "Record",
+            Value::Map(_) => "Map",
            Value::Function(_) => "Function",
            Value::Handler(_) => "Handler",
            Value::Builtin(_) => "Function",
            Value::Constructor { .. } => "Constructor",
            Value::Versioned { .. } => "Versioned",
            Value::Json(_) => "Json",
+            Value::ExternFn { .. } => "ExternFn",
        }
    }

@@ -208,6 +245,11 @@ impl Value {
                    ys.get(k).map(|yv| Value::values_equal(v, yv)).unwrap_or(false)
                })
            }
+            (Value::Map(xs), Value::Map(ys)) => {
+                xs.len() == ys.len() && xs.iter().all(|(k, v)| {
+                    ys.get(k).map(|yv| Value::values_equal(v, yv)).unwrap_or(false)
+                })
+            }
            (Value::Constructor { name: n1, fields: f1 }, Value::Constructor { name: n2, fields: f2 }) => {
                n1 == n2 && f1.len() == f2.len() && f1.iter().zip(f2.iter()).all(|(x, y)| Value::values_equal(x, y))
            }
@@ -278,6 +320,16 @@ impl TryFromValue for Vec<Value> {
    }
 }

+impl TryFromValue for HashMap<String, Value> {
+    const TYPE_NAME: &'static str = "Map";
+    fn try_from_value(value: &Value) -> Option<Self> {
+        match value {
+            Value::Map(m) => Some(m.clone()),
+            _ => None,
+        }
+    }
+}
+
 impl TryFromValue for Value {
    const TYPE_NAME: &'static str = "any";
    fn try_from_value(value: &Value) -> Option<Self> {
@@ -324,6 +376,18 @@ impl fmt::Display for Value {
                }
                write!(f, " }}")
            }
+            Value::Map(entries) => {
+                write!(f, "Map {{")?;
+                let mut sorted: Vec<_> = entries.iter().collect();
+                sorted.sort_by_key(|(k, _)| (*k).clone());
+                for (i, (key, value)) in sorted.iter().enumerate() {
+                    if i > 0 {
+                        write!(f, ", ")?;
+                    }
+                    write!(f, "\"{}\": {}", key, value)?;
+                }
+                write!(f, "}}")
+            }
            Value::Function(_) => write!(f, "<function>"),
            Value::Builtin(b) => write!(f, "<builtin:{:?}>", b),
            Value::Handler(_) => write!(f, "<handler>"),
@@ -349,6 +413,7 @@ impl fmt::Display for Value {
                write!(f, "{} @v{}", value, version)
            }
            Value::Json(json) => write!(f, "{}", json),
+            Value::ExternFn { name, .. } => write!(f, "<extern fn {}>", name),
        }
    }
 }
@@ -920,14 +985,23 @@ impl Interpreter {
                Value::Builtin(BuiltinFn::ListIsEmpty),
            ),
            ("find".to_string(), Value::Builtin(BuiltinFn::ListFind)),
+            ("findIndex".to_string(), Value::Builtin(BuiltinFn::ListFindIndex)),
            ("any".to_string(), Value::Builtin(BuiltinFn::ListAny)),
            ("all".to_string(), Value::Builtin(BuiltinFn::ListAll)),
            ("take".to_string(), Value::Builtin(BuiltinFn::ListTake)),
            ("drop".to_string(), Value::Builtin(BuiltinFn::ListDrop)),
+            ("zip".to_string(), Value::Builtin(BuiltinFn::ListZip)),
+            ("flatten".to_string(), Value::Builtin(BuiltinFn::ListFlatten)),
+            ("contains".to_string(), Value::Builtin(BuiltinFn::ListContains)),
            (
                "forEach".to_string(),
                Value::Builtin(BuiltinFn::ListForEach),
            ),
+            ("sort".to_string(), Value::Builtin(BuiltinFn::ListSort)),
+            (
+                "sortBy".to_string(),
+                Value::Builtin(BuiltinFn::ListSortBy),
+            ),
        ]));
        env.define("List", list_module);

@@ -1068,9 +1142,26 @@ impl Interpreter {
            ("floor".to_string(), Value::Builtin(BuiltinFn::MathFloor)),
            ("ceil".to_string(), Value::Builtin(BuiltinFn::MathCeil)),
            ("round".to_string(), Value::Builtin(BuiltinFn::MathRound)),
+            ("sin".to_string(), Value::Builtin(BuiltinFn::MathSin)),
+            ("cos".to_string(), Value::Builtin(BuiltinFn::MathCos)),
+            ("atan2".to_string(), Value::Builtin(BuiltinFn::MathAtan2)),
        ]));
        env.define("Math", math_module);

+        // Int module
+        let int_module = Value::Record(HashMap::from([
+            ("toString".to_string(), Value::Builtin(BuiltinFn::IntToString)),
+            ("toFloat".to_string(), Value::Builtin(BuiltinFn::IntToFloat)),
+        ]));
+        env.define("Int", int_module);
+
+        // Float module
+        let float_module = Value::Record(HashMap::from([
+            ("toString".to_string(), Value::Builtin(BuiltinFn::FloatToString)),
+            ("toInt".to_string(), Value::Builtin(BuiltinFn::FloatToInt)),
+        ]));
+        env.define("Float", float_module);
+
        // JSON module
        let json_module = Value::Record(HashMap::from([
            ("parse".to_string(), Value::Builtin(BuiltinFn::JsonParse)),
@@ -1094,16 +1185,72 @@ impl Interpreter {
            ("object".to_string(), Value::Builtin(BuiltinFn::JsonObject)),
        ]));
        env.define("Json", json_module);
+
+        // Map module
+        let map_module = Value::Record(HashMap::from([
+            ("new".to_string(), Value::Builtin(BuiltinFn::MapNew)),
+            ("set".to_string(), Value::Builtin(BuiltinFn::MapSet)),
+            ("get".to_string(), Value::Builtin(BuiltinFn::MapGet)),
+            ("contains".to_string(), Value::Builtin(BuiltinFn::MapContains)),
+            ("remove".to_string(), Value::Builtin(BuiltinFn::MapRemove)),
+            ("keys".to_string(), Value::Builtin(BuiltinFn::MapKeys)),
+            ("values".to_string(), Value::Builtin(BuiltinFn::MapValues)),
+            ("size".to_string(), Value::Builtin(BuiltinFn::MapSize)),
+            ("isEmpty".to_string(), Value::Builtin(BuiltinFn::MapIsEmpty)),
+            ("fromList".to_string(), Value::Builtin(BuiltinFn::MapFromList)),
+            ("toList".to_string(), Value::Builtin(BuiltinFn::MapToList)),
+            ("merge".to_string(), Value::Builtin(BuiltinFn::MapMerge)),
+        ]));
+        env.define("Map", map_module);
    }

    /// Execute a program
    pub fn run(&mut self, program: &Program) -> Result<Value, RuntimeError> {
        let mut last_value = Value::Unit;
+        let mut has_main_let = false;

        for decl in &program.declarations {
+            // Track if there's a top-level `let main = ...`
+            if let Declaration::Let(let_decl) = decl {
+                if let_decl.name.name == "main" {
+                    has_main_let = true;
+                }
+            }
            last_value = self.eval_declaration(decl)?;
        }

+        // Auto-invoke main if it was defined as a let binding with a function value
+        if has_main_let {
+            if let Some(main_val) = self.global_env.get("main") {
+                if let Value::Function(ref closure) = main_val {
+                    if closure.params.is_empty() {
+                        let span = Span { start: 0, end: 0 };
+                        let mut result = self.eval_call(main_val.clone(), vec![], span)?;
+                        // Trampoline loop
+                        loop {
+                            match result {
+                                EvalResult::Value(v) => {
+                                    last_value = v;
+                                    break;
+                                }
+                                EvalResult::Effect(req) => {
+                                    last_value = self.handle_effect(req)?;
+                                    break;
+                                }
+                                EvalResult::TailCall { func, args, span } => {
+                                    result = self.eval_call(func, args, span)?;
+                                }
+                                EvalResult::Resume(v) => {
+                                    last_value = v;
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
        Ok(last_value)
    }

@@ -1265,6 +1412,33 @@ impl Interpreter {
                Ok(Value::Unit)
            }

+            Declaration::ExternFn(ext) => {
+                // Register a placeholder that errors at runtime
+                let name = ext.name.name.clone();
+                let arity = ext.params.len();
+                // Create a closure that produces a clear error
+                let closure = Closure {
+                    params: ext.params.iter().map(|p| p.name.name.clone()).collect(),
+                    body: Expr::Literal(crate::ast::Literal {
+                        kind: crate::ast::LiteralKind::Unit,
+                        span: ext.span,
+                    }),
+                    env: self.global_env.clone(),
+                };
+                // We store an ExternFn marker value
+                self.global_env
+                    .define(&name, Value::ExternFn { name: name.clone(), arity });
+                Ok(Value::Unit)
+            }
+
+            Declaration::ExternLet(ext) => {
+                // Register a placeholder that errors at runtime (extern lets only work in JS)
+                let name = ext.name.name.clone();
+                self.global_env
+                    .define(&name, Value::ExternFn { name: name.clone(), arity: 0 });
+                Ok(Value::Unit)
+            }
+
            Declaration::Effect(_) | Declaration::Trait(_) | Declaration::Impl(_) => {
                // These are compile-time only
                Ok(Value::Unit)
@@ -1415,6 +1589,34 @@ impl Interpreter {
                }
            }

+            Expr::TupleIndex {
+                object,
+                index,
+                span,
+            } => {
+                let obj_val = self.eval_expr(object, env)?;
+                match obj_val {
+                    Value::Tuple(elements) => {
+                        if *index < elements.len() {
+                            Ok(EvalResult::Value(elements[*index].clone()))
+                        } else {
+                            Err(RuntimeError {
+                                message: format!(
+                                    "Tuple index {} out of bounds for tuple with {} elements",
+                                    index,
+                                    elements.len()
+                                ),
+                                span: Some(*span),
+                            })
+                        }
+                    }
+                    _ => Err(RuntimeError {
+                        message: format!("Cannot use tuple index on {}", obj_val.type_name()),
+                        span: Some(*span),
+                    }),
+                }
+            }
+
            Expr::Lambda { params, body, .. } => {
                let closure = Closure {
                    params: params.iter().map(|p| p.name.name.clone()).collect(),
@@ -1481,8 +1683,28 @@ impl Interpreter {
                self.eval_expr_tail(result, &block_env, tail)
            }

-            Expr::Record { fields, .. } => {
+            Expr::Record {
+                spread, fields, ..
+            } => {
                let mut record = HashMap::new();
+
+                // If there's a spread, evaluate it and start with its fields
+                if let Some(spread_expr) = spread {
+                    let spread_val = self.eval_expr(spread_expr, env)?;
+                    if let Value::Record(spread_fields) = spread_val {
+                        record = spread_fields;
+                    } else {
+                        return Err(RuntimeError {
+                            message: format!(
+                                "Spread expression must evaluate to a record, got {}",
+                                spread_val.type_name()
+                            ),
+                            span: Some(expr.span()),
+                        });
+                    }
+                }
+
+                // Override with explicit fields
                for (name, expr) in fields {
                    let val = self.eval_expr(expr, env)?;
                    record.insert(name.name.clone(), val);
@@ -1555,6 +1777,18 @@ impl Interpreter {
                    span: Some(span),
                }),
            },
+            BinaryOp::Concat => match (left, right) {
+                (Value::String(a), Value::String(b)) => Ok(Value::String(a + &b)),
+                (Value::List(a), Value::List(b)) => {
+                    let mut result = a;
+                    result.extend(b);
+                    Ok(Value::List(result))
+                }
+                (l, r) => Err(RuntimeError {
+                    message: format!("Cannot concatenate {} and {}", l.type_name(), r.type_name()),
+                    span: Some(span),
+                }),
+            },
            BinaryOp::Sub => match (left, right) {
                (Value::Int(a), Value::Int(b)) => Ok(Value::Int(a - b)),
                (Value::Float(a), Value::Float(b)) => Ok(Value::Float(a - b)),
@@ -1610,6 +1844,7 @@ impl Interpreter {
                (Value::Int(a), Value::Int(b)) => Ok(Value::Bool(a < b)),
                (Value::Float(a), Value::Float(b)) => Ok(Value::Bool(a < b)),
                (Value::String(a), Value::String(b)) => Ok(Value::Bool(a < b)),
+                (Value::Char(a), Value::Char(b)) => Ok(Value::Bool(a < b)),
                (l, r) => Err(RuntimeError {
                    message: format!("Cannot compare {} and {}", l.type_name(), r.type_name()),
                    span: Some(span),
@@ -1619,6 +1854,7 @@ impl Interpreter {
                (Value::Int(a), Value::Int(b)) => Ok(Value::Bool(a <= b)),
                (Value::Float(a), Value::Float(b)) => Ok(Value::Bool(a <= b)),
                (Value::String(a), Value::String(b)) => Ok(Value::Bool(a <= b)),
+                (Value::Char(a), Value::Char(b)) => Ok(Value::Bool(a <= b)),
                (l, r) => Err(RuntimeError {
                    message: format!("Cannot compare {} and {}", l.type_name(), r.type_name()),
                    span: Some(span),
@@ -1628,6 +1864,7 @@ impl Interpreter {
                (Value::Int(a), Value::Int(b)) => Ok(Value::Bool(a > b)),
                (Value::Float(a), Value::Float(b)) => Ok(Value::Bool(a > b)),
                (Value::String(a), Value::String(b)) => Ok(Value::Bool(a > b)),
+                (Value::Char(a), Value::Char(b)) => Ok(Value::Bool(a > b)),
                (l, r) => Err(RuntimeError {
                    message: format!("Cannot compare {} and {}", l.type_name(), r.type_name()),
                    span: Some(span),
@@ -1637,6 +1874,7 @@ impl Interpreter {
                (Value::Int(a), Value::Int(b)) => Ok(Value::Bool(a >= b)),
                (Value::Float(a), Value::Float(b)) => Ok(Value::Bool(a >= b)),
                (Value::String(a), Value::String(b)) => Ok(Value::Bool(a >= b)),
+                (Value::Char(a), Value::Char(b)) => Ok(Value::Bool(a >= b)),
                (l, r) => Err(RuntimeError {
                    message: format!("Cannot compare {} and {}", l.type_name(), r.type_name()),
                    span: Some(span),
@@ -1720,6 +1958,13 @@ impl Interpreter {
                }))
            }
            Value::Builtin(builtin) => self.eval_builtin(builtin, args, span),
+            Value::ExternFn { name, .. } => Err(RuntimeError {
+                message: format!(
+                    "Extern function '{}' can only be called when compiled to JavaScript (use `lux build --target js`)",
+                    name
+                ),
+                span: Some(span),
+            }),
            v => Err(RuntimeError {
                message: format!("Cannot call {}", v.type_name()),
                span: Some(span),
@@ -2219,6 +2464,46 @@ impl Interpreter {
                Ok(EvalResult::Value(Value::String(result)))
            }

+            BuiltinFn::IntToString => {
+                if args.len() != 1 {
+                    return Err(err("Int.toString requires 1 argument"));
+                }
+                match &args[0] {
+                    Value::Int(n) => Ok(EvalResult::Value(Value::String(format!("{}", n)))),
+                    v => Ok(EvalResult::Value(Value::String(format!("{}", v)))),
+                }
+            }
+
+            BuiltinFn::FloatToString => {
+                if args.len() != 1 {
+                    return Err(err("Float.toString requires 1 argument"));
+                }
+                match &args[0] {
+                    Value::Float(f) => Ok(EvalResult::Value(Value::String(format!("{}", f)))),
+                    v => Ok(EvalResult::Value(Value::String(format!("{}", v)))),
+                }
+            }
+
+            BuiltinFn::IntToFloat => {
+                if args.len() != 1 {
+                    return Err(err("Int.toFloat requires 1 argument"));
+                }
+                match &args[0] {
+                    Value::Int(n) => Ok(EvalResult::Value(Value::Float(*n as f64))),
+                    v => Err(err(&format!("Int.toFloat expects Int, got {}", v.type_name()))),
+                }
+            }
+
+            BuiltinFn::FloatToInt => {
+                if args.len() != 1 {
+                    return Err(err("Float.toInt requires 1 argument"));
+                }
+                match &args[0] {
+                    Value::Float(f) => Ok(EvalResult::Value(Value::Int(*f as i64))),
+                    v => Err(err(&format!("Float.toInt expects Float, got {}", v.type_name()))),
+                }
+            }
+
            BuiltinFn::TypeOf => {
                if args.len() != 1 {
                    return Err(err("typeOf requires 1 argument"));
@@ -2395,6 +2680,45 @@ impl Interpreter {
                }
            }

+            BuiltinFn::MathSin => {
+                if args.len() != 1 {
+                    return Err(err("Math.sin requires 1 argument"));
+                }
+                match &args[0] {
+                    Value::Float(n) => Ok(EvalResult::Value(Value::Float(n.sin()))),
+                    Value::Int(n) => Ok(EvalResult::Value(Value::Float((*n as f64).sin()))),
+                    v => Err(err(&format!("Math.sin expects number, got {}", v.type_name()))),
+                }
+            }
+
+            BuiltinFn::MathCos => {
+                if args.len() != 1 {
+                    return Err(err("Math.cos requires 1 argument"));
+                }
+                match &args[0] {
+                    Value::Float(n) => Ok(EvalResult::Value(Value::Float(n.cos()))),
+                    Value::Int(n) => Ok(EvalResult::Value(Value::Float((*n as f64).cos()))),
+                    v => Err(err(&format!("Math.cos expects number, got {}", v.type_name()))),
+                }
+            }
+
+            BuiltinFn::MathAtan2 => {
+                if args.len() != 2 {
+                    return Err(err("Math.atan2 requires 2 arguments: y, x"));
+                }
+                let y = match &args[0] {
+                    Value::Float(n) => *n,
+                    Value::Int(n) => *n as f64,
+                    v => return Err(err(&format!("Math.atan2 expects number, got {}", v.type_name()))),
+                };
+                let x = match &args[1] {
+                    Value::Float(n) => *n,
+                    Value::Int(n) => *n as f64,
+                    v => return Err(err(&format!("Math.atan2 expects number, got {}", v.type_name()))),
+                };
+                Ok(EvalResult::Value(Value::Float(y.atan2(x))))
+            }
+
            // Additional List operations
            BuiltinFn::ListIsEmpty => {
                let list = Self::expect_arg_1::<Vec<Value>>(&args, "List.isEmpty", span)?;
@@ -2448,6 +2772,55 @@ impl Interpreter {
                Ok(EvalResult::Value(Value::Bool(true)))
            }

+            BuiltinFn::ListFindIndex => {
+                let (list, func) = Self::expect_args_2::<Vec<Value>, Value>(&args, "List.findIndex", span)?;
+                for (i, item) in list.iter().enumerate() {
+                    let v = self.eval_call_to_value(func.clone(), vec![item.clone()], span)?;
+                    match v {
+                        Value::Bool(true) => {
+                            return Ok(EvalResult::Value(Value::Constructor {
+                                name: "Some".to_string(),
+                                fields: vec![Value::Int(i as i64)],
+                            }));
+                        }
+                        Value::Bool(false) => {}
+                        _ => return Err(err("List.findIndex predicate must return Bool")),
+                    }
+                }
+                Ok(EvalResult::Value(Value::Constructor {
+                    name: "None".to_string(),
+                    fields: vec![],
+                }))
+            }
+
+            BuiltinFn::ListZip => {
+                let (list1, list2) = Self::expect_args_2::<Vec<Value>, Vec<Value>>(&args, "List.zip", span)?;
+                let result: Vec<Value> = list1
+                    .into_iter()
+                    .zip(list2.into_iter())
+                    .map(|(a, b)| Value::Tuple(vec![a, b]))
+                    .collect();
+                Ok(EvalResult::Value(Value::List(result)))
+            }
+
+            BuiltinFn::ListFlatten => {
+                let list = Self::expect_arg_1::<Vec<Value>>(&args, "List.flatten", span)?;
+                let mut result = Vec::new();
+                for item in list {
+                    match item {
+                        Value::List(inner) => result.extend(inner),
+                        other => result.push(other),
+                    }
+                }
+                Ok(EvalResult::Value(Value::List(result)))
+            }
+
+            BuiltinFn::ListContains => {
+                let (list, target) = Self::expect_args_2::<Vec<Value>, Value>(&args, "List.contains", span)?;
+                let found = list.iter().any(|item| Value::values_equal(item, &target));
+                Ok(EvalResult::Value(Value::Bool(found)))
+            }
+
            BuiltinFn::ListTake => {
                let (list, n) = Self::expect_args_2::<Vec<Value>, i64>(&args, "List.take", span)?;
                let n = n.max(0) as usize;
@@ -2474,6 +2847,67 @@ impl Interpreter {
                Ok(EvalResult::Value(Value::Unit))
            }

+            BuiltinFn::ListSort => {
+                // List.sort(list) - sort using natural ordering (Int, Float, String, Bool)
+                let mut list =
+                    Self::expect_arg_1::<Vec<Value>>(&args, "List.sort", span)?;
+                list.sort_by(|a, b| Self::compare_values(a, b));
+                Ok(EvalResult::Value(Value::List(list)))
+            }
+
+            BuiltinFn::ListSortBy => {
+                // List.sortBy(list, fn(a, b) => Int) - sort with custom comparator
+                // Comparator returns negative (a < b), 0 (a == b), or positive (a > b)
+                let (list, func) =
+                    Self::expect_args_2::<Vec<Value>, Value>(&args, "List.sortBy", span)?;
+                let mut indexed: Vec<(usize, Value)> =
+                    list.into_iter().enumerate().collect();
+                let mut err: Option<RuntimeError> = None;
+                let func_ref = &func;
+                let self_ptr = self as *mut Self;
+                indexed.sort_by(|a, b| {
+                    if err.is_some() {
+                        return std::cmp::Ordering::Equal;
+                    }
+                    // Safety: we're in a single-threaded context and the closure
+                    // needs mutable access to call eval_call_to_value
+                    let interp = unsafe { &mut *self_ptr };
+                    match interp.eval_call_to_value(
+                        func_ref.clone(),
+                        vec![a.1.clone(), b.1.clone()],
+                        span,
+                    ) {
+                        Ok(Value::Int(n)) => {
+                            if n < 0 {
+                                std::cmp::Ordering::Less
+                            } else if n > 0 {
+                                std::cmp::Ordering::Greater
+                            } else {
+                                std::cmp::Ordering::Equal
+                            }
+                        }
+                        Ok(_) => {
+                            err = Some(RuntimeError {
+                                message: "List.sortBy comparator must return Int"
+                                    .to_string(),
+                                span: Some(span),
+                            });
+                            std::cmp::Ordering::Equal
+                        }
+                        Err(e) => {
+                            err = Some(e);
+                            std::cmp::Ordering::Equal
+                        }
+                    }
+                });
+                if let Some(e) = err {
+                    return Err(e);
+                }
+                let result: Vec<Value> =
+                    indexed.into_iter().map(|(_, v)| v).collect();
+                Ok(EvalResult::Value(Value::List(result)))
+            }
+
            // Additional String operations
            BuiltinFn::StringStartsWith => {
                let (s, prefix) = Self::expect_args_2::<String, String>(&args, "String.startsWith", span)?;
@@ -2884,6 +3318,128 @@ impl Interpreter {
                }
                Ok(EvalResult::Value(Value::Json(serde_json::Value::Object(map))))
            }
+
+            // Map operations
+            BuiltinFn::MapNew => {
+                Ok(EvalResult::Value(Value::Map(HashMap::new())))
+            }
+
+            BuiltinFn::MapSet => {
+                if args.len() != 3 {
+                    return Err(err("Map.set requires 3 arguments: map, key, value"));
+                }
+                let mut map = match &args[0] {
+                    Value::Map(m) => m.clone(),
+                    v => return Err(err(&format!("Map.set expects Map as first argument, got {}", v.type_name()))),
+                };
+                let key = match &args[1] {
+                    Value::String(s) => s.clone(),
+                    v => return Err(err(&format!("Map.set expects String key, got {}", v.type_name()))),
+                };
+                map.insert(key, args[2].clone());
+                Ok(EvalResult::Value(Value::Map(map)))
+            }
+
+            BuiltinFn::MapGet => {
+                let (map, key) = Self::expect_args_2::<HashMap<String, Value>, String>(&args, "Map.get", span)?;
+                match map.get(&key) {
+                    Some(v) => Ok(EvalResult::Value(Value::Constructor {
+                        name: "Some".to_string(),
+                        fields: vec![v.clone()],
+                    })),
+                    None => Ok(EvalResult::Value(Value::Constructor {
+                        name: "None".to_string(),
+                        fields: vec![],
+                    })),
+                }
+            }
+
+            BuiltinFn::MapContains => {
+                let (map, key) = Self::expect_args_2::<HashMap<String, Value>, String>(&args, "Map.contains", span)?;
+                Ok(EvalResult::Value(Value::Bool(map.contains_key(&key))))
+            }
+
+            BuiltinFn::MapRemove => {
+                let (mut map, key) = Self::expect_args_2::<HashMap<String, Value>, String>(&args, "Map.remove", span)?;
+                map.remove(&key);
+                Ok(EvalResult::Value(Value::Map(map)))
+            }
+
+            BuiltinFn::MapKeys => {
+                let map = Self::expect_arg_1::<HashMap<String, Value>>(&args, "Map.keys", span)?;
+                let mut keys: Vec<String> = map.keys().cloned().collect();
+                keys.sort();
+                Ok(EvalResult::Value(Value::List(
+                    keys.into_iter().map(Value::String).collect(),
+                )))
+            }
+
+            BuiltinFn::MapValues => {
+                let map = Self::expect_arg_1::<HashMap<String, Value>>(&args, "Map.values", span)?;
+                let mut entries: Vec<(String, Value)> = map.into_iter().collect();
+                entries.sort_by(|(a, _), (b, _)| a.cmp(b));
+                Ok(EvalResult::Value(Value::List(
+                    entries.into_iter().map(|(_, v)| v).collect(),
+                )))
+            }
+
+            BuiltinFn::MapSize => {
+                let map = Self::expect_arg_1::<HashMap<String, Value>>(&args, "Map.size", span)?;
+                Ok(EvalResult::Value(Value::Int(map.len() as i64)))
+            }
+
+            BuiltinFn::MapIsEmpty => {
+                let map = Self::expect_arg_1::<HashMap<String, Value>>(&args, "Map.isEmpty", span)?;
+                Ok(EvalResult::Value(Value::Bool(map.is_empty())))
+            }
+
+            BuiltinFn::MapFromList => {
+                let list = Self::expect_arg_1::<Vec<Value>>(&args, "Map.fromList", span)?;
+                let mut map = HashMap::new();
+                for item in list {
+                    match item {
+                        Value::Tuple(fields) if fields.len() == 2 => {
+                            let key = match &fields[0] {
+                                Value::String(s) => s.clone(),
+                                v => return Err(err(&format!("Map.fromList expects (String, V) tuples, got {} key", v.type_name()))),
+                            };
+                            map.insert(key, fields[1].clone());
+                        }
+                        _ => return Err(err("Map.fromList expects List<(String, V)>")),
+                    }
+                }
+                Ok(EvalResult::Value(Value::Map(map)))
+            }
+
+            BuiltinFn::MapToList => {
+                let map = Self::expect_arg_1::<HashMap<String, Value>>(&args, "Map.toList", span)?;
+                let mut entries: Vec<(String, Value)> = map.into_iter().collect();
+                entries.sort_by(|(a, _), (b, _)| a.cmp(b));
+                Ok(EvalResult::Value(Value::List(
+                    entries
+                        .into_iter()
+                        .map(|(k, v)| Value::Tuple(vec![Value::String(k), v]))
+                        .collect(),
+                )))
+            }
+
+            BuiltinFn::MapMerge => {
+                if args.len() != 2 {
+                    return Err(err("Map.merge requires 2 arguments: map1, map2"));
+                }
+                let mut map1 = match &args[0] {
+                    Value::Map(m) => m.clone(),
+                    v => return Err(err(&format!("Map.merge expects Map as first argument, got {}", v.type_name()))),
+                };
+                let map2 = match &args[1] {
+                    Value::Map(m) => m.clone(),
+                    v => return Err(err(&format!("Map.merge expects Map as second argument, got {}", v.type_name()))),
+                };
+                for (k, v) in map2 {
+                    map1.insert(k, v);
+                }
+                Ok(EvalResult::Value(Value::Map(map1)))
+            }
        }
    }

@@ -2967,6 +3523,18 @@ impl Interpreter {
        })
    }

+    /// Compare two values for natural ordering (used by List.sort)
+    fn compare_values(a: &Value, b: &Value) -> std::cmp::Ordering {
+        match (a, b) {
+            (Value::Int(x), Value::Int(y)) => x.cmp(y),
+            (Value::Float(x), Value::Float(y)) => x.partial_cmp(y).unwrap_or(std::cmp::Ordering::Equal),
+            (Value::String(x), Value::String(y)) => x.cmp(y),
+            (Value::Bool(x), Value::Bool(y)) => x.cmp(y),
+            (Value::Char(x), Value::Char(y)) => x.cmp(y),
+            _ => std::cmp::Ordering::Equal,
+        }
+    }
+
    fn match_pattern(&self, pattern: &Pattern, value: &Value) -> Option<Vec<(String, Value)>> {
        match pattern {
            Pattern::Wildcard(_) => Some(Vec::new()),
@@ -3049,6 +3617,11 @@ impl Interpreter {
                    b.get(k).map(|bv| self.values_equal(v, bv)).unwrap_or(false)
                })
            }
+            (Value::Map(a), Value::Map(b)) => {
+                a.len() == b.len() && a.iter().all(|(k, v)| {
+                    b.get(k).map(|bv| self.values_equal(v, bv)).unwrap_or(false)
+                })
+            }
            (
                Value::Constructor {
                    name: n1,
@@ -3469,6 +4042,119 @@ impl Interpreter {
                }
            }

+            ("File", "copy") => {
+                let source = match request.args.first() {
+                    Some(Value::String(s)) => s.clone(),
+                    _ => return Err(RuntimeError {
+                        message: "File.copy requires a string source path".to_string(),
+                        span: None,
+                    }),
+                };
+                let dest = match request.args.get(1) {
+                    Some(Value::String(s)) => s.clone(),
+                    _ => return Err(RuntimeError {
+                        message: "File.copy requires a string destination path".to_string(),
+                        span: None,
+                    }),
+                };
+                match std::fs::copy(&source, &dest) {
+                    Ok(_) => Ok(Value::Unit),
+                    Err(e) => Err(RuntimeError {
+                        message: format!("Failed to copy '{}' to '{}': {}", source, dest, e),
+                        span: None,
+                    }),
+                }
+            }
+
+            ("File", "glob") => {
+                let pattern = match request.args.first() {
+                    Some(Value::String(s)) => s.clone(),
+                    _ => return Err(RuntimeError {
+                        message: "File.glob requires a string pattern".to_string(),
+                        span: None,
+                    }),
+                };
+                match glob::glob(&pattern) {
+                    Ok(paths) => {
+                        let entries: Vec<Value> = paths
+                            .filter_map(|entry| entry.ok())
+                            .map(|path| Value::String(path.to_string_lossy().to_string()))
+                            .collect();
+                        Ok(Value::List(entries))
+                    }
+                    Err(e) => Err(RuntimeError {
+                        message: format!("Invalid glob pattern '{}': {}", pattern, e),
+                        span: None,
+                    }),
+                }
+            }
+
+            // ===== File Effect (safe Result-returning variants) =====
+            ("File", "tryRead") => {
+                let path = match request.args.first() {
+                    Some(Value::String(s)) => s.clone(),
+                    _ => return Err(RuntimeError {
+                        message: "File.tryRead requires a string path".to_string(),
+                        span: None,
+                    }),
+                };
+                match std::fs::read_to_string(&path) {
+                    Ok(content) => Ok(Value::Constructor {
+                        name: "Ok".to_string(),
+                        fields: vec![Value::String(content)],
+                    }),
+                    Err(e) => Ok(Value::Constructor {
+                        name: "Err".to_string(),
+                        fields: vec![Value::String(format!("Failed to read file '{}': {}", path, e))],
+                    }),
+                }
+            }
+            ("File", "tryWrite") => {
+                let path = match request.args.first() {
+                    Some(Value::String(s)) => s.clone(),
+                    _ => return Err(RuntimeError {
+                        message: "File.tryWrite requires a string path".to_string(),
+                        span: None,
+                    }),
+                };
+                let content = match request.args.get(1) {
+                    Some(Value::String(s)) => s.clone(),
+                    _ => return Err(RuntimeError {
+                        message: "File.tryWrite requires string content".to_string(),
+                        span: None,
+                    }),
+                };
+                match std::fs::write(&path, &content) {
+                    Ok(()) => Ok(Value::Constructor {
+                        name: "Ok".to_string(),
+                        fields: vec![Value::Unit],
+                    }),
+                    Err(e) => Ok(Value::Constructor {
+                        name: "Err".to_string(),
+                        fields: vec![Value::String(format!("Failed to write file '{}': {}", path, e))],
+                    }),
+                }
+            }
+            ("File", "tryDelete") => {
+                let path = match request.args.first() {
+                    Some(Value::String(s)) => s.clone(),
+                    _ => return Err(RuntimeError {
+                        message: "File.tryDelete requires a string path".to_string(),
+                        span: None,
+                    }),
+                };
+                match std::fs::remove_file(&path) {
+                    Ok(()) => Ok(Value::Constructor {
+                        name: "Ok".to_string(),
+                        fields: vec![Value::Unit],
+                    }),
+                    Err(e) => Ok(Value::Constructor {
+                        name: "Err".to_string(),
+                        fields: vec![Value::String(format!("Failed to delete file '{}': {}", path, e))],
+                    }),
+                }
+            }
+
            // ===== Process Effect =====
            ("Process", "exec") => {
                use std::process::Command;
@@ -3824,6 +4510,26 @@ impl Interpreter {
                }
                Ok(Value::Unit)
            }
+            ("Test", "assertEqualMsg") => {
+                let expected = request.args.first().cloned().unwrap_or(Value::Unit);
+                let actual = request.args.get(1).cloned().unwrap_or(Value::Unit);
+                let label = match request.args.get(2) {
+                    Some(Value::String(s)) => s.clone(),
+                    _ => "Values not equal".to_string(),
+                };
+
+                if Value::values_equal(&expected, &actual) {
+                    self.test_results.borrow_mut().passed += 1;
+                } else {
+                    self.test_results.borrow_mut().failed += 1;
+                    self.test_results.borrow_mut().failures.push(TestFailure {
+                        message: label,
+                        expected: Some(format!("{}", expected)),
+                        actual: Some(format!("{}", actual)),
+                    });
+                }
+                Ok(Value::Unit)
+            }
            ("Test", "assertNotEqual") => {
                let a = request.args.first().cloned().unwrap_or(Value::Unit);
                let b = request.args.get(1).cloned().unwrap_or(Value::Unit);
@@ -4956,6 +5662,7 @@ mod tests {
        // Create a simple migration that adds a field
        // Migration: old.name -> { name: old.name, email: "unknown" }
        let migration_body = Expr::Record {
+            spread: None,
            fields: vec![
                (
                    Ident::new("name", Span::default()),
--- a/src/lexer.rs
+++ b/src/lexer.rs
@@ -42,6 +42,7 @@ pub enum TokenKind {
    Effect,
    Handler,
    Run,
+    Handle,
    Resume,
    Type,
    True,
@@ -54,6 +55,7 @@ pub enum TokenKind {
    Trait,  // trait (for type classes)
    Impl,   // impl (for trait implementations)
    For,    // for (in impl Trait for Type)
+    Extern, // extern (for FFI declarations)

    // Documentation
    DocComment(String), // /// doc comment
@@ -70,6 +72,7 @@ pub enum TokenKind {

    // Operators
    Plus,       // +
+    PlusPlus,   // ++
    Minus,      // -
    Star,       // *
    Slash,      // /
@@ -89,6 +92,7 @@ pub enum TokenKind {
    Arrow,      // =>
    ThinArrow,  // ->
    Dot,        // .
+    DotDotDot,  // ...
    Colon,      // :
    ColonColon, // ::
    Comma,      // ,
@@ -138,6 +142,7 @@ impl fmt::Display for TokenKind {
            TokenKind::Effect => write!(f, "effect"),
            TokenKind::Handler => write!(f, "handler"),
            TokenKind::Run => write!(f, "run"),
+            TokenKind::Handle => write!(f, "handle"),
            TokenKind::Resume => write!(f, "resume"),
            TokenKind::Type => write!(f, "type"),
            TokenKind::Import => write!(f, "import"),
@@ -148,6 +153,7 @@ impl fmt::Display for TokenKind {
            TokenKind::Trait => write!(f, "trait"),
            TokenKind::Impl => write!(f, "impl"),
            TokenKind::For => write!(f, "for"),
+            TokenKind::Extern => write!(f, "extern"),
            TokenKind::DocComment(s) => write!(f, "/// {}", s),
            TokenKind::Is => write!(f, "is"),
            TokenKind::Pure => write!(f, "pure"),
@@ -160,6 +166,7 @@ impl fmt::Display for TokenKind {
            TokenKind::True => write!(f, "true"),
            TokenKind::False => write!(f, "false"),
            TokenKind::Plus => write!(f, "+"),
+            TokenKind::PlusPlus => write!(f, "++"),
            TokenKind::Minus => write!(f, "-"),
            TokenKind::Star => write!(f, "*"),
            TokenKind::Slash => write!(f, "/"),
@@ -179,6 +186,7 @@ impl fmt::Display for TokenKind {
            TokenKind::Arrow => write!(f, "=>"),
            TokenKind::ThinArrow => write!(f, "->"),
            TokenKind::Dot => write!(f, "."),
+            TokenKind::DotDotDot => write!(f, "..."),
            TokenKind::Colon => write!(f, ":"),
            TokenKind::ColonColon => write!(f, "::"),
            TokenKind::Comma => write!(f, ","),
@@ -268,7 +276,14 @@ impl<'a> Lexer<'a> {

        let kind = match c {
            // Single-character tokens
-            '+' => TokenKind::Plus,
+            '+' => {
+                if self.peek() == Some('+') {
+                    self.advance();
+                    TokenKind::PlusPlus
+                } else {
+                    TokenKind::Plus
+                }
+            }
            '*' => TokenKind::Star,
            '%' => TokenKind::Percent,
            '(' => TokenKind::LParen,
@@ -364,7 +379,22 @@ impl<'a> Lexer<'a> {
                    TokenKind::Pipe
                }
            }
-            '.' => TokenKind::Dot,
+            '.' => {
+                if self.peek() == Some('.') {
+                    // Check for ... (need to peek past second dot)
+                    // We look at source directly since we can only peek one ahead
+                    let next_next = self.source[self.pos..].chars().nth(1);
+                    if next_next == Some('.') {
+                        self.advance(); // consume second '.'
+                        self.advance(); // consume third '.'
+                        TokenKind::DotDotDot
+                    } else {
+                        TokenKind::Dot
+                    }
+                } else {
+                    TokenKind::Dot
+                }
+            }
            ':' => {
                if self.peek() == Some(':') {
                    self.advance();
@@ -383,7 +413,26 @@ impl<'a> Lexer<'a> {
            }

            // String literals
-            '"' => self.scan_string(start)?,
+            '"' => {
+                // Check for triple-quote multiline string """
+                if self.peek() == Some('"') {
+                    // Clone to peek at the second char
+                    let mut lookahead = self.chars.clone();
+                    lookahead.next(); // consume first peeked "
+                    if lookahead.peek() == Some(&'"') {
+                        // It's a triple-quote: consume both remaining quotes
+                        self.advance(); // second "
+                        self.advance(); // third "
+                        self.scan_multiline_string(start)?
+                    } else {
+                        // It's an empty string ""
+                        self.advance(); // consume closing "
+                        TokenKind::String(String::new())
+                    }
+                } else {
+                    self.scan_string(start)?
+                }
+            }

            // Char literals
            '\'' => self.scan_char(start)?,
@@ -493,6 +542,8 @@ impl<'a> Lexer<'a> {
                                Some('"') => '"',
                                Some('0') => '\0',
                                Some('\'') => '\'',
+                                Some('{') => '{',
+                                Some('}') => '}',
                                Some('x') => {
                                    // Hex escape \xNN
                                    let h1 = self.advance().and_then(|c| c.to_digit(16));
@@ -639,6 +690,211 @@ impl<'a> Lexer<'a> {
        Ok(TokenKind::InterpolatedString(parts))
    }

+    fn scan_multiline_string(&mut self, _start: usize) -> Result<TokenKind, LexError> {
+        let mut parts: Vec<StringPart> = Vec::new();
+        let mut current_literal = String::new();
+
+        // Skip the first newline after opening """ if present
+        if self.peek() == Some('\n') {
+            self.advance();
+        } else if self.peek() == Some('\r') {
+            self.advance();
+            if self.peek() == Some('\n') {
+                self.advance();
+            }
+        }
+
+        loop {
+            match self.advance() {
+                Some('"') => {
+                    // Check for closing """
+                    if self.peek() == Some('"') {
+                        let mut lookahead = self.chars.clone();
+                        lookahead.next(); // consume first peeked "
+                        if lookahead.peek() == Some(&'"') {
+                            // Closing """ found
+                            self.advance(); // second "
+                            self.advance(); // third "
+                            break;
+                        }
+                    }
+                    // Not closing triple-quote, just a regular " in the string
+                    current_literal.push('"');
+                }
+                Some('\\') => {
+                    // Handle escape sequences (same as regular strings)
+                    match self.peek() {
+                        Some('{') => {
+                            self.advance();
+                            current_literal.push('{');
+                        }
+                        Some('}') => {
+                            self.advance();
+                            current_literal.push('}');
+                        }
+                        _ => {
+                            let escape_start = self.pos;
+                            let escaped = match self.advance() {
+                                Some('n') => '\n',
+                                Some('r') => '\r',
+                                Some('t') => '\t',
+                                Some('\\') => '\\',
+                                Some('"') => '"',
+                                Some('0') => '\0',
+                                Some('\'') => '\'',
+                                Some(c) => {
+                                    return Err(LexError {
+                                        message: format!("Invalid escape sequence: \\{}", c),
+                                        span: Span::new(escape_start - 1, self.pos),
+                                    });
+                                }
+                                None => {
+                                    return Err(LexError {
+                                        message: "Unterminated multiline string".into(),
+                                        span: Span::new(_start, self.pos),
+                                    });
+                                }
+                            };
+                            current_literal.push(escaped);
+                        }
+                    }
+                }
+                Some('{') => {
+                    // Interpolation (same as regular strings)
+                    if !current_literal.is_empty() {
+                        parts.push(StringPart::Literal(std::mem::take(&mut current_literal)));
+                    }
+
+                    let mut expr_text = String::new();
+                    let mut brace_depth = 1;
+
+                    loop {
+                        match self.advance() {
+                            Some('{') => {
+                                brace_depth += 1;
+                                expr_text.push('{');
+                            }
+                            Some('}') => {
+                                brace_depth -= 1;
+                                if brace_depth == 0 {
+                                    break;
+                                }
+                                expr_text.push('}');
+                            }
+                            Some(c) => expr_text.push(c),
+                            None => {
+                                return Err(LexError {
+                                    message: "Unterminated interpolation in multiline string"
+                                        .into(),
+                                    span: Span::new(_start, self.pos),
+                                });
+                            }
+                        }
+                    }
+
+                    parts.push(StringPart::Expr(expr_text));
+                }
+                Some(c) => current_literal.push(c),
+                None => {
+                    return Err(LexError {
+                        message: "Unterminated multiline string".into(),
+                        span: Span::new(_start, self.pos),
+                    });
+                }
+            }
+        }
+
+        // Strip common leading whitespace from all lines
+        let strip_indent = |s: &str| -> String {
+            if s.is_empty() {
+                return String::new();
+            }
+            let lines: Vec<&str> = s.split('\n').collect();
+            // Find minimum indentation of non-empty lines
+            let min_indent = lines
+                .iter()
+                .filter(|line| !line.trim().is_empty())
+                .map(|line| line.len() - line.trim_start().len())
+                .min()
+                .unwrap_or(0);
+            // Strip that indentation from each line
+            lines
+                .iter()
+                .map(|line| {
+                    if line.len() >= min_indent {
+                        &line[min_indent..]
+                    } else {
+                        line.trim_start()
+                    }
+                })
+                .collect::<Vec<_>>()
+                .join("\n")
+        };
+
+        // Strip trailing whitespace-only line before closing """
+        let trim_trailing = |s: &mut String| {
+            // Remove trailing spaces/tabs (indent before closing """)
+            while s.ends_with(' ') || s.ends_with('\t') {
+                s.pop();
+            }
+            // Remove the trailing newline
+            if s.ends_with('\n') {
+                s.pop();
+                if s.ends_with('\r') {
+                    s.pop();
+                }
+            }
+        };
+
+        if parts.is_empty() {
+            trim_trailing(&mut current_literal);
+            let result = strip_indent(&current_literal);
+            return Ok(TokenKind::String(result));
+        }
+
+        // Add remaining literal
+        if !current_literal.is_empty() {
+            trim_trailing(&mut current_literal);
+            parts.push(StringPart::Literal(current_literal));
+        }
+
+        // For interpolated multiline strings, strip indent from literal parts
+        // First, collect all literal content to find min indent
+        let mut all_text = String::new();
+        for part in &parts {
+            if let StringPart::Literal(lit) = part {
+                all_text.push_str(lit);
+            }
+        }
+        let lines: Vec<&str> = all_text.split('\n').collect();
+        let min_indent = lines
+            .iter()
+            .filter(|line| !line.trim().is_empty())
+            .map(|line| line.len() - line.trim_start().len())
+            .min()
+            .unwrap_or(0);
+
+        if min_indent > 0 {
+            for part in &mut parts {
+                if let StringPart::Literal(lit) = part {
+                    let stripped_lines: Vec<&str> = lit
+                        .split('\n')
+                        .map(|line| {
+                            if line.len() >= min_indent {
+                                &line[min_indent..]
+                            } else {
+                                line.trim_start()
+                            }
+                        })
+                        .collect();
+                    *lit = stripped_lines.join("\n");
+                }
+            }
+        }
+
+        Ok(TokenKind::InterpolatedString(parts))
+    }
+
    fn scan_char(&mut self, start: usize) -> Result<TokenKind, LexError> {
        let c = match self.advance() {
            Some('\\') => match self.advance() {
@@ -743,6 +999,7 @@ impl<'a> Lexer<'a> {
            "effect" => TokenKind::Effect,
            "handler" => TokenKind::Handler,
            "run" => TokenKind::Run,
+            "handle" => TokenKind::Handle,
            "resume" => TokenKind::Resume,
            "type" => TokenKind::Type,
            "import" => TokenKind::Import,
@@ -753,6 +1010,7 @@ impl<'a> Lexer<'a> {
            "trait" => TokenKind::Trait,
            "impl" => TokenKind::Impl,
            "for" => TokenKind::For,
+            "extern" => TokenKind::Extern,
            "is" => TokenKind::Is,
            "pure" => TokenKind::Pure,
            "total" => TokenKind::Total,
@@ -761,6 +1019,8 @@ impl<'a> Lexer<'a> {
            "commutative" => TokenKind::Commutative,
            "where" => TokenKind::Where,
            "assume" => TokenKind::Assume,
+            "and" => TokenKind::And,
+            "or" => TokenKind::Or,
            "true" => TokenKind::Bool(true),
            "false" => TokenKind::Bool(false),
            _ => TokenKind::Ident(ident.to_string()),
--- a/src/linter.rs
+++ b/src/linter.rs
@@ -403,6 +403,12 @@ impl Linter {
                Declaration::Function(f) => {
                    self.defined_functions.insert(f.name.name.clone());
                }
+                Declaration::ExternFn(e) => {
+                    self.defined_functions.insert(e.name.name.clone());
+                }
+                Declaration::ExternLet(e) => {
+                    self.define_var(&e.name.name);
+                }
                Declaration::Let(l) => {
                    self.define_var(&l.name.name);
                }
@@ -510,10 +516,13 @@ impl Linter {
                    self.collect_refs_expr(&arm.body);
                }
            }
-            Expr::Field { object, .. } => {
+            Expr::Field { object, .. } | Expr::TupleIndex { object, .. } => {
                self.collect_refs_expr(object);
            }
-            Expr::Record { fields, .. } => {
+            Expr::Record { spread, fields, .. } => {
+                if let Some(spread_expr) = spread {
+                    self.collect_refs_expr(spread_expr);
+                }
                for (_, val) in fields {
                    self.collect_refs_expr(val);
                }
--- a/src/lsp.rs
+++ b/src/lsp.rs
@@ -317,10 +317,71 @@ impl LspServer {
        let doc = self.documents.get(&uri)?;
        let source = &doc.text;

-        // Try to get info from symbol table first
+        // Try to get info from symbol table first (position-based lookup)
        if let Some(ref table) = doc.symbol_table {
            let offset = self.position_to_offset(source, position);
            if let Some(symbol) = table.definition_at_position(offset) {
+                return Some(self.format_symbol_hover(symbol));
+            }
+        }
+
+        // Get the word under cursor
+        let word = self.get_word_at_position(source, position)?;
+
+        // When hovering on a keyword like 'fn', 'type', 'effect', 'let', 'trait',
+        // look ahead to find the declaration name and show that symbol's info
+        if let Some(ref table) = doc.symbol_table {
+            if matches!(word.as_str(), "fn" | "type" | "effect" | "let" | "trait" | "handler" | "impl") {
+                let offset = self.position_to_offset(source, position);
+                if let Some(name) = self.find_next_ident(source, offset + word.len()) {
+                    for sym in table.global_symbols() {
+                        if sym.name == name {
+                            return Some(self.format_symbol_hover(sym));
+                        }
+                    }
+                }
+            }
+
+            // Try name-based lookup in symbol table (for usage sites)
+            for sym in table.global_symbols() {
+                if sym.name == word {
+                    return Some(self.format_symbol_hover(sym));
+                }
+            }
+        }
+
+        // Check for module names (Console, List, String, etc.)
+        if let Some(hover) = self.get_module_hover(&word) {
+            return Some(hover);
+        }
+
+        // Rich documentation for behavioral property keywords
+        if let Some((signature, doc_text)) = self.get_rich_symbol_info(&word) {
+            return Some(Hover {
+                contents: HoverContents::Markup(MarkupContent {
+                    kind: MarkupKind::Markdown,
+                    value: format!("```lux\n{}\n```\n\n{}", signature, doc_text),
+                }),
+                range: None,
+            });
+        }
+
+        // Builtin keyword/function info
+        if let Some((signature, doc_text)) = self.get_symbol_info(&word) {
+            return Some(Hover {
+                contents: HoverContents::Markup(MarkupContent {
+                    kind: MarkupKind::Markdown,
+                    value: format!("```lux\n{}\n```\n\n{}", signature, doc_text),
+                }),
+                range: None,
+            });
+        }
+
+        None
+    }
+
+    /// Format a symbol into a hover response
+    fn format_symbol_hover(&self, symbol: &crate::symbol_table::Symbol) -> Hover {
        let signature = symbol.type_signature.as_ref()
            .map(|s| s.as_str())
            .unwrap_or(&symbol.name);
@@ -339,44 +400,144 @@ impl LspServer {
        let doc_str = symbol.documentation.as_ref()
            .map(|d| format!("\n\n{}", d))
            .unwrap_or_default();
-
-                // Format signature: wrap long signatures onto multiple lines
        let formatted_sig = format_signature_for_hover(signature);
-
-                // Add behavioral property documentation if present
        let property_docs = extract_property_docs(signature);

-                return Some(Hover {
+        Hover {
            contents: HoverContents::Markup(MarkupContent {
                kind: MarkupKind::Markdown,
-                        value: format!("```lux\n{}\n```\n\n*{}*{}{}", formatted_sig, kind_str, property_docs, doc_str),
+                value: format!(
+                    "```lux\n{}\n```\n*{}*{}{}",
+                    formatted_sig, kind_str, property_docs, doc_str
+                ),
            }),
            range: None,
-                });
        }
    }

-        // Fall back to hardcoded info
+    /// Get hover info for built-in module names
+    fn get_module_hover(&self, name: &str) -> Option<Hover> {
+        let (sig, doc) = match name {
+            "Console" => (
+                "effect Console",
+                "**Console I/O**\n\n\
+                 - `Console.print(msg: String): Unit` — print to stdout\n\
+                 - `Console.readLine(): String` — read a line from stdin\n\
+                 - `Console.readInt(): Int` — read an integer from stdin",
+            ),
+            "File" => (
+                "effect File",
+                "**File System**\n\n\
+                 - `File.read(path: String): String` — read file contents\n\
+                 - `File.write(path: String, content: String): Unit` — write to file\n\
+                 - `File.append(path: String, content: String): Unit` — append to file\n\
+                 - `File.exists(path: String): Bool` — check if file exists\n\
+                 - `File.delete(path: String): Unit` — delete a file\n\
+                 - `File.list(path: String): List<String>` — list directory",
+            ),
+            "Http" => (
+                "effect Http",
+                "**HTTP Client**\n\n\
+                 - `Http.get(url: String): String` — GET request\n\
+                 - `Http.post(url: String, body: String): String` — POST request\n\
+                 - `Http.put(url: String, body: String): String` — PUT request\n\
+                 - `Http.delete(url: String): String` — DELETE request",
+            ),
+            "Sql" => (
+                "effect Sql",
+                "**SQL Database**\n\n\
+                 - `Sql.open(path: String): Connection` — open database\n\
+                 - `Sql.execute(conn: Connection, sql: String): Unit` — execute SQL\n\
+                 - `Sql.query(conn: Connection, sql: String): List<Row>` — query rows\n\
+                 - `Sql.close(conn: Connection): Unit` — close connection",
+            ),
+            "Random" => (
+                "effect Random",
+                "**Random Number Generation**\n\n\
+                 - `Random.int(min: Int, max: Int): Int` — random integer\n\
+                 - `Random.float(): Float` — random float 0.0–1.0\n\
+                 - `Random.bool(): Bool` — random boolean",
+            ),
+            "Time" => (
+                "effect Time",
+                "**Time**\n\n\
+                 - `Time.now(): Int` — current Unix timestamp (ms)\n\
+                 - `Time.sleep(ms: Int): Unit` — sleep for milliseconds",
+            ),
+            "Process" => (
+                "effect Process",
+                "**Process / System**\n\n\
+                 - `Process.exec(cmd: String): String` — run shell command\n\
+                 - `Process.env(name: String): String` — get env variable\n\
+                 - `Process.args(): List<String>` — command-line arguments\n\
+                 - `Process.exit(code: Int): Unit` — exit with code",
+            ),
+            "Math" => (
+                "module Math",
+                "**Math Functions**\n\n\
+                 - `Math.abs(n: Int): Int` — absolute value\n\
+                 - `Math.min(a: Int, b: Int): Int` — minimum\n\
+                 - `Math.max(a: Int, b: Int): Int` — maximum\n\
+                 - `Math.sqrt(n: Float): Float` — square root\n\
+                 - `Math.pow(base: Float, exp: Float): Float` — power\n\
+                 - `Math.floor(n: Float): Int` — round down\n\
+                 - `Math.ceil(n: Float): Int` — round up",
+            ),
+            "List" => (
+                "module List",
+                "**List Operations**\n\n\
+                 - `List.map(list, f)` — transform each element\n\
+                 - `List.filter(list, p)` — keep matching elements\n\
+                 - `List.fold(list, init, f)` — reduce to single value\n\
+                 - `List.head(list)` — first element (Option)\n\
+                 - `List.tail(list)` — all except first (Option)\n\
+                 - `List.length(list)` — number of elements\n\
+                 - `List.concat(a, b)` — concatenate lists\n\
+                 - `List.range(start, end)` — integer range\n\
+                 - `List.reverse(list)` — reverse order\n\
+                 - `List.get(list, i)` — element at index (Option)",
+            ),
+            "String" => (
+                "module String",
+                "**String Operations**\n\n\
+                 - `String.length(s)` — string length\n\
+                 - `String.split(s, delim)` — split by delimiter\n\
+                 - `String.join(list, delim)` — join with delimiter\n\
+                 - `String.trim(s)` — trim whitespace\n\
+                 - `String.contains(s, sub)` — check substring\n\
+                 - `String.replace(s, from, to)` — replace occurrences\n\
+                 - `String.startsWith(s, prefix)` — check prefix\n\
+                 - `String.endsWith(s, suffix)` — check suffix\n\
+                 - `String.substring(s, start, end)` — extract range\n\
+                 - `String.chars(s)` — list of characters",
+            ),
+            "Option" => (
+                "type Option<A> = Some(A) | None",
+                "**Optional Value**\n\n\
+                 - `Option.isSome(opt)` — has a value?\n\
+                 - `Option.isNone(opt)` — is empty?\n\
+                 - `Option.getOrElse(opt, default)` — unwrap or default\n\
+                 - `Option.map(opt, f)` — transform if present\n\
+                 - `Option.flatMap(opt, f)` — chain operations",
+            ),
+            "Result" => (
+                "type Result<A, E> = Ok(A) | Err(E)",
+                "**Result of Fallible Operation**\n\n\
+                 - `Result.isOk(r)` — succeeded?\n\
+                 - `Result.isErr(r)` — failed?\n\
+                 - `Result.map(r, f)` — transform success value\n\
+                 - `Result.mapErr(r, f)` — transform error value",
+            ),
+            _ => return None,
+        };

-        // Extract the word at the cursor position
-        let word = self.get_word_at_position(source, position)?;
-
-        // Look up rich documentation for known symbols
-        let info = self.get_rich_symbol_info(&word)
-            .or_else(|| self.get_symbol_info(&word).map(|(s, d)| (s.to_string(), d.to_string())));
-
-        if let Some((signature, doc)) = info {
-            let formatted_sig = format_signature_for_hover(&signature);
        Some(Hover {
            contents: HoverContents::Markup(MarkupContent {
                kind: MarkupKind::Markdown,
-                    value: format!("```lux\n{}\n```\n\n{}", formatted_sig, doc),
+                value: format!("```lux\n{}\n```\n{}", sig, doc),
            }),
            range: None,
        })
-        } else {
-            None
-        }
    }

    fn get_word_at_position(&self, source: &str, position: Position) -> Option<String> {
@@ -402,6 +563,26 @@ impl LspServer {
        }
    }

+    /// Find the next identifier in source after the given offset (skipping whitespace)
+    fn find_next_ident(&self, source: &str, start: usize) -> Option<String> {
+        let chars: Vec<char> = source.chars().collect();
+        let mut pos = start;
+        // Skip whitespace
+        while pos < chars.len() && (chars[pos] == ' ' || chars[pos] == '\t' || chars[pos] == '\n' || chars[pos] == '\r') {
+            pos += 1;
+        }
+        // Collect identifier
+        let ident_start = pos;
+        while pos < chars.len() && (chars[pos].is_alphanumeric() || chars[pos] == '_') {
+            pos += 1;
+        }
+        if pos > ident_start {
+            Some(chars[ident_start..pos].iter().collect())
+        } else {
+            None
+        }
+    }
+
    fn get_symbol_info(&self, word: &str) -> Option<(&'static str, &'static str)> {
        match word {
            // Keywords
@@ -607,17 +788,11 @@ impl LspServer {

    fn position_to_offset(&self, source: &str, position: Position) -> usize {
        let mut offset = 0;
-        let mut line = 0u32;
-
-        for (i, c) in source.char_indices() {
-            if line == position.line {
-                let col = i - offset;
-                return offset + (position.character as usize).min(col + 1);
-            }
-            if c == '\n' {
-                line += 1;
-                offset = i + 1;
+        for (line_idx, line) in source.lines().enumerate() {
+            if line_idx == position.line as usize {
+                return offset + (position.character as usize).min(line.len());
            }
+            offset += line.len() + 1; // +1 for newline
        }
        source.len()
    }
@@ -1396,12 +1571,15 @@ fn collect_call_site_hints(
                collect_call_site_hints(source, e, param_names, hints);
            }
        }
-        Expr::Record { fields, .. } => {
+        Expr::Record { spread, fields, .. } => {
+            if let Some(spread_expr) = spread {
+                collect_call_site_hints(source, spread_expr, param_names, hints);
+            }
            for (_, e) in fields {
                collect_call_site_hints(source, e, param_names, hints);
            }
        }
-        Expr::Field { object, .. } => {
+        Expr::Field { object, .. } | Expr::TupleIndex { object, .. } => {
            collect_call_site_hints(source, object, param_names, hints);
        }
        Expr::Run { expr, handlers, .. } => {
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,4 +1,7 @@
-//! Lux - A functional programming language with first-class effects
+//! Lux — Make the important things visible.
+//!
+//! A functional programming language with first-class effects, schema evolution,
+//! and behavioral types. See `lux philosophy` or docs/PHILOSOPHY.md.

 mod analysis;
 mod ast;
@@ -34,7 +37,7 @@ use std::borrow::Cow;
 use std::collections::HashSet;
 use typechecker::TypeChecker;

-const VERSION: &str = "0.1.0";
+const VERSION: &str = env!("CARGO_PKG_VERSION");

 const HELP: &str = r#"
 Lux - A functional language with first-class effects
@@ -171,9 +174,14 @@ fn main() {
                    .and_then(|s| s.parse::<u16>().ok())
                    .unwrap_or(8080);

-                let dir = args.get(2)
-                    .filter(|a| !a.starts_with('-'))
-                    .map(|s| s.as_str())
+                let port_value_idx = args.iter()
+                    .position(|a| a == "--port" || a == "-p")
+                    .map(|i| i + 1);
+                let dir = args.iter().enumerate()
+                    .skip(2)
+                    .filter(|(i, a)| !a.starts_with('-') && Some(*i) != port_value_idx)
+                    .map(|(_, a)| a.as_str())
+                    .next()
                    .unwrap_or(".");

                serve_static_files(dir, port);
@@ -185,10 +193,12 @@ fn main() {
                    eprintln!("       lux compile <file.lux> --run");
                    eprintln!("       lux compile <file.lux> --emit-c [-o file.c]");
                    eprintln!("       lux compile <file.lux> --target js [-o file.js]");
+                    eprintln!("       lux compile <file.lux> --watch");
                    std::process::exit(1);
                }
                let run_after = args.iter().any(|a| a == "--run");
                let emit_c = args.iter().any(|a| a == "--emit-c");
+                let watch = args.iter().any(|a| a == "--watch");
                let target_js = args.iter()
                    .position(|a| a == "--target")
                    .and_then(|i| args.get(i + 1))
@@ -204,17 +214,34 @@ fn main() {
                } else {
                    compile_to_c(&args[2], output_path, run_after, emit_c);
                }
+
+                if watch {
+                    // Build the args to replay for each recompilation (without --watch)
+                    let compile_args: Vec<String> = args.iter()
+                        .skip(1)
+                        .filter(|a| a.as_str() != "--watch")
+                        .cloned()
+                        .collect();
+                    watch_and_rerun(&args[2], &compile_args);
+                }
+            }
+            "repl" => {
+                // Start REPL
+                run_repl();
            }
            "doc" => {
                // Generate API documentation
                generate_docs(&args[2..]);
            }
+            "philosophy" => {
+                print_philosophy();
+            }
            cmd => {
                // Check if it looks like a command typo
                if !std::path::Path::new(cmd).exists() && !cmd.starts_with('-') && !cmd.contains('.') && !cmd.contains('/') {
                    let known_commands = vec![
                        "fmt", "lint", "test", "watch", "init", "check", "debug",
-                        "pkg", "registry", "serve", "compile", "doc",
+                        "pkg", "registry", "serve", "compile", "doc", "repl", "philosophy",
                    ];
                    let suggestions = diagnostics::find_similar_names(cmd, known_commands.into_iter(), 2);
                    if !suggestions.is_empty() {
@@ -229,18 +256,24 @@ fn main() {
            }
        }
    } else {
-        // Start REPL
-        run_repl();
+        // No arguments — show help
+        print_help();
    }
 }

 fn print_help() {
    println!("{}", bc(colors::GREEN, &format!("Lux {}", VERSION)));
-    println!("{}", c(colors::DIM, "A functional language with first-class effects"));
+    println!("{}", c(colors::DIM, "Make the important things visible."));
+    println!();
+    println!("  {} Effects in types — see what code does", c(colors::DIM, "·"));
+    println!("  {} Composition over configuration — no DI frameworks", c(colors::DIM, "·"));
+    println!("  {} Safety without ceremony — inference where it helps", c(colors::DIM, "·"));
+    println!("  {} One right way — opinionated formatter, integrated tools", c(colors::DIM, "·"));
    println!();
    println!("{}", bc("", "Usage:"));
    println!();
-    println!("  {}                        Start the REPL", bc(colors::CYAN, "lux"));
+    println!("  {}                        Show this help", bc(colors::CYAN, "lux"));
+    println!("  {}                   Start the REPL", bc(colors::CYAN, "lux repl"));
    println!("  {} {}             Run a file (interpreter)", bc(colors::CYAN, "lux"), c(colors::YELLOW, "<file.lux>"));
    println!("  {} {} {}   Compile to native binary", bc(colors::CYAN, "lux"), bc(colors::CYAN, "compile"), c(colors::YELLOW, "<file.lux>"));
    println!("  {} {} {} {}   Compile with output name", bc(colors::CYAN, "lux"), bc(colors::CYAN, "compile"), c(colors::YELLOW, "<f>"), c(colors::YELLOW, "-o app"));
@@ -275,6 +308,8 @@ fn print_help() {
        c(colors::DIM, "(alias: s)"));
    println!("  {} {} {}  Generate API documentation",
        bc(colors::CYAN, "lux"), bc(colors::CYAN, "doc"), c(colors::YELLOW, "[file] [-o dir]"));
+    println!("  {} {}           Show language philosophy",
+        bc(colors::CYAN, "lux"), bc(colors::CYAN, "philosophy"));
    println!("  {} {}                Start LSP server",
        bc(colors::CYAN, "lux"), c(colors::YELLOW, "--lsp"));
    println!("  {} {}               Show this help",
@@ -283,6 +318,36 @@ fn print_help() {
        bc(colors::CYAN, "lux"), c(colors::YELLOW, "--version"));
 }

+fn print_philosophy() {
+    println!("{}", bc(colors::GREEN, &format!("The Lux Philosophy")));
+    println!();
+    println!("  {}", bc("", "Make the important things visible."));
+    println!();
+    println!("  Most languages hide what matters most in production: what code");
+    println!("  can do, how data changes over time, and what guarantees functions");
+    println!("  provide. Lux makes all three first-class, compiler-checked features.");
+    println!();
+    println!("  {} {}", bc(colors::CYAN, "1. Explicit over implicit"), c(colors::DIM, "— effects in types, not hidden behind interfaces"));
+    println!("     fn processOrder(order: Order): Receipt {} {}", c(colors::YELLOW, "with {Database, Email}"), c(colors::DIM, "// signature IS documentation"));
+    println!();
+    println!("  {} {}", bc(colors::CYAN, "2. Composition over configuration"), c(colors::DIM, "— no DI frameworks, no monad transformers"));
+    println!("     run app() {} {}", c(colors::YELLOW, "with { Database = mock, Http = mock }"), c(colors::DIM, "// swap handlers, not libraries"));
+    println!();
+    println!("  {} {}", bc(colors::CYAN, "3. Safety without ceremony"), c(colors::DIM, "— type inference where it helps, annotations where they document"));
+    println!("     let x = 42                {}", c(colors::DIM, "// inferred"));
+    println!("     fn f(x: Int): Int = x * 2 {}", c(colors::DIM, "// annotated: API contract"));
+    println!();
+    println!("  {} {}", bc(colors::CYAN, "4. Practical over academic"), c(colors::DIM, "— ML semantics in C-family syntax, no monads to learn"));
+    println!("     {} {} {}", c(colors::DIM, "fn main(): Unit"), c(colors::YELLOW, "with {Console}"), c(colors::DIM, "= Console.print(\"Hello!\")"));
+    println!();
+    println!("  {} {}", bc(colors::CYAN, "5. One right way"), c(colors::DIM, "— opinionated formatter, integrated tooling, built-in testing"));
+    println!("     lux fmt | lux lint | lux check | lux test | lux compile");
+    println!();
+    println!("  {} {}", bc(colors::CYAN, "6. Tools are the language"), c(colors::DIM, "— formatter knows the AST, linter knows the types, LSP knows the effects"));
+    println!();
+    println!("  See {} for the full philosophy with language comparisons.", c(colors::CYAN, "docs/PHILOSOPHY.md"));
+}
+
 fn format_files(args: &[String]) {
    use formatter::{format, FormatConfig};
    use std::path::Path;
@@ -721,6 +786,36 @@ fn collect_lux_files_nonrecursive(dir: &str, pattern: Option<&str>, files: &mut
    }
 }

+/// Find a C compiler. Priority: $CC env var, build-time embedded path, PATH search.
+fn find_c_compiler() -> String {
+    // 1. Explicit env var
+    if let Ok(cc) = std::env::var("CC") {
+        if !cc.is_empty() {
+            return cc;
+        }
+    }
+    // 2. Path captured at build time (e.g. absolute nix store path)
+    let built_in = env!("LUX_CC_PATH");
+    if !built_in.is_empty() && std::path::Path::new(built_in).exists() {
+        return built_in.to_string();
+    }
+    // 3. Search PATH
+    for name in &["cc", "gcc", "clang"] {
+        if let Ok(output) = std::process::Command::new("which").arg(name).output() {
+            if output.status.success() {
+                if let Ok(p) = String::from_utf8(output.stdout) {
+                    let p = p.trim();
+                    if !p.is_empty() {
+                        return p.to_string();
+                    }
+                }
+            }
+        }
+    }
+    // 4. Last resort
+    "cc".to_string()
+}
+
 fn compile_to_c(path: &str, output_path: Option<&str>, run_after: bool, emit_c: bool) {
    use codegen::c_backend::CBackend;
    use modules::ModuleLoader;
@@ -764,7 +859,7 @@ fn compile_to_c(path: &str, output_path: Option<&str>, run_after: bool, emit_c:

    // Generate C code
    let mut backend = CBackend::new();
-    let c_code = match backend.generate(&program) {
+    let c_code = match backend.generate(&program, loader.module_cache()) {
        Ok(code) => code,
        Err(e) => {
            eprintln!("{} C codegen: {}", c(colors::RED, "error:"), e);
@@ -812,13 +907,14 @@ fn compile_to_c(path: &str, output_path: Option<&str>, run_after: bool, emit_c:
        std::process::exit(1);
    }

-    // Find C compiler
-    let cc = std::env::var("CC").unwrap_or_else(|_| "cc".to_string());
+    // Find C compiler: $CC env var > embedded build-time path > PATH search
+    let cc = find_c_compiler();

    let compile_result = Command::new(&cc)
        .args(["-O2", "-o"])
        .arg(&output_bin)
        .arg(&temp_c)
+        .arg("-lm")
        .output();

    match compile_result {
@@ -1002,7 +1098,7 @@ fn run_tests(args: &[String]) {
    for test_file in &test_files {
        let path_str = test_file.to_string_lossy().to_string();

-        // Read and parse the file
+        // Read and parse the file (with module loading)
        let source = match fs::read_to_string(test_file) {
            Ok(s) => s,
            Err(e) => {
@@ -1012,7 +1108,13 @@ fn run_tests(args: &[String]) {
            }
        };

-        let program = match Parser::parse_source(&source) {
+        use modules::ModuleLoader;
+        let mut loader = ModuleLoader::new();
+        if let Some(parent) = test_file.parent() {
+            loader.add_search_path(parent.to_path_buf());
+        }
+
+        let program = match loader.load_source(&source, Some(test_file.as_path())) {
            Ok(p) => p,
            Err(e) => {
                println!("  {} {} {}", c(colors::RED, "\u{2717}"), path_str, c(colors::RED, &format!("parse error: {}", e)));
@@ -1021,9 +1123,9 @@ fn run_tests(args: &[String]) {
            }
        };

-        // Type check
+        // Type check with module support
        let mut checker = typechecker::TypeChecker::new();
-        if let Err(errors) = checker.check_program(&program) {
+        if let Err(errors) = checker.check_program_with_modules(&program, &loader) {
            println!("  {} {} {}", c(colors::RED, "\u{2717}"), path_str, c(colors::RED, "type error"));
            for err in errors {
                eprintln!("    {}", err);
@@ -1051,7 +1153,7 @@ fn run_tests(args: &[String]) {
            interp.register_auto_migrations(&auto_migrations);
            interp.reset_test_results();

-            match interp.run(&program) {
+            match interp.run_with_modules(&program, &loader) {
                Ok(_) => {
                    let results = interp.get_test_results();
                    if results.failed == 0 && results.passed == 0 {
@@ -1085,8 +1187,8 @@ fn run_tests(args: &[String]) {
                interp.register_auto_migrations(&auto_migrations);
                interp.reset_test_results();

-                // First run the file to define all functions
-                if let Err(e) = interp.run(&program) {
+                // First run the file to define all functions and load imports
+                if let Err(e) = interp.run_with_modules(&program, &loader) {
                    println!("    {} {} {}", c(colors::RED, "\u{2717}"), test_name, c(colors::RED, &e.to_string()));
                    total_failed += 1;
                    continue;
@@ -1261,6 +1363,64 @@ fn watch_file(path: &str) {
    }
 }

+fn watch_and_rerun(path: &str, compile_args: &[String]) {
+    use std::time::{Duration, SystemTime};
+    use std::path::Path;
+
+    let file_path = Path::new(path);
+    if !file_path.exists() {
+        eprintln!("File not found: {}", path);
+        std::process::exit(1);
+    }
+
+    println!();
+    println!("Watching {} for changes (Ctrl+C to stop)...", path);
+
+    let mut last_modified = std::fs::metadata(file_path)
+        .and_then(|m| m.modified())
+        .unwrap_or(SystemTime::UNIX_EPOCH);
+
+    loop {
+        std::thread::sleep(Duration::from_millis(500));
+
+        let modified = match std::fs::metadata(file_path).and_then(|m| m.modified()) {
+            Ok(m) => m,
+            Err(_) => continue,
+        };
+
+        if modified > last_modified {
+            last_modified = modified;
+
+            // Clear screen
+            print!("\x1B[2J\x1B[H");
+
+            println!("=== Compiling {} ===", path);
+            println!();
+
+            let result = std::process::Command::new(std::env::current_exe().unwrap())
+                .args(compile_args)
+                .status();
+
+            match result {
+                Ok(status) if status.success() => {
+                    println!();
+                    println!("=== Success ===");
+                }
+                Ok(_) => {
+                    println!();
+                    println!("=== Failed ===");
+                }
+                Err(e) => {
+                    eprintln!("Error running compiler: {}", e);
+                }
+            }
+
+            println!();
+            println!("Watching for changes...");
+        }
+    }
+}
+
 fn serve_static_files(dir: &str, port: u16) {
    use std::io::{Write, BufRead, BufReader};
    use std::net::TcpListener;
@@ -2128,6 +2288,48 @@ fn extract_module_doc(source: &str, path: &str) -> Result<ModuleDoc, String> {
                    is_public: matches!(t.visibility, ast::Visibility::Public),
                });
            }
+            ast::Declaration::ExternFn(ext) => {
+                let params: Vec<String> = ext.params.iter()
+                    .map(|p| format!("{}: {}", p.name.name, format_type(&p.typ)))
+                    .collect();
+                let js_note = ext.js_name.as_ref()
+                    .map(|n| format!(" = \"{}\"", n))
+                    .unwrap_or_default();
+                let signature = format!(
+                    "extern fn {}({}): {}{}",
+                    ext.name.name,
+                    params.join(", "),
+                    format_type(&ext.return_type),
+                    js_note
+                );
+                let doc = extract_doc_comment(source, ext.span.start);
+                functions.push(FunctionDoc {
+                    name: ext.name.name.clone(),
+                    signature,
+                    description: doc,
+                    is_public: matches!(ext.visibility, ast::Visibility::Public),
+                    properties: vec![],
+                });
+            }
+            ast::Declaration::ExternLet(ext) => {
+                let js_note = ext.js_name.as_ref()
+                    .map(|n| format!(" = \"{}\"", n))
+                    .unwrap_or_default();
+                let signature = format!(
+                    "extern let {}: {}{}",
+                    ext.name.name,
+                    format_type(&ext.typ),
+                    js_note
+                );
+                let doc = extract_doc_comment(source, ext.span.start);
+                functions.push(FunctionDoc {
+                    name: ext.name.name.clone(),
+                    signature,
+                    description: doc,
+                    is_public: matches!(ext.visibility, ast::Visibility::Public),
+                    properties: vec![],
+                });
+            }
            ast::Declaration::Effect(e) => {
                let doc = extract_doc_comment(source, e.span.start);
                let ops: Vec<String> = e.operations.iter()
@@ -3765,6 +3967,49 @@ c")"#;
        assert_eq!(eval(source).unwrap(), r#""literal {braces}""#);
    }

+    #[test]
+    fn test_multiline_string() {
+        let source = r#"
+            let s = """
+                hello
+                world
+            """
+            let result = String.length(s)
+        "#;
+        // "hello\nworld" = 11 chars
+        assert_eq!(eval(source).unwrap(), "11");
+    }
+
+    #[test]
+    fn test_multiline_string_with_quotes() {
+        // Quotes are fine in the middle of triple-quoted strings
+        let source = "let s = \"\"\"\n    She said \"hello\" to him.\n\"\"\"";
+        assert_eq!(eval(source).unwrap(), r#""She said "hello" to him.""#);
+    }
+
+    #[test]
+    fn test_multiline_string_interpolation() {
+        let source = r#"
+            let name = "Lux"
+            let s = """
+                Hello, {name}!
+            """
+        "#;
+        assert_eq!(eval(source).unwrap(), r#""Hello, Lux!""#);
+    }
+
+    #[test]
+    fn test_multiline_string_empty() {
+        let source = r#"let s = """""""#;
+        assert_eq!(eval(source).unwrap(), r#""""#);
+    }
+
+    #[test]
+    fn test_multiline_string_inline() {
+        let source = r#"let s = """hello world""""#;
+        assert_eq!(eval(source).unwrap(), r#""hello world""#);
+    }
+
    // Option tests
    #[test]
    fn test_option_constructors() {
@@ -3878,6 +4123,146 @@ c")"#;
        assert_eq!(eval("let x = { a: 1, b: 2 } == { a: 1, b: 3 }").unwrap(), "false");
    }

+    #[test]
+    fn test_record_spread() {
+        let source = r#"
+            let base = { x: 1, y: 2, z: 3 }
+            let updated = { ...base, y: 20 }
+            let result = updated.y
+        "#;
+        assert_eq!(eval(source).unwrap(), "20");
+    }
+
+    #[test]
+    fn test_deep_path_record_update() {
+        // Basic deep path: { ...base, pos.x: val } desugars to { ...base, pos: { ...base.pos, x: val } }
+        let source = r#"
+            let npc = { name: "Goblin", pos: { x: 10, y: 20 } }
+            let moved = { ...npc, pos.x: 50, pos.y: 60 }
+            let result = moved.pos.x
+        "#;
+        assert_eq!(eval(source).unwrap(), "50");
+
+        // Verify other fields are preserved through spread
+        let source2 = r#"
+            let npc = { name: "Goblin", pos: { x: 10, y: 20 } }
+            let moved = { ...npc, pos.x: 50 }
+            let result = moved.pos.y
+        "#;
+        assert_eq!(eval(source2).unwrap(), "20");
+
+        // Verify top-level spread fields preserved
+        let source3 = r#"
+            let npc = { name: "Goblin", pos: { x: 10, y: 20 } }
+            let moved = { ...npc, pos.x: 50 }
+            let result = moved.name
+        "#;
+        assert_eq!(eval(source3).unwrap(), "\"Goblin\"");
+
+        // Mix of flat and deep path fields
+        let source4 = r#"
+            let npc = { name: "Goblin", pos: { x: 10, y: 20 }, hp: 100 }
+            let updated = { ...npc, pos.x: 50, hp: 80 }
+            let result = (updated.pos.x, updated.hp, updated.name)
+        "#;
+        assert_eq!(eval(source4).unwrap(), "(50, 80, \"Goblin\")");
+    }
+
+    #[test]
+    fn test_deep_path_record_multilevel() {
+        // Multi-level deep path: world.physics.gravity
+        let source = r#"
+            let world = { name: "Earth", physics: { gravity: { x: 0, y: -10 }, drag: 1 } }
+            let updated = { ...world, physics.gravity.y: -20 }
+            let result = (updated.physics.gravity.y, updated.physics.drag, updated.name)
+        "#;
+        assert_eq!(eval(source).unwrap(), "(-20, 1, \"Earth\")");
+    }
+
+    #[test]
+    fn test_deep_path_conflict_error() {
+        // Field appears as both flat and deep path — should error
+        let result = eval(r#"
+            let base = { pos: { x: 1, y: 2 } }
+            let bad = { ...base, pos: { x: 10, y: 20 }, pos.x: 30 }
+        "#);
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_extern_fn_parse() {
+        // Extern fn should parse successfully
+        let source = r#"
+            extern fn getElementById(id: String): String
+            let x = 42
+        "#;
+        assert_eq!(eval(source).unwrap(), "42");
+    }
+
+    #[test]
+    fn test_extern_fn_with_js_name() {
+        // Extern fn with JS name override
+        let source = r#"
+            extern fn getCtx(el: String, kind: String): String = "getContext"
+            let x = 42
+        "#;
+        assert_eq!(eval(source).unwrap(), "42");
+    }
+
+    #[test]
+    fn test_extern_fn_call_errors_in_interpreter() {
+        // Calling an extern fn in the interpreter should produce a clear error
+        let source = r#"
+            extern fn alert(msg: String): Unit
+            let x = alert("hello")
+        "#;
+        let result = eval(source);
+        assert!(result.is_err());
+        let err = result.unwrap_err();
+        assert!(err.contains("extern") || err.contains("Extern") || err.contains("JavaScript"),
+            "Error should mention extern/JavaScript: {}", err);
+    }
+
+    #[test]
+    fn test_pub_extern_fn() {
+        // pub extern fn should parse
+        let source = r#"
+            pub extern fn requestAnimationFrame(callback: fn(): Unit): Int
+            let x = 42
+        "#;
+        assert_eq!(eval(source).unwrap(), "42");
+    }
+
+    #[test]
+    fn test_extern_fn_js_codegen() {
+        // Verify JS backend emits extern fn calls without _lux suffix
+        use crate::codegen::js_backend::JsBackend;
+        use crate::parser::Parser;
+        use crate::lexer::Lexer;
+
+        let source = r#"
+            extern fn getElementById(id: String): String
+            extern fn getContext(el: String, kind: String): String = "getContext"
+            fn main(): Unit = {
+                let el = getElementById("canvas")
+                let ctx = getContext(el, "2d")
+                ()
+            }
+        "#;
+
+        let tokens = Lexer::new(source).tokenize().unwrap();
+        let program = Parser::new(tokens).parse_program().unwrap();
+        let mut backend = JsBackend::new();
+        let js = backend.generate(&program).unwrap();
+
+        // getElementById should appear as-is (no _lux suffix)
+        assert!(js.contains("getElementById("), "JS should call getElementById directly: {}", js);
+        // getContext should use the JS name override
+        assert!(js.contains("getContext("), "JS should call getContext directly: {}", js);
+        // main should still be mangled
+        assert!(js.contains("main_lux"), "main should be mangled: {}", js);
+    }
+
    #[test]
    fn test_invalid_escape_sequence() {
        let result = eval(r#"let x = "\z""#);
@@ -4831,6 +5216,71 @@ c")"#;
        }
    }

+    // ============ Multi-line Arguments Tests ============
+
+    #[test]
+    fn test_multiline_function_args() {
+        let source = r#"
+            fn add(a: Int, b: Int): Int = a + b
+            let result = add(
+                1,
+                2
+            )
+        "#;
+        assert_eq!(eval(source).unwrap(), "3");
+    }
+
+    #[test]
+    fn test_multiline_function_args_with_lambda() {
+        let source = r#"
+            let xs = List.map(
+                [1, 2, 3],
+                fn(x) => x * 2
+            )
+        "#;
+        assert_eq!(eval(source).unwrap(), "[2, 4, 6]");
+    }
+
+    // ============ Tuple Index Tests ============
+
+    #[test]
+    fn test_tuple_index_access() {
+        let source = r#"
+            let pair = (42, "hello")
+            let first = pair.0
+        "#;
+        assert_eq!(eval(source).unwrap(), "42");
+    }
+
+    #[test]
+    fn test_tuple_index_access_second() {
+        let source = r#"
+            let pair = (42, "hello")
+            let second = pair.1
+        "#;
+        assert_eq!(eval(source).unwrap(), "\"hello\"");
+    }
+
+    #[test]
+    fn test_tuple_index_triple() {
+        let source = r#"
+            let triple = (1, 2, 3)
+            let sum = triple.0 + triple.1 + triple.2
+        "#;
+        assert_eq!(eval(source).unwrap(), "6");
+    }
+
+    #[test]
+    fn test_tuple_index_in_function() {
+        let source = r#"
+            fn first(pair: (Int, String)): Int = pair.0
+            fn second(pair: (Int, String)): String = pair.1
+            let p = (42, "hello")
+            let result = first(p)
+        "#;
+        assert_eq!(eval(source).unwrap(), "42");
+    }
+
    // Exhaustiveness checking tests
    mod exhaustiveness_tests {
        use super::*;
@@ -5286,4 +5736,173 @@ c")"#;
            check_file("projects/rest-api/main.lux").unwrap();
        }
    }
+
+    // === Map type tests ===
+
+    #[test]
+    fn test_map_new_and_size() {
+        let source = r#"
+            let m = Map.new()
+            let result = Map.size(m)
+        "#;
+        assert_eq!(eval(source).unwrap(), "0");
+    }
+
+    #[test]
+    fn test_map_set_and_get() {
+        let source = r#"
+            let m = Map.new()
+            let m2 = Map.set(m, "name", "Alice")
+            let result = Map.get(m2, "name")
+        "#;
+        assert_eq!(eval(source).unwrap(), "Some(\"Alice\")");
+    }
+
+    #[test]
+    fn test_map_get_missing() {
+        let source = r#"
+            let m = Map.new()
+            let result = Map.get(m, "missing")
+        "#;
+        assert_eq!(eval(source).unwrap(), "None");
+    }
+
+    #[test]
+    fn test_map_contains() {
+        let source = r#"
+            let m = Map.set(Map.new(), "x", 1)
+            let result = (Map.contains(m, "x"), Map.contains(m, "y"))
+        "#;
+        assert_eq!(eval(source).unwrap(), "(true, false)");
+    }
+
+    #[test]
+    fn test_map_remove() {
+        let source = r#"
+            let m = Map.set(Map.set(Map.new(), "a", 1), "b", 2)
+            let m2 = Map.remove(m, "a")
+            let result = (Map.size(m2), Map.contains(m2, "a"), Map.contains(m2, "b"))
+        "#;
+        assert_eq!(eval(source).unwrap(), "(1, false, true)");
+    }
+
+    #[test]
+    fn test_map_keys_and_values() {
+        let source = r#"
+            let m = Map.set(Map.set(Map.new(), "b", 2), "a", 1)
+            let result = Map.keys(m)
+        "#;
+        assert_eq!(eval(source).unwrap(), "[\"a\", \"b\"]");
+    }
+
+    #[test]
+    fn test_map_from_list() {
+        let source = r#"
+            let m = Map.fromList([("x", 10), ("y", 20)])
+            let result = (Map.get(m, "x"), Map.size(m))
+        "#;
+        assert_eq!(eval(source).unwrap(), "(Some(10), 2)");
+    }
+
+    #[test]
+    fn test_map_to_list() {
+        let source = r#"
+            let m = Map.set(Map.set(Map.new(), "b", 2), "a", 1)
+            let result = Map.toList(m)
+        "#;
+        assert_eq!(eval(source).unwrap(), "[(\"a\", 1), (\"b\", 2)]");
+    }
+
+    #[test]
+    fn test_map_merge() {
+        let source = r#"
+            let m1 = Map.fromList([("a", 1), ("b", 2)])
+            let m2 = Map.fromList([("b", 3), ("c", 4)])
+            let merged = Map.merge(m1, m2)
+            let result = (Map.get(merged, "a"), Map.get(merged, "b"), Map.get(merged, "c"))
+        "#;
+        assert_eq!(eval(source).unwrap(), "(Some(1), Some(3), Some(4))");
+    }
+
+    #[test]
+    fn test_map_immutability() {
+        let source = r#"
+            let m1 = Map.fromList([("a", 1)])
+            let m2 = Map.set(m1, "b", 2)
+            let result = (Map.size(m1), Map.size(m2))
+        "#;
+        assert_eq!(eval(source).unwrap(), "(1, 2)");
+    }
+
+    #[test]
+    fn test_map_is_empty() {
+        let source = r#"
+            let m1 = Map.new()
+            let m2 = Map.set(m1, "x", 1)
+            let result = (Map.isEmpty(m1), Map.isEmpty(m2))
+        "#;
+        assert_eq!(eval(source).unwrap(), "(true, false)");
+    }
+
+    #[test]
+    fn test_map_type_annotation() {
+        let source = r#"
+            fn lookup(m: Map<String, Int>, key: String): Option<Int> =
+                Map.get(m, key)
+            let m = Map.fromList([("age", 30)])
+            let result = lookup(m, "age")
+        "#;
+        assert_eq!(eval(source).unwrap(), "Some(30)");
+    }
+
+    #[test]
+    fn test_file_copy() {
+        use std::io::Write;
+        // Create a temp file, copy it, verify contents
+        let dir = std::env::temp_dir().join("lux_test_file_copy");
+        let _ = std::fs::create_dir_all(&dir);
+        let src = dir.join("src.txt");
+        let dst = dir.join("dst.txt");
+        std::fs::File::create(&src).unwrap().write_all(b"hello copy").unwrap();
+        let _ = std::fs::remove_file(&dst);
+
+        let source = format!(r#"
+            fn main(): Unit with {{File}} =
+                File.copy("{}", "{}")
+            let _ = run main() with {{}}
+            let result = "done"
+        "#, src.display(), dst.display());
+        let result = eval(&source);
+        assert!(result.is_ok(), "File.copy failed: {:?}", result);
+        let contents = std::fs::read_to_string(&dst).unwrap();
+        assert_eq!(contents, "hello copy");
+
+        // Cleanup
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+
+    #[test]
+    fn test_effectful_callback_propagation() {
+        // WISH-7: effectful callbacks in List.forEach should propagate effects
+        // This should type-check successfully because Console effect is inferred
+        let source = r#"
+            fn printAll(items: List<String>): Unit =
+                List.forEach(items, fn(x: String): Unit => Console.print(x))
+            let result = "ok"
+        "#;
+        let result = eval(source);
+        assert!(result.is_ok(), "Effectful callback should type-check: {:?}", result);
+    }
+
+    #[test]
+    fn test_effectful_callback_in_map() {
+        // Effectful callback in List.map should propagate effects
+        let source = r#"
+            fn readAll(paths: List<String>): List<String> =
+                List.map(paths, fn(p: String): String => File.read(p))
+            let result = "ok"
+        "#;
+        let result = eval(source);
+        assert!(result.is_ok(), "Effectful callback in map should type-check: {:?}", result);
+    }
 }
--- a/src/modules.rs
+++ b/src/modules.rs
@@ -52,6 +52,8 @@ impl Module {
                    Declaration::Let(l) => l.visibility == Visibility::Public,
                    Declaration::Type(t) => t.visibility == Visibility::Public,
                    Declaration::Trait(t) => t.visibility == Visibility::Public,
+                    Declaration::ExternFn(e) => e.visibility == Visibility::Public,
+                    Declaration::ExternLet(e) => e.visibility == Visibility::Public,
                    // Effects, handlers, and impls are always public for now
                    Declaration::Effect(_) | Declaration::Handler(_) | Declaration::Impl(_) => true,
                }
@@ -279,6 +281,12 @@ impl ModuleLoader {
                }
                Declaration::Type(t) if t.visibility == Visibility::Public => {
                    exports.insert(t.name.name.clone());
+                    // Also export constructors for ADT types
+                    if let crate::ast::TypeDef::Enum(variants) = &t.definition {
+                        for variant in variants {
+                            exports.insert(variant.name.name.clone());
+                        }
+                    }
                }
                Declaration::Effect(e) => {
                    // Effects are always exported
@@ -288,6 +296,12 @@ impl ModuleLoader {
                    // Handlers are always exported
                    exports.insert(h.name.name.clone());
                }
+                Declaration::ExternFn(e) if e.visibility == Visibility::Public => {
+                    exports.insert(e.name.name.clone());
+                }
+                Declaration::ExternLet(e) if e.visibility == Visibility::Public => {
+                    exports.insert(e.name.name.clone());
+                }
                _ => {}
            }
        }
@@ -305,6 +319,11 @@ impl ModuleLoader {
        self.cache.iter()
    }

+    /// Get the module cache (for passing to C backend)
+    pub fn module_cache(&self) -> &HashMap<String, Module> {
+        &self.cache
+    }
+
    /// Clear the module cache
    pub fn clear_cache(&mut self) {
        self.cache.clear();
--- a/src/parser.rs
+++ b/src/parser.rs
@@ -238,6 +238,7 @@ impl Parser {

        match self.peek_kind() {
            TokenKind::Fn => Ok(Declaration::Function(self.parse_function_decl(visibility, doc)?)),
+            TokenKind::Extern => self.parse_extern_decl(visibility, doc),
            TokenKind::Effect => Ok(Declaration::Effect(self.parse_effect_decl(doc)?)),
            TokenKind::Handler => Ok(Declaration::Handler(self.parse_handler_decl()?)),
            TokenKind::Type => Ok(Declaration::Type(self.parse_type_decl(visibility, doc)?)),
@@ -245,7 +246,8 @@ impl Parser {
            TokenKind::Trait => Ok(Declaration::Trait(self.parse_trait_decl(visibility, doc)?)),
            TokenKind::Impl => Ok(Declaration::Impl(self.parse_impl_decl()?)),
            TokenKind::Run => Err(self.error("Bare 'run' expressions are not allowed at top level. Use 'let _ = run ...' or 'let result = run ...'")),
-            _ => Err(self.error("Expected declaration (fn, effect, handler, type, trait, impl, or let)")),
+            TokenKind::Handle => Err(self.error("Bare 'handle' expressions are not allowed at top level. Use 'let _ = handle ...' or 'let result = handle ...'")),
+            _ => Err(self.error("Expected declaration (fn, extern, effect, handler, type, trait, impl, or let)")),
        }
    }

@@ -322,6 +324,109 @@ impl Parser {
        })
    }

+    /// Parse extern declaration: dispatch to extern fn or extern let
+    fn parse_extern_decl(&mut self, visibility: Visibility, doc: Option<String>) -> Result<Declaration, ParseError> {
+        // Peek past 'extern' to see if it's 'fn' or 'let'
+        if self.pos + 1 < self.tokens.len() {
+            match &self.tokens[self.pos + 1].kind {
+                TokenKind::Fn => Ok(Declaration::ExternFn(self.parse_extern_fn_decl(visibility, doc)?)),
+                TokenKind::Let => Ok(Declaration::ExternLet(self.parse_extern_let_decl(visibility, doc)?)),
+                _ => Err(self.error("Expected 'fn' or 'let' after 'extern'")),
+            }
+        } else {
+            Err(self.error("Expected 'fn' or 'let' after 'extern'"))
+        }
+    }
+
+    /// Parse extern let declaration: extern let name: Type = "jsName"
+    fn parse_extern_let_decl(&mut self, visibility: Visibility, doc: Option<String>) -> Result<ExternLetDecl, ParseError> {
+        let start = self.current_span();
+        self.expect(TokenKind::Extern)?;
+        self.expect(TokenKind::Let)?;
+
+        let name = self.parse_ident()?;
+
+        // Type annotation
+        self.expect(TokenKind::Colon)?;
+        let typ = self.parse_type()?;
+
+        // Optional JS name override: = "jsName"
+        let js_name = if self.check(TokenKind::Eq) {
+            self.advance();
+            match self.peek_kind() {
+                TokenKind::String(s) => {
+                    let name = s.clone();
+                    self.advance();
+                    Some(name)
+                }
+                _ => return Err(self.error("Expected string literal for JS name in extern let")),
+            }
+        } else {
+            None
+        };
+
+        let span = start.merge(self.previous_span());
+        Ok(ExternLetDecl {
+            visibility,
+            doc,
+            name,
+            typ,
+            js_name,
+            span,
+        })
+    }
+
+    /// Parse extern function declaration: extern fn name<T>(params): ReturnType = "jsName"
+    fn parse_extern_fn_decl(&mut self, visibility: Visibility, doc: Option<String>) -> Result<ExternFnDecl, ParseError> {
+        let start = self.current_span();
+        self.expect(TokenKind::Extern)?;
+        self.expect(TokenKind::Fn)?;
+
+        let name = self.parse_ident()?;
+
+        // Optional type parameters
+        let type_params = if self.check(TokenKind::Lt) {
+            self.parse_type_params()?
+        } else {
+            Vec::new()
+        };
+
+        self.expect(TokenKind::LParen)?;
+        let params = self.parse_params()?;
+        self.expect(TokenKind::RParen)?;
+
+        // Return type
+        self.expect(TokenKind::Colon)?;
+        let return_type = self.parse_type()?;
+
+        // Optional JS name override: = "jsName"
+        let js_name = if self.check(TokenKind::Eq) {
+            self.advance();
+            match self.peek_kind() {
+                TokenKind::String(s) => {
+                    let name = s.clone();
+                    self.advance();
+                    Some(name)
+                }
+                _ => return Err(self.error("Expected string literal for JS name in extern fn")),
+            }
+        } else {
+            None
+        };
+
+        let span = start.merge(self.previous_span());
+        Ok(ExternFnDecl {
+            visibility,
+            doc,
+            name,
+            type_params,
+            params,
+            return_type,
+            js_name,
+            span,
+        })
+    }
+
    /// Parse effect declaration
    fn parse_effect_decl(&mut self, doc: Option<String>) -> Result<EffectDecl, ParseError> {
        let start = self.current_span();
@@ -845,6 +950,7 @@ impl Parser {
    /// Parse function parameters
    fn parse_params(&mut self) -> Result<Vec<Parameter>, ParseError> {
        let mut params = Vec::new();
+        self.skip_newlines();

        while !self.check(TokenKind::RParen) {
            let start = self.current_span();
@@ -854,9 +960,11 @@ impl Parser {
            let span = start.merge(self.previous_span());

            params.push(Parameter { name, typ, span });
+            self.skip_newlines();

            if !self.check(TokenKind::RParen) {
                self.expect(TokenKind::Comma)?;
+                self.skip_newlines();
            }
        }

@@ -1558,6 +1666,7 @@ impl Parser {
        loop {
            let op = match self.peek_kind() {
                TokenKind::Plus => BinaryOp::Add,
+                TokenKind::PlusPlus => BinaryOp::Concat,
                TokenKind::Minus => BinaryOp::Sub,
                _ => break,
            };
@@ -1646,6 +1755,20 @@ impl Parser {
            } else if self.check(TokenKind::Dot) {
                let start = expr.span();
                self.advance();
+
+                // Check for tuple index access: expr.0, expr.1, etc.
+                if let TokenKind::Int(n) = self.peek_kind() {
+                    let index = n as usize;
+                    self.advance();
+                    let span = start.merge(self.previous_span());
+                    expr = Expr::TupleIndex {
+                        object: Box::new(expr),
+                        index,
+                        span,
+                    };
+                    continue;
+                }
+
                let field = self.parse_ident()?;

                // Check if this is an effect operation: Effect.operation(args)
@@ -1681,11 +1804,14 @@ impl Parser {

    fn parse_args(&mut self) -> Result<Vec<Expr>, ParseError> {
        let mut args = Vec::new();
+        self.skip_newlines();

        while !self.check(TokenKind::RParen) {
            args.push(self.parse_expr()?);
+            self.skip_newlines();
            if !self.check(TokenKind::RParen) {
                self.expect(TokenKind::Comma)?;
+                self.skip_newlines();
            }
        }

@@ -1757,6 +1883,7 @@ impl Parser {
            TokenKind::Let => self.parse_let_expr(),
            TokenKind::Fn => self.parse_lambda_expr(),
            TokenKind::Run => self.parse_run_expr(),
+            TokenKind::Handle => self.parse_handle_expr(),
            TokenKind::Resume => self.parse_resume_expr(),

            // Delimiters
@@ -1774,6 +1901,7 @@ impl Parser {

        let condition = Box::new(self.parse_expr()?);

+        self.skip_newlines();
        self.expect(TokenKind::Then)?;
        self.skip_newlines();
        let then_branch = Box::new(self.parse_expr()?);
@@ -1887,12 +2015,38 @@ impl Parser {
                    span: token.span,
                }))
            }
+            TokenKind::Char(c) => {
+                let c = *c;
+                self.advance();
+                Ok(Pattern::Literal(Literal {
+                    kind: LiteralKind::Char(c),
+                    span: token.span,
+                }))
+            }
            TokenKind::Ident(name) => {
                // Check if it starts with uppercase (constructor) or lowercase (variable)
                if name.chars().next().map_or(false, |c| c.is_uppercase()) {
-                    self.parse_constructor_pattern()
+                    self.parse_constructor_pattern_with_module(None)
                } else {
                    let ident = self.parse_ident()?;
+                    // Check for module-qualified constructor: module.Constructor
+                    if self.check(TokenKind::Dot) {
+                        // Peek ahead to see if next is an uppercase identifier
+                        let dot_pos = self.pos;
+                        self.advance(); // skip dot
+                        if let TokenKind::Ident(next_name) = self.peek_kind() {
+                            if next_name
+                                .chars()
+                                .next()
+                                .map_or(false, |c| c.is_uppercase())
+                            {
+                                return self
+                                    .parse_constructor_pattern_with_module(Some(ident));
+                            }
+                        }
+                        // Not a module-qualified constructor, backtrack
+                        self.pos = dot_pos;
+                    }
                    Ok(Pattern::Var(ident))
                }
            }
@@ -1902,25 +2056,40 @@ impl Parser {
        }
    }

-    fn parse_constructor_pattern(&mut self) -> Result<Pattern, ParseError> {
-        let start = self.current_span();
+    fn parse_constructor_pattern_with_module(
+        &mut self,
+        module: Option<Ident>,
+    ) -> Result<Pattern, ParseError> {
+        let start = module
+            .as_ref()
+            .map(|m| m.span)
+            .unwrap_or_else(|| self.current_span());
        let name = self.parse_ident()?;

        if self.check(TokenKind::LParen) {
            self.advance();
+            self.skip_newlines();
            let mut fields = Vec::new();
            while !self.check(TokenKind::RParen) {
                fields.push(self.parse_pattern()?);
+                self.skip_newlines();
                if !self.check(TokenKind::RParen) {
                    self.expect(TokenKind::Comma)?;
+                    self.skip_newlines();
                }
            }
            self.expect(TokenKind::RParen)?;
            let span = start.merge(self.previous_span());
-            Ok(Pattern::Constructor { name, fields, span })
-        } else {
-            let span = name.span;
            Ok(Pattern::Constructor {
+                module,
+                name,
+                fields,
+                span,
+            })
+        } else {
+            let span = start.merge(name.span);
+            Ok(Pattern::Constructor {
+                module,
                name,
                fields: Vec::new(),
                span,
@@ -1931,12 +2100,15 @@ impl Parser {
    fn parse_tuple_pattern(&mut self) -> Result<Pattern, ParseError> {
        let start = self.current_span();
        self.expect(TokenKind::LParen)?;
+        self.skip_newlines();

        let mut elements = Vec::new();
        while !self.check(TokenKind::RParen) {
            elements.push(self.parse_pattern()?);
+            self.skip_newlines();
            if !self.check(TokenKind::RParen) {
                self.expect(TokenKind::Comma)?;
+                self.skip_newlines();
            }
        }

@@ -2066,6 +2238,7 @@ impl Parser {

    fn parse_lambda_params(&mut self) -> Result<Vec<Parameter>, ParseError> {
        let mut params = Vec::new();
+        self.skip_newlines();

        while !self.check(TokenKind::RParen) {
            let start = self.current_span();
@@ -2081,9 +2254,11 @@ impl Parser {

            let span = start.merge(self.previous_span());
            params.push(Parameter { name, typ, span });
+            self.skip_newlines();

            if !self.check(TokenKind::RParen) {
                self.expect(TokenKind::Comma)?;
+                self.skip_newlines();
            }
        }

@@ -2124,6 +2299,40 @@ impl Parser {
        })
    }

+    fn parse_handle_expr(&mut self) -> Result<Expr, ParseError> {
+        let start = self.current_span();
+        self.expect(TokenKind::Handle)?;
+
+        let expr = Box::new(self.parse_call_expr()?);
+
+        self.expect(TokenKind::With)?;
+        self.expect(TokenKind::LBrace)?;
+        self.skip_newlines();
+
+        let mut handlers = Vec::new();
+        while !self.check(TokenKind::RBrace) {
+            let effect = self.parse_ident()?;
+            self.expect(TokenKind::Eq)?;
+            let handler = self.parse_expr()?;
+            handlers.push((effect, handler));
+
+            self.skip_newlines();
+            if self.check(TokenKind::Comma) {
+                self.advance();
+            }
+            self.skip_newlines();
+        }
+
+        let end = self.current_span();
+        self.expect(TokenKind::RBrace)?;
+
+        Ok(Expr::Run {
+            expr,
+            handlers,
+            span: start.merge(end),
+        })
+    }
+
    fn parse_resume_expr(&mut self) -> Result<Expr, ParseError> {
        let start = self.current_span();
        self.expect(TokenKind::Resume)?;
@@ -2137,6 +2346,7 @@ impl Parser {
    fn parse_tuple_or_paren_expr(&mut self) -> Result<Expr, ParseError> {
        let start = self.current_span();
        self.expect(TokenKind::LParen)?;
+        self.skip_newlines();

        if self.check(TokenKind::RParen) {
            self.advance();
@@ -2147,16 +2357,19 @@ impl Parser {
        }

        let first = self.parse_expr()?;
+        self.skip_newlines();

        if self.check(TokenKind::Comma) {
            // Tuple
            let mut elements = vec![first];
            while self.check(TokenKind::Comma) {
                self.advance();
+                self.skip_newlines();
                if self.check(TokenKind::RParen) {
                    break;
                }
                elements.push(self.parse_expr()?);
+                self.skip_newlines();
            }
            self.expect(TokenKind::RParen)?;
            let span = start.merge(self.previous_span());
@@ -2182,12 +2395,39 @@ impl Parser {
            }));
        }

-        // Check if it's a record (ident: expr) or block
+        // Check for record spread: { ...expr, field: val }
+        if matches!(self.peek_kind(), TokenKind::DotDotDot) {
+            return self.parse_record_expr_rest(start);
+        }
+
+        // Check if it's a record (ident: expr or ident.path: expr) or block
        if matches!(self.peek_kind(), TokenKind::Ident(_)) {
            let lookahead = self.tokens.get(self.pos + 1).map(|t| &t.kind);
            if matches!(lookahead, Some(TokenKind::Colon)) {
                return self.parse_record_expr_rest(start);
            }
+            // Check for deep path record: { ident.ident...: expr }
+            if matches!(lookahead, Some(TokenKind::Dot)) {
+                let mut look = self.pos + 2;
+                loop {
+                    match self.tokens.get(look).map(|t| &t.kind) {
+                        Some(TokenKind::Ident(_)) => {
+                            look += 1;
+                            match self.tokens.get(look).map(|t| &t.kind) {
+                                Some(TokenKind::Colon) => {
+                                    return self.parse_record_expr_rest(start);
+                                }
+                                Some(TokenKind::Dot) => {
+                                    look += 1;
+                                    continue;
+                                }
+                                _ => break,
+                            }
+                        }
+                        _ => break,
+                    }
+                }
+            }
        }

        // It's a block
@@ -2195,13 +2435,40 @@ impl Parser {
    }

    fn parse_record_expr_rest(&mut self, start: Span) -> Result<Expr, ParseError> {
-        let mut fields = Vec::new();
+        let mut raw_fields: Vec<(Vec<Ident>, Expr)> = Vec::new();
+        let mut spread = None;
+        let mut has_deep_paths = false;
+
+        // Check for spread: { ...expr, ... }
+        if self.check(TokenKind::DotDotDot) {
+            self.advance(); // consume ...
+            let spread_expr = self.parse_expr()?;
+            spread = Some(Box::new(spread_expr));
+
+            self.skip_newlines();
+            if self.check(TokenKind::Comma) {
+                self.advance();
+            }
+            self.skip_newlines();
+        }

        while !self.check(TokenKind::RBrace) {
            let name = self.parse_ident()?;
+
+            // Check for dotted path: pos.x, pos.x.y, etc.
+            let mut path = vec![name];
+            while self.check(TokenKind::Dot) {
+                self.advance(); // consume .
+                let segment = self.parse_ident()?;
+                path.push(segment);
+            }
+            if path.len() > 1 {
+                has_deep_paths = true;
+            }
+
            self.expect(TokenKind::Colon)?;
            let value = self.parse_expr()?;
-            fields.push((name, value));
+            raw_fields.push((path, value));

            self.skip_newlines();
            if self.check(TokenKind::Comma) {
@@ -2212,7 +2479,120 @@ impl Parser {

        self.expect(TokenKind::RBrace)?;
        let span = start.merge(self.previous_span());
-        Ok(Expr::Record { fields, span })
+
+        if has_deep_paths {
+            Self::desugar_deep_fields(spread, raw_fields, span)
+        } else {
+            // No deep paths — use flat fields directly (common case, no allocation overhead)
+            let fields = raw_fields
+                .into_iter()
+                .map(|(mut path, value)| (path.remove(0), value))
+                .collect();
+            Ok(Expr::Record {
+                spread,
+                fields,
+                span,
+            })
+        }
+    }
+
+    /// Desugar deep path record fields into nested record spread expressions.
+    /// `{ ...base, pos.x: vx, pos.y: vy }` becomes `{ ...base, pos: { ...base.pos, x: vx, y: vy } }`
+    fn desugar_deep_fields(
+        spread: Option<Box<Expr>>,
+        raw_fields: Vec<(Vec<Ident>, Expr)>,
+        outer_span: Span,
+    ) -> Result<Expr, ParseError> {
+        use std::collections::HashMap;
+
+        // Group fields by first path segment, preserving order
+        let mut groups: Vec<(String, Vec<(Vec<Ident>, Expr)>)> = Vec::new();
+        let mut group_map: HashMap<String, usize> = HashMap::new();
+
+        for (path, value) in raw_fields {
+            let key = path[0].name.clone();
+            if let Some(&idx) = group_map.get(&key) {
+                groups[idx].1.push((path, value));
+            } else {
+                group_map.insert(key.clone(), groups.len());
+                groups.push((key, vec![(path, value)]));
+            }
+        }
+
+        let mut fields = Vec::new();
+        for (_, group) in groups {
+            let first_ident = group[0].0[0].clone();
+
+            let has_flat = group.iter().any(|(p, _)| p.len() == 1);
+            let has_deep = group.iter().any(|(p, _)| p.len() > 1);
+
+            if has_flat && has_deep {
+                return Err(ParseError {
+                    message: format!(
+                        "Field '{}' appears as both a direct field and a deep path prefix",
+                        first_ident.name
+                    ),
+                    span: first_ident.span,
+                });
+            }
+
+            if has_flat {
+                if group.len() > 1 {
+                    return Err(ParseError {
+                        message: format!("Duplicate field '{}'", first_ident.name),
+                        span: group[1].0[0].span,
+                    });
+                }
+                let (_, value) = group.into_iter().next().unwrap();
+                fields.push((first_ident, value));
+            } else {
+                // Deep paths — create nested record with spread from parent
+                let sub_spread = spread.as_ref().map(|s| {
+                    Box::new(Expr::Field {
+                        object: s.clone(),
+                        field: first_ident.clone(),
+                        span: first_ident.span,
+                    })
+                });
+
+                // Strip first segment from all paths
+                let sub_fields: Vec<(Vec<Ident>, Expr)> = group
+                    .into_iter()
+                    .map(|(mut path, value)| {
+                        path.remove(0);
+                        (path, value)
+                    })
+                    .collect();
+
+                let has_nested_deep = sub_fields.iter().any(|(p, _)| p.len() > 1);
+                if has_nested_deep {
+                    // Recursively desugar deeper paths
+                    let nested =
+                        Self::desugar_deep_fields(sub_spread, sub_fields, first_ident.span)?;
+                    fields.push((first_ident, nested));
+                } else {
+                    // All sub-paths are single-segment — build Record directly
+                    let flat_fields: Vec<(Ident, Expr)> = sub_fields
+                        .into_iter()
+                        .map(|(mut path, value)| (path.remove(0), value))
+                        .collect();
+                    fields.push((
+                        first_ident.clone(),
+                        Expr::Record {
+                            spread: sub_spread,
+                            fields: flat_fields,
+                            span: first_ident.span,
+                        },
+                    ));
+                }
+            }
+        }
+
+        Ok(Expr::Record {
+            spread,
+            fields,
+            span: outer_span,
+        })
    }

    fn parse_block_rest(&mut self, start: Span) -> Result<Expr, ParseError> {
--- a/src/symbol_table.rs
+++ b/src/symbol_table.rs
@@ -228,13 +228,14 @@ impl SymbolTable {
            Declaration::Let(let_decl) => {
                let is_public = matches!(let_decl.visibility, Visibility::Public);
                let type_sig = let_decl.typ.as_ref().map(|t| self.type_expr_to_string(t));
-                let symbol = self.new_symbol(
+                let mut symbol = self.new_symbol(
                    let_decl.name.name.clone(),
                    SymbolKind::Variable,
                    let_decl.span,
                    type_sig,
                    is_public,
                );
+                symbol.documentation = let_decl.doc.clone();
                let id = self.add_symbol(scope_idx, symbol);
                self.add_reference(id, let_decl.name.span, true, true);

@@ -244,6 +245,48 @@ impl SymbolTable {
            Declaration::Handler(h) => self.visit_handler(h, scope_idx),
            Declaration::Trait(t) => self.visit_trait(t, scope_idx),
            Declaration::Impl(i) => self.visit_impl(i, scope_idx),
+            Declaration::ExternFn(ext) => {
+                let is_public = matches!(ext.visibility, Visibility::Public);
+                let params: Vec<String> = ext
+                    .params
+                    .iter()
+                    .map(|p| format!("{}: {}", p.name.name, self.type_expr_to_string(&p.typ)))
+                    .collect();
+                let sig = format!(
+                    "extern fn {}({}): {}",
+                    ext.name.name,
+                    params.join(", "),
+                    self.type_expr_to_string(&ext.return_type)
+                );
+                let mut symbol = self.new_symbol(
+                    ext.name.name.clone(),
+                    SymbolKind::Function,
+                    ext.span,
+                    Some(sig),
+                    is_public,
+                );
+                symbol.documentation = ext.doc.clone();
+                let id = self.add_symbol(scope_idx, symbol);
+                self.add_reference(id, ext.name.span, true, true);
+            }
+            Declaration::ExternLet(ext) => {
+                let is_public = matches!(ext.visibility, Visibility::Public);
+                let sig = format!(
+                    "extern let {}: {}",
+                    ext.name.name,
+                    self.type_expr_to_string(&ext.typ)
+                );
+                let mut symbol = self.new_symbol(
+                    ext.name.name.clone(),
+                    SymbolKind::Variable,
+                    ext.span,
+                    Some(sig),
+                    is_public,
+                );
+                symbol.documentation = ext.doc.clone();
+                let id = self.add_symbol(scope_idx, symbol);
+                self.add_reference(id, ext.name.span, true, true);
+            }
        }
    }

@@ -279,13 +322,14 @@ impl SymbolTable {
        };
        let type_sig = format!("fn {}({}): {}{}{}", f.name.name, param_types.join(", "), return_type, properties, effects);

-        let symbol = self.new_symbol(
+        let mut symbol = self.new_symbol(
            f.name.name.clone(),
            SymbolKind::Function,
            f.name.span,
            Some(type_sig),
            is_public,
        );
+        symbol.documentation = f.doc.clone();
        let fn_id = self.add_symbol(scope_idx, symbol);
        self.add_reference(fn_id, f.name.span, true, false);

@@ -326,13 +370,14 @@ impl SymbolTable {
        let is_public = matches!(t.visibility, Visibility::Public);
        let type_sig = format!("type {}", t.name.name);

-        let symbol = self.new_symbol(
+        let mut symbol = self.new_symbol(
            t.name.name.clone(),
            SymbolKind::Type,
            t.name.span,
            Some(type_sig),
            is_public,
        );
+        symbol.documentation = t.doc.clone();
        let type_id = self.add_symbol(scope_idx, symbol);
        self.add_reference(type_id, t.name.span, true, false);

@@ -372,13 +417,14 @@ impl SymbolTable {
        let is_public = true; // Effects are typically public
        let type_sig = format!("effect {}", e.name.name);

-        let symbol = self.new_symbol(
+        let mut symbol = self.new_symbol(
            e.name.name.clone(),
            SymbolKind::Effect,
            e.name.span,
            Some(type_sig),
            is_public,
        );
+        symbol.documentation = e.doc.clone();
        let effect_id = self.add_symbol(scope_idx, symbol);

        // Add operations
@@ -409,13 +455,14 @@ impl SymbolTable {
        let is_public = matches!(t.visibility, Visibility::Public);
        let type_sig = format!("trait {}", t.name.name);

-        let symbol = self.new_symbol(
+        let mut symbol = self.new_symbol(
            t.name.name.clone(),
            SymbolKind::Type, // Traits are like types
            t.name.span,
            Some(type_sig),
            is_public,
        );
+        symbol.documentation = t.doc.clone();
        self.add_symbol(scope_idx, symbol);
    }

@@ -479,7 +526,7 @@ impl SymbolTable {
                    self.visit_expr(arg, scope_idx);
                }
            }
-            Expr::Field { object, .. } => {
+            Expr::Field { object, .. } | Expr::TupleIndex { object, .. } => {
                self.visit_expr(object, scope_idx);
            }
            Expr::If { condition, then_branch, else_branch, .. } => {
@@ -522,7 +569,10 @@ impl SymbolTable {
                    self.visit_expr(e, scope_idx);
                }
            }
-            Expr::Record { fields, .. } => {
+            Expr::Record { spread, fields, .. } => {
+                if let Some(spread_expr) = spread {
+                    self.visit_expr(spread_expr, scope_idx);
+                }
                for (_, e) in fields {
                    self.visit_expr(e, scope_idx);
                }
--- a/src/typechecker.rs
+++ b/src/typechecker.rs
@@ -5,9 +5,9 @@
 use std::collections::HashMap;

 use crate::ast::{
-    self, BinaryOp, Declaration, EffectDecl, Expr, FunctionDecl, HandlerDecl, Ident, ImplDecl,
-    ImportDecl, LetDecl, Literal, LiteralKind, MatchArm, Parameter, Pattern, Program, Span,
-    Statement, TraitDecl, TypeDecl, TypeExpr, UnaryOp, VariantFields,
+    self, BinaryOp, Declaration, EffectDecl, ExternFnDecl, Expr, FunctionDecl, HandlerDecl, Ident,
+    ImplDecl, ImportDecl, LetDecl, Literal, LiteralKind, MatchArm, Parameter, Pattern, Program,
+    Span, Statement, TraitDecl, TypeDecl, TypeExpr, UnaryOp, VariantFields,
 };
 use crate::diagnostics::{find_similar_names, format_did_you_mean, Diagnostic, ErrorCode, Severity};
 use crate::exhaustiveness::{check_exhaustiveness, missing_patterns_hint};
@@ -335,11 +335,14 @@ fn references_params(expr: &Expr, params: &[&str]) -> bool {
                Statement::Expr(e) => references_params(e, params),
            }) || references_params(result, params)
        }
-        Expr::Field { object, .. } => references_params(object, params),
+        Expr::Field { object, .. } | Expr::TupleIndex { object, .. } => references_params(object, params),
        Expr::Lambda { body, .. } => references_params(body, params),
        Expr::Tuple { elements, .. } => elements.iter().any(|e| references_params(e, params)),
        Expr::List { elements, .. } => elements.iter().any(|e| references_params(e, params)),
-        Expr::Record { fields, .. } => fields.iter().any(|(_, e)| references_params(e, params)),
+        Expr::Record { spread, fields, .. } => {
+            spread.as_ref().is_some_and(|s| references_params(s, params))
+                || fields.iter().any(|(_, e)| references_params(e, params))
+        }
        Expr::Match { scrutinee, arms, .. } => {
            references_params(scrutinee, params)
                || arms.iter().any(|a| references_params(&a.body, params))
@@ -516,10 +519,11 @@ fn has_recursive_calls(func_name: &str, body: &Expr) -> bool {
        Expr::Tuple { elements, .. } | Expr::List { elements, .. } => {
            elements.iter().any(|e| has_recursive_calls(func_name, e))
        }
-        Expr::Record { fields, .. } => {
-            fields.iter().any(|(_, e)| has_recursive_calls(func_name, e))
+        Expr::Record { spread, fields, .. } => {
+            spread.as_ref().is_some_and(|s| has_recursive_calls(func_name, s))
+                || fields.iter().any(|(_, e)| has_recursive_calls(func_name, e))
        }
-        Expr::Field { object, .. } => has_recursive_calls(func_name, object),
+        Expr::Field { object, .. } | Expr::TupleIndex { object, .. } => has_recursive_calls(func_name, object),
        Expr::Let { value, body, .. } => {
            has_recursive_calls(func_name, value) || has_recursive_calls(func_name, body)
        }
@@ -672,6 +676,7 @@ fn generate_auto_migration_expr(

    // Build the record expression
    Some(Expr::Record {
+        spread: None,
        fields: field_exprs,
        span,
    })
@@ -976,6 +981,13 @@ impl TypeChecker {
                    if !fields.is_empty() {
                        self.env.bind(&name, TypeScheme::mono(Type::Record(fields)));
                    }
+
+                    // Also copy type definitions so imported types are usable
+                    for (type_name, type_def) in &module_checker.env.types {
+                        if !self.env.types.contains_key(type_name) {
+                            self.env.types.insert(type_name.clone(), type_def.clone());
+                        }
+                    }
                }
                ImportKind::Direct => {
                    // Import a specific name directly
@@ -1215,6 +1227,22 @@ impl TypeChecker {
                let trait_impl = self.collect_impl(impl_decl);
                self.env.trait_impls.push(trait_impl);
            }
+            Declaration::ExternFn(ext) => {
+                // Register extern fn type signature (like a regular function but no body)
+                let param_types: Vec<Type> = ext
+                    .params
+                    .iter()
+                    .map(|p| self.resolve_type(&p.typ))
+                    .collect();
+                let return_type = self.resolve_type(&ext.return_type);
+                let fn_type = Type::function(param_types, return_type);
+                self.env.bind(&ext.name.name, TypeScheme::mono(fn_type));
+            }
+            Declaration::ExternLet(ext) => {
+                // Register extern let with its declared type
+                let typ = self.resolve_type(&ext.typ);
+                self.env.bind(&ext.name.name, TypeScheme::mono(typ));
+            }
        }
    }

@@ -1536,7 +1564,7 @@ impl TypeChecker {
        // Use the declared type if present, otherwise use inferred
        let final_type = if let Some(ref type_expr) = let_decl.typ {
            let declared = self.resolve_type(type_expr);
-            if let Err(e) = unify(&inferred, &declared) {
+            if let Err(e) = unify_with_env(&inferred, &declared, &self.env) {
                self.errors.push(TypeError {
                    message: format!(
                        "Variable '{}' has type {}, but declared type is {}: {}",
@@ -1673,6 +1701,42 @@ impl TypeChecker {
                span,
            } => self.infer_field(object, field, *span),

+            Expr::TupleIndex {
+                object,
+                index,
+                span,
+            } => {
+                let object_type = self.infer_expr(object);
+                match &object_type {
+                    Type::Tuple(types) => {
+                        if *index < types.len() {
+                            types[*index].clone()
+                        } else {
+                            self.errors.push(TypeError {
+                                message: format!(
+                                    "Tuple index {} out of bounds for tuple with {} elements",
+                                    index,
+                                    types.len()
+                                ),
+                                span: *span,
+                            });
+                            Type::Error
+                        }
+                    }
+                    Type::Var(_) => Type::var(),
+                    _ => {
+                        self.errors.push(TypeError {
+                            message: format!(
+                                "Cannot use tuple index on non-tuple type {}",
+                                object_type
+                            ),
+                            span: *span,
+                        });
+                        Type::Error
+                    }
+                }
+            }
+
            Expr::Lambda {
                params,
                return_type,
@@ -1708,7 +1772,11 @@ impl TypeChecker {
                span,
            } => self.infer_block(statements, result, *span),

-            Expr::Record { fields, span } => self.infer_record(fields, *span),
+            Expr::Record {
+                spread,
+                fields,
+                span,
+            } => self.infer_record(spread.as_deref(), fields, *span),

            Expr::Tuple { elements, span } => self.infer_tuple(elements, *span),

@@ -1747,7 +1815,7 @@ impl TypeChecker {
        match op {
            BinaryOp::Add => {
                // Add supports both numeric types and string concatenation
-                if let Err(e) = unify(&left_type, &right_type) {
+                if let Err(e) = unify_with_env(&left_type, &right_type, &self.env) {
                    self.errors.push(TypeError {
                        message: format!("Operands of '{}' must have same type: {}", op, e),
                        span,
@@ -1768,9 +1836,32 @@ impl TypeChecker {
                }
            }

+            BinaryOp::Concat => {
+                // Concat (++) supports strings and lists
+                if let Err(e) = unify_with_env(&left_type, &right_type, &self.env) {
+                    self.errors.push(TypeError {
+                        message: format!("Operands of '++' must have same type: {}", e),
+                        span,
+                    });
+                }
+                match &left_type {
+                    Type::String | Type::List(_) | Type::Var(_) => left_type,
+                    _ => {
+                        self.errors.push(TypeError {
+                            message: format!(
+                                "Operator '++' requires String or List operands, got {}",
+                                left_type
+                            ),
+                            span,
+                        });
+                        Type::Error
+                    }
+                }
+            }
+
            BinaryOp::Sub | BinaryOp::Mul | BinaryOp::Div | BinaryOp::Mod => {
                // Arithmetic: both operands must be same numeric type
-                if let Err(e) = unify(&left_type, &right_type) {
+                if let Err(e) = unify_with_env(&left_type, &right_type, &self.env) {
                    self.errors.push(TypeError {
                        message: format!("Operands of '{}' must have same type: {}", op, e),
                        span,
@@ -1794,7 +1885,7 @@ impl TypeChecker {

            BinaryOp::Eq | BinaryOp::Ne => {
                // Equality: operands must have same type
-                if let Err(e) = unify(&left_type, &right_type) {
+                if let Err(e) = unify_with_env(&left_type, &right_type, &self.env) {
                    self.errors.push(TypeError {
                        message: format!("Operands of '{}' must have same type: {}", op, e),
                        span,
@@ -1805,7 +1896,7 @@ impl TypeChecker {

            BinaryOp::Lt | BinaryOp::Le | BinaryOp::Gt | BinaryOp::Ge => {
                // Comparison: operands must be same orderable type
-                if let Err(e) = unify(&left_type, &right_type) {
+                if let Err(e) = unify_with_env(&left_type, &right_type, &self.env) {
                    self.errors.push(TypeError {
                        message: format!("Operands of '{}' must have same type: {}", op, e),
                        span,
@@ -1816,13 +1907,13 @@ impl TypeChecker {

            BinaryOp::And | BinaryOp::Or => {
                // Logical: both must be Bool
-                if let Err(e) = unify(&left_type, &Type::Bool) {
+                if let Err(e) = unify_with_env(&left_type, &Type::Bool, &self.env) {
                    self.errors.push(TypeError {
                        message: format!("Left operand of '{}' must be Bool: {}", op, e),
                        span: left.span(),
                    });
                }
-                if let Err(e) = unify(&right_type, &Type::Bool) {
+                if let Err(e) = unify_with_env(&right_type, &Type::Bool, &self.env) {
                    self.errors.push(TypeError {
                        message: format!("Right operand of '{}' must be Bool: {}", op, e),
                        span: right.span(),
@@ -1836,7 +1927,7 @@ impl TypeChecker {
                // right must be a function that accepts left's type
                let result_type = Type::var();
                let expected_fn = Type::function(vec![left_type.clone()], result_type.clone());
-                if let Err(e) = unify(&right_type, &expected_fn) {
+                if let Err(e) = unify_with_env(&right_type, &expected_fn, &self.env) {
                    self.errors.push(TypeError {
                        message: format!(
                            "Pipe target must be a function accepting {}: {}",
@@ -1868,7 +1959,7 @@ impl TypeChecker {
                }
            },
            UnaryOp::Not => {
-                if let Err(e) = unify(&operand_type, &Type::Bool) {
+                if let Err(e) = unify_with_env(&operand_type, &Type::Bool, &self.env) {
                    self.errors.push(TypeError {
                        message: format!("Operator '!' requires Bool operand: {}", e),
                        span,
@@ -1883,6 +1974,17 @@ impl TypeChecker {
        let func_type = self.infer_expr(func);
        let arg_types: Vec<Type> = args.iter().map(|a| self.infer_expr(a)).collect();

+        // Propagate effects from callback arguments to enclosing scope
+        for arg_type in &arg_types {
+            if let Type::Function { effects, .. } = arg_type {
+                for effect in &effects.effects {
+                    if self.inferring_effects {
+                        self.inferred_effects.insert(effect.clone());
+                    }
+                }
+            }
+        }
+
        // Check property constraints from where clauses
        if let Expr::Var(func_id) = func {
            if let Some(constraints) = self.property_constraints.get(&func_id.name).cloned() {
@@ -1919,7 +2021,7 @@ impl TypeChecker {
            self.current_effects.clone(),
        );

-        match unify(&func_type, &expected_fn) {
+        match unify_with_env(&func_type, &expected_fn, &self.env) {
            Ok(subst) => result_type.apply(&subst),
            Err(e) => {
                // Provide more detailed error message based on the type of mismatch
@@ -1993,10 +2095,22 @@ impl TypeChecker {
                if let Some((_, field_type)) = fields.iter().find(|(n, _)| n == &operation.name) {
                    // It's a function call on a module field
                    let arg_types: Vec<Type> = args.iter().map(|a| self.infer_expr(a)).collect();
+
+                    // Propagate effects from callback arguments to enclosing scope
+                    for arg_type in &arg_types {
+                        if let Type::Function { effects, .. } = arg_type {
+                            for effect in &effects.effects {
+                                if self.inferring_effects {
+                                    self.inferred_effects.insert(effect.clone());
+                                }
+                            }
+                        }
+                    }
+
                    let result_type = Type::var();
                    let expected_fn = Type::function(arg_types, result_type.clone());

-                    if let Err(e) = unify(field_type, &expected_fn) {
+                    if let Err(e) = unify_with_env(field_type, &expected_fn, &self.env) {
                        self.errors.push(TypeError {
                            message: format!(
                                "Type mismatch in {}.{} call: {}",
@@ -2052,6 +2166,17 @@ impl TypeChecker {
                // Check argument types
                let arg_types: Vec<Type> = args.iter().map(|a| self.infer_expr(a)).collect();

+                // Propagate effects from callback arguments to enclosing scope
+                for arg_type in &arg_types {
+                    if let Type::Function { effects, .. } = arg_type {
+                        for effect in &effects.effects {
+                            if self.inferring_effects {
+                                self.inferred_effects.insert(effect.clone());
+                            }
+                        }
+                    }
+                }
+
                if arg_types.len() != op.params.len() {
                    self.errors.push(TypeError {
                        message: format!(
@@ -2068,7 +2193,7 @@ impl TypeChecker {
                for (i, (arg_type, (_, param_type))) in
                    arg_types.iter().zip(op.params.iter()).enumerate()
                {
-                    if let Err(e) = unify(arg_type, param_type) {
+                    if let Err(e) = unify_with_env(arg_type, param_type, &self.env) {
                        self.errors.push(TypeError {
                            message: format!(
                                "Argument {} of '{}.{}' has type {}, expected {}: {}",
@@ -2101,6 +2226,7 @@ impl TypeChecker {

    fn infer_field(&mut self, object: &Expr, field: &Ident, span: Span) -> Type {
        let object_type = self.infer_expr(object);
+        let object_type = self.env.expand_type_alias(&object_type);

        match &object_type {
            Type::Record(fields) => match fields.iter().find(|(n, _)| n == &field.name) {
@@ -2181,7 +2307,7 @@ impl TypeChecker {
        // Check return type if specified
        let ret_type = if let Some(rt) = return_type {
            let declared = self.resolve_type(rt);
-            if let Err(e) = unify(&body_type, &declared) {
+            if let Err(e) = unify_with_env(&body_type, &declared, &self.env) {
                self.errors.push(TypeError {
                    message: format!(
                        "Lambda body type {} doesn't match declared {}: {}",
@@ -2247,7 +2373,7 @@ impl TypeChecker {
        span: Span,
    ) -> Type {
        let cond_type = self.infer_expr(condition);
-        if let Err(e) = unify(&cond_type, &Type::Bool) {
+        if let Err(e) = unify_with_env(&cond_type, &Type::Bool, &self.env) {
            self.errors.push(TypeError {
                message: format!("If condition must be Bool, got {}: {}", cond_type, e),
                span: condition.span(),
@@ -2257,7 +2383,7 @@ impl TypeChecker {
        let then_type = self.infer_expr(then_branch);
        let else_type = self.infer_expr(else_branch);

-        match unify(&then_type, &else_type) {
+        match unify_with_env(&then_type, &else_type, &self.env) {
            Ok(subst) => then_type.apply(&subst),
            Err(e) => {
                self.errors.push(TypeError {
@@ -2298,7 +2424,7 @@ impl TypeChecker {
            // Check guard if present
            if let Some(ref guard) = arm.guard {
                let guard_type = self.infer_expr(guard);
-                if let Err(e) = unify(&guard_type, &Type::Bool) {
+                if let Err(e) = unify_with_env(&guard_type, &Type::Bool, &self.env) {
                    self.errors.push(TypeError {
                        message: format!("Match guard must be Bool: {}", e),
                        span: guard.span(),
@@ -2314,7 +2440,7 @@ impl TypeChecker {
            match &result_type {
                None => result_type = Some(body_type),
                Some(prev) => {
-                    if let Err(e) = unify(prev, &body_type) {
+                    if let Err(e) = unify_with_env(prev, &body_type, &self.env) {
                        self.errors.push(TypeError {
                            message: format!(
                                "Match arm has incompatible type: expected {}, got {}: {}",
@@ -2364,7 +2490,7 @@ impl TypeChecker {

            Pattern::Literal(lit) => {
                let lit_type = self.infer_literal(lit);
-                if let Err(e) = unify(&lit_type, expected) {
+                if let Err(e) = unify_with_env(&lit_type, expected, &self.env) {
                    self.errors.push(TypeError {
                        message: format!("Pattern literal type mismatch: {}", e),
                        span: lit.span,
@@ -2373,12 +2499,12 @@ impl TypeChecker {
                Vec::new()
            }

-            Pattern::Constructor { name, fields, span } => {
+            Pattern::Constructor { name, fields, span, .. } => {
                // Look up constructor
                // For now, handle Option specially
                match name.name.as_str() {
                    "None" => {
-                        if let Err(e) = unify(expected, &Type::Option(Box::new(Type::var()))) {
+                        if let Err(e) = unify_with_env(expected, &Type::Option(Box::new(Type::var())), &self.env) {
                            self.errors.push(TypeError {
                                message: format!(
                                    "None pattern doesn't match type {}: {}",
@@ -2391,7 +2517,7 @@ impl TypeChecker {
                    }
                    "Some" => {
                        let inner_type = Type::var();
-                        if let Err(e) = unify(expected, &Type::Option(Box::new(inner_type.clone())))
+                        if let Err(e) = unify_with_env(expected, &Type::Option(Box::new(inner_type.clone())), &self.env)
                        {
                            self.errors.push(TypeError {
                                message: format!(
@@ -2420,7 +2546,7 @@ impl TypeChecker {

            Pattern::Tuple { elements, span } => {
                let element_types: Vec<Type> = elements.iter().map(|_| Type::var()).collect();
-                if let Err(e) = unify(expected, &Type::Tuple(element_types.clone())) {
+                if let Err(e) = unify_with_env(expected, &Type::Tuple(element_types.clone()), &self.env) {
                    self.errors.push(TypeError {
                        message: format!("Tuple pattern doesn't match type {}: {}", expected, e),
                        span: *span,
@@ -2470,7 +2596,7 @@ impl TypeChecker {

                    if let Some(type_expr) = typ {
                        let declared = self.resolve_type(type_expr);
-                        if let Err(e) = unify(&value_type, &declared) {
+                        if let Err(e) = unify_with_env(&value_type, &declared, &self.env) {
                            self.errors.push(TypeError {
                                message: format!(
                                    "Variable '{}' has type {}, but declared type is {}: {}",
@@ -2491,12 +2617,47 @@ impl TypeChecker {
        self.infer_expr(result)
    }

-    fn infer_record(&mut self, fields: &[(Ident, Expr)], _span: Span) -> Type {
-        let field_types: Vec<(String, Type)> = fields
+    fn infer_record(
+        &mut self,
+        spread: Option<&Expr>,
+        fields: &[(Ident, Expr)],
+        span: Span,
+    ) -> Type {
+        // Start with spread fields if present
+        let mut field_types: Vec<(String, Type)> = if let Some(spread_expr) = spread {
+            let spread_type = self.infer_expr(spread_expr);
+            let spread_type = self.env.expand_type_alias(&spread_type);
+            match spread_type {
+                Type::Record(spread_fields) => spread_fields,
+                _ => {
+                    self.errors.push(TypeError {
+                        message: format!(
+                            "Spread expression must be a record type, got {}",
+                            spread_type
+                        ),
+                        span,
+                    });
+                    Vec::new()
+                }
+            }
+        } else {
+            Vec::new()
+        };
+
+        // Apply explicit field overrides
+        let explicit_types: Vec<(String, Type)> = fields
            .iter()
            .map(|(name, expr)| (name.name.clone(), self.infer_expr(expr)))
            .collect();

+        for (name, typ) in explicit_types {
+            if let Some(existing) = field_types.iter_mut().find(|(n, _)| n == &name) {
+                existing.1 = typ;
+            } else {
+                field_types.push((name, typ));
+            }
+        }
+
        Type::Record(field_types)
    }

@@ -2513,7 +2674,7 @@ impl TypeChecker {
        let first_type = self.infer_expr(&elements[0]);
        for elem in &elements[1..] {
            let elem_type = self.infer_expr(elem);
-            if let Err(e) = unify(&first_type, &elem_type) {
+            if let Err(e) = unify_with_env(&first_type, &elem_type, &self.env) {
                self.errors.push(TypeError {
                    message: format!("List elements must have same type: {}", e),
                    span,
@@ -2819,7 +2980,7 @@ impl TypeChecker {
            // Check return type matches if specified
            if let Some(ref return_type_expr) = impl_method.return_type {
                let return_type = self.resolve_type(return_type_expr);
-                if let Err(e) = unify(&body_type, &return_type) {
+                if let Err(e) = unify_with_env(&body_type, &return_type, &self.env) {
                    self.errors.push(TypeError {
                        message: format!(
                            "Method '{}' body has type {}, but declared return type is {}: {}",
@@ -2862,6 +3023,9 @@ impl TypeChecker {
                        "Option" if resolved_args.len() == 1 => {
                            return Type::Option(Box::new(resolved_args[0].clone()));
                        }
+                        "Map" if resolved_args.len() == 2 => {
+                            return Type::Map(Box::new(resolved_args[0].clone()), Box::new(resolved_args[1].clone()));
+                        }
                        _ => {}
                    }
                }
--- a/src/types.rs
+++ b/src/types.rs
@@ -47,6 +47,8 @@ pub enum Type {
    List(Box<Type>),
    /// Option type (sugar for App(Option, [T]))
    Option(Box<Type>),
+    /// Map type (sugar for App(Map, [K, V]))
+    Map(Box<Type>, Box<Type>),
    /// Versioned type (e.g., User @v2)
    Versioned {
        base: Box<Type>,
@@ -119,6 +121,7 @@ impl Type {
            Type::Tuple(elements) => elements.iter().any(|e| e.contains_var(var)),
            Type::Record(fields) => fields.iter().any(|(_, t)| t.contains_var(var)),
            Type::List(inner) | Type::Option(inner) => inner.contains_var(var),
+            Type::Map(k, v) => k.contains_var(var) || v.contains_var(var),
            Type::Versioned { base, .. } => base.contains_var(var),
            _ => false,
        }
@@ -158,6 +161,7 @@ impl Type {
            ),
            Type::List(inner) => Type::List(Box::new(inner.apply(subst))),
            Type::Option(inner) => Type::Option(Box::new(inner.apply(subst))),
+            Type::Map(k, v) => Type::Map(Box::new(k.apply(subst)), Box::new(v.apply(subst))),
            Type::Versioned { base, version } => Type::Versioned {
                base: Box::new(base.apply(subst)),
                version: version.clone(),
@@ -208,6 +212,11 @@ impl Type {
                vars
            }
            Type::List(inner) | Type::Option(inner) => inner.free_vars(),
+            Type::Map(k, v) => {
+                let mut vars = k.free_vars();
+                vars.extend(v.free_vars());
+                vars
+            }
            Type::Versioned { base, .. } => base.free_vars(),
            _ => HashSet::new(),
        }
@@ -279,6 +288,7 @@ impl fmt::Display for Type {
            }
            Type::List(inner) => write!(f, "List<{}>", inner),
            Type::Option(inner) => write!(f, "Option<{}>", inner),
+            Type::Map(k, v) => write!(f, "Map<{}, {}>", k, v),
            Type::Versioned { base, version } => {
                write!(f, "{} {}", base, version)
            }
@@ -946,6 +956,46 @@ impl TypeEnv {
                        params: vec![("path".to_string(), Type::String)],
                        return_type: Type::Unit,
                    },
+                    EffectOpDef {
+                        name: "copy".to_string(),
+                        params: vec![
+                            ("source".to_string(), Type::String),
+                            ("dest".to_string(), Type::String),
+                        ],
+                        return_type: Type::Unit,
+                    },
+                    EffectOpDef {
+                        name: "glob".to_string(),
+                        params: vec![("pattern".to_string(), Type::String)],
+                        return_type: Type::List(Box::new(Type::String)),
+                    },
+                    EffectOpDef {
+                        name: "tryRead".to_string(),
+                        params: vec![("path".to_string(), Type::String)],
+                        return_type: Type::App {
+                            constructor: Box::new(Type::Named("Result".to_string())),
+                            args: vec![Type::String, Type::String],
+                        },
+                    },
+                    EffectOpDef {
+                        name: "tryWrite".to_string(),
+                        params: vec![
+                            ("path".to_string(), Type::String),
+                            ("content".to_string(), Type::String),
+                        ],
+                        return_type: Type::App {
+                            constructor: Box::new(Type::Named("Result".to_string())),
+                            args: vec![Type::Unit, Type::String],
+                        },
+                    },
+                    EffectOpDef {
+                        name: "tryDelete".to_string(),
+                        params: vec![("path".to_string(), Type::String)],
+                        return_type: Type::App {
+                            constructor: Box::new(Type::Named("Result".to_string())),
+                            args: vec![Type::Unit, Type::String],
+                        },
+                    },
                ],
            },
        );
@@ -1146,6 +1196,15 @@ impl TypeEnv {
                        ],
                        return_type: Type::Unit,
                    },
+                    EffectOpDef {
+                        name: "assertEqualMsg".to_string(),
+                        params: vec![
+                            ("expected".to_string(), Type::Var(0)),
+                            ("actual".to_string(), Type::Var(0)),
+                            ("label".to_string(), Type::String),
+                        ],
+                        return_type: Type::Unit,
+                    },
                    EffectOpDef {
                        name: "assertNotEqual".to_string(),
                        params: vec![
@@ -1480,6 +1539,16 @@ impl TypeEnv {
                    Type::Option(Box::new(Type::var())),
                ),
            ),
+            (
+                "findIndex".to_string(),
+                Type::function(
+                    vec![
+                        Type::List(Box::new(Type::var())),
+                        Type::function(vec![Type::var()], Type::Bool),
+                    ],
+                    Type::Option(Box::new(Type::Int)),
+                ),
+            ),
            (
                "any".to_string(),
                Type::function(
@@ -1524,6 +1593,50 @@ impl TypeEnv {
                    Type::Unit,
                ),
            ),
+            (
+                "sort".to_string(),
+                Type::function(
+                    vec![Type::List(Box::new(Type::var()))],
+                    Type::List(Box::new(Type::var())),
+                ),
+            ),
+            (
+                "sortBy".to_string(),
+                {
+                    let elem = Type::var();
+                    Type::function(
+                        vec![
+                            Type::List(Box::new(elem.clone())),
+                            Type::function(vec![elem.clone(), elem], Type::Int),
+                        ],
+                        Type::List(Box::new(Type::var())),
+                    )
+                },
+            ),
+            (
+                "zip".to_string(),
+                Type::function(
+                    vec![
+                        Type::List(Box::new(Type::var())),
+                        Type::List(Box::new(Type::var())),
+                    ],
+                    Type::List(Box::new(Type::Tuple(vec![Type::var(), Type::var()]))),
+                ),
+            ),
+            (
+                "flatten".to_string(),
+                Type::function(
+                    vec![Type::List(Box::new(Type::List(Box::new(Type::var()))))],
+                    Type::List(Box::new(Type::var())),
+                ),
+            ),
+            (
+                "contains".to_string(),
+                Type::function(
+                    vec![Type::List(Box::new(Type::var())), Type::var()],
+                    Type::Bool,
+                ),
+            ),
        ]);
        env.bind("List", TypeScheme::mono(list_module_type));

@@ -1599,6 +1712,14 @@ impl TypeEnv {
                "parseFloat".to_string(),
                Type::function(vec![Type::String], Type::Option(Box::new(Type::Float))),
            ),
+            (
+                "indexOf".to_string(),
+                Type::function(vec![Type::String, Type::String], Type::Option(Box::new(Type::Int))),
+            ),
+            (
+                "lastIndexOf".to_string(),
+                Type::function(vec![Type::String, Type::String], Type::Option(Box::new(Type::Int))),
+            ),
        ]);
        env.bind("String", TypeScheme::mono(string_module_type));

@@ -1758,6 +1879,73 @@ impl TypeEnv {
        ]);
        env.bind("Option", TypeScheme::mono(option_module_type));

+        // Map module
+        let map_v = || Type::var();
+        let map_type = || Type::Map(Box::new(Type::String), Box::new(Type::var()));
+        let map_module_type = Type::Record(vec![
+            (
+                "new".to_string(),
+                Type::function(vec![], map_type()),
+            ),
+            (
+                "set".to_string(),
+                Type::function(
+                    vec![map_type(), Type::String, map_v()],
+                    map_type(),
+                ),
+            ),
+            (
+                "get".to_string(),
+                Type::function(
+                    vec![map_type(), Type::String],
+                    Type::Option(Box::new(map_v())),
+                ),
+            ),
+            (
+                "contains".to_string(),
+                Type::function(vec![map_type(), Type::String], Type::Bool),
+            ),
+            (
+                "remove".to_string(),
+                Type::function(vec![map_type(), Type::String], map_type()),
+            ),
+            (
+                "keys".to_string(),
+                Type::function(vec![map_type()], Type::List(Box::new(Type::String))),
+            ),
+            (
+                "values".to_string(),
+                Type::function(vec![map_type()], Type::List(Box::new(map_v()))),
+            ),
+            (
+                "size".to_string(),
+                Type::function(vec![map_type()], Type::Int),
+            ),
+            (
+                "isEmpty".to_string(),
+                Type::function(vec![map_type()], Type::Bool),
+            ),
+            (
+                "fromList".to_string(),
+                Type::function(
+                    vec![Type::List(Box::new(Type::Tuple(vec![Type::String, map_v()])))],
+                    map_type(),
+                ),
+            ),
+            (
+                "toList".to_string(),
+                Type::function(
+                    vec![map_type()],
+                    Type::List(Box::new(Type::Tuple(vec![Type::String, map_v()]))),
+                ),
+            ),
+            (
+                "merge".to_string(),
+                Type::function(vec![map_type(), map_type()], map_type()),
+            ),
+        ]);
+        env.bind("Map", TypeScheme::mono(map_module_type));
+
        // Result module
        let result_type = Type::App {
            constructor: Box::new(Type::Named("Result".to_string())),
@@ -1870,9 +2058,47 @@ impl TypeEnv {
                "round".to_string(),
                Type::function(vec![Type::var()], Type::Int),
            ),
+            (
+                "sin".to_string(),
+                Type::function(vec![Type::Float], Type::Float),
+            ),
+            (
+                "cos".to_string(),
+                Type::function(vec![Type::Float], Type::Float),
+            ),
+            (
+                "atan2".to_string(),
+                Type::function(vec![Type::Float, Type::Float], Type::Float),
+            ),
        ]);
        env.bind("Math", TypeScheme::mono(math_module_type));

+        // Int module
+        let int_module_type = Type::Record(vec![
+            (
+                "toString".to_string(),
+                Type::function(vec![Type::Int], Type::String),
+            ),
+            (
+                "toFloat".to_string(),
+                Type::function(vec![Type::Int], Type::Float),
+            ),
+        ]);
+        env.bind("Int", TypeScheme::mono(int_module_type));
+
+        // Float module
+        let float_module_type = Type::Record(vec![
+            (
+                "toString".to_string(),
+                Type::function(vec![Type::Float], Type::String),
+            ),
+            (
+                "toInt".to_string(),
+                Type::function(vec![Type::Float], Type::Int),
+            ),
+        ]);
+        env.bind("Float", TypeScheme::mono(float_module_type));
+
        env
    }

@@ -1956,6 +2182,9 @@ impl TypeEnv {
            Type::Option(inner) => {
                Type::Option(Box::new(self.expand_type_alias(inner)))
            }
+            Type::Map(k, v) => {
+                Type::Map(Box::new(self.expand_type_alias(k)), Box::new(self.expand_type_alias(v)))
+            }
            Type::Versioned { base, version } => {
                Type::Versioned {
                    base: Box::new(self.expand_type_alias(base)),
@@ -2032,7 +2261,9 @@ pub fn unify(t1: &Type, t2: &Type) -> Result<Substitution, String> {
            // Function's required effects (e1) must be a subset of available effects (e2)
            // A pure function (empty effects) can be called anywhere
            // A function requiring {Logger} can be called in context with {Logger} or {Logger, Console}
-            if !e1.is_subset(&e2) {
+            // When expected effects (e2) are empty, it means "no constraint" (e.g., callback parameter)
+            // so we allow any actual effects through
+            if !e2.is_empty() && !e1.is_subset(&e2) {
                return Err(format!(
                    "Effect mismatch: expected {{{}}}, got {{{}}}",
                    e1, e2
@@ -2114,6 +2345,13 @@ pub fn unify(t1: &Type, t2: &Type) -> Result<Substitution, String> {
        // Option
        (Type::Option(a), Type::Option(b)) => unify(a, b),

+        // Map
+        (Type::Map(k1, v1), Type::Map(k2, v2)) => {
+            let s1 = unify(k1, k2)?;
+            let s2 = unify(&v1.apply(&s1), &v2.apply(&s1))?;
+            Ok(s1.compose(&s2))
+        }
+
        // Versioned types
        (
            Type::Versioned {
--- a/stdlib/html.lux
+++ b/stdlib/html.lux
@@ -14,6 +14,7 @@
 pub type Html<M> =
    | Element(String, List<Attr<M>>, List<Html<M>>)
    | Text(String)
+    | RawHtml(String)
    | Empty

 // Attributes that can be applied to elements
@@ -41,6 +42,7 @@ pub type Attr<M> =
    | OnKeyDown(fn(String): M)
    | OnKeyUp(fn(String): M)
    | DataAttr(String, String)
+    | Attribute(String, String)

 // ============================================================================
 // Element builders - Container elements
@@ -180,6 +182,28 @@ pub fn video<M>(attrs: List<Attr<M>>, children: List<Html<M>>): Html<M> =
 pub fn audio<M>(attrs: List<Attr<M>>, children: List<Html<M>>): Html<M> =
    Element("audio", attrs, children)

+// ============================================================================
+// Element builders - Document / Head elements
+// ============================================================================
+
+pub fn meta<M>(attrs: List<Attr<M>>): Html<M> =
+    Element("meta", attrs, [])
+
+pub fn link<M>(attrs: List<Attr<M>>): Html<M> =
+    Element("link", attrs, [])
+
+pub fn script<M>(attrs: List<Attr<M>>, children: List<Html<M>>): Html<M> =
+    Element("script", attrs, children)
+
+pub fn iframe<M>(attrs: List<Attr<M>>, children: List<Html<M>>): Html<M> =
+    Element("iframe", attrs, children)
+
+pub fn figure<M>(attrs: List<Attr<M>>, children: List<Html<M>>): Html<M> =
+    Element("figure", attrs, children)
+
+pub fn figcaption<M>(attrs: List<Attr<M>>, children: List<Html<M>>): Html<M> =
+    Element("figcaption", attrs, children)
+
 // ============================================================================
 // Element builders - Tables
 // ============================================================================
@@ -285,6 +309,12 @@ pub fn onKeyUp<M>(h: fn(String): M): Attr<M> =
 pub fn data<M>(name: String, value: String): Attr<M> =
    DataAttr(name, value)

+pub fn attr<M>(name: String, value: String): Attr<M> =
+    Attribute(name, value)
+
+pub fn rawHtml<M>(content: String): Html<M> =
+    RawHtml(content)
+
 // ============================================================================
 // Utility functions
 // ============================================================================
@@ -319,6 +349,7 @@ pub fn renderAttr<M>(attr: Attr<M>): String =
        Checked(false) => "",
        Name(n) => " name=\"" + n + "\"",
        DataAttr(name, value) => " data-" + name + "=\"" + value + "\"",
+        Attribute(name, value) => " " + name + "=\"" + value + "\"",
        // Event handlers are ignored in static rendering
        OnClick(_) => "",
        OnInput(_) => "",
@@ -355,6 +386,7 @@ pub fn render<M>(html: Html<M>): String =
            }
        },
        Text(content) => escapeHtml(content),
+        RawHtml(content) => content,
        Empty => ""
    }

@@ -368,15 +400,47 @@ pub fn escapeHtml(s: String): String = {
    s4
 }

-// Render a full HTML document
+// Render a full HTML document (basic)
 pub fn document(title: String, headExtra: List<Html<M>>, bodyContent: List<Html<M>>): String = {
    let headElements = List.concat([
-        [Element("meta", [DataAttr("charset", "UTF-8")], [])],
-        [Element("meta", [Name("viewport"), Value("width=device-width, initial-scale=1.0")], [])],
+        [Element("meta", [Attribute("charset", "UTF-8")], [])],
+        [Element("meta", [Name("viewport"), Attribute("content", "width=device-width, initial-scale=1.0")], [])],
        [Element("title", [], [Text(title)])],
        headExtra
    ])
-    let doc = Element("html", [DataAttr("lang", "en")], [
+    let doc = Element("html", [Attribute("lang", "en")], [
+        Element("head", [], headElements),
+        Element("body", [], bodyContent)
+    ])
+    "<!DOCTYPE html>\n" + render(doc)
+}
+
+// Render a full HTML document with SEO meta tags
+pub fn seoDocument(
+    title: String,
+    description: String,
+    url: String,
+    ogImage: String,
+    headExtra: List<Html<M>>,
+    bodyContent: List<Html<M>>
+): String = {
+    let headElements = List.concat([
+        [Element("meta", [Attribute("charset", "UTF-8")], [])],
+        [Element("meta", [Name("viewport"), Attribute("content", "width=device-width, initial-scale=1.0")], [])],
+        [Element("title", [], [Text(title)])],
+        [Element("meta", [Name("description"), Attribute("content", description)], [])],
+        [Element("meta", [Attribute("property", "og:title"), Attribute("content", title)], [])],
+        [Element("meta", [Attribute("property", "og:description"), Attribute("content", description)], [])],
+        [Element("meta", [Attribute("property", "og:type"), Attribute("content", "website")], [])],
+        [Element("meta", [Attribute("property", "og:url"), Attribute("content", url)], [])],
+        [Element("meta", [Attribute("property", "og:image"), Attribute("content", ogImage)], [])],
+        [Element("meta", [Name("twitter:card"), Attribute("content", "summary_large_image")], [])],
+        [Element("meta", [Name("twitter:title"), Attribute("content", title)], [])],
+        [Element("meta", [Name("twitter:description"), Attribute("content", description)], [])],
+        [Element("link", [Attribute("rel", "canonical"), Href(url)], [])],
+        headExtra
+    ])
+    let doc = Element("html", [Attribute("lang", "en")], [
        Element("head", [], headElements),
        Element("body", [], bodyContent)
    ])
--- a/stdlib/http.lux
+++ b/stdlib/http.lux
@@ -625,6 +625,41 @@ pub fn router(routes: List<Route>, notFound: fn(Request): Response): Handler =
        }
    }

+// ============================================================
+// Static File Serving
+// ============================================================
+
+// Serve a static file from disk
+pub fn serveStaticFile(basePath: String, requestPath: String): Response with {File} = {
+    let filePath = basePath + requestPath
+    if File.exists(filePath) then {
+        let content = File.read(filePath)
+        let mime = getMimeType(filePath)
+        { status: 200, headers: [("Content-Type", mime)], body: content }
+    } else
+        { status: 404, headers: textHeaders(), body: "Not Found" }
+}
+
+// ============================================================
+// Form Body Parsing
+// ============================================================
+
+// Parse URL-encoded form body (same format as query strings)
+pub fn parseFormBody(body: String): List<(String, String)> =
+    parseQueryParams(body)
+
+// Get a form field value by name
+pub fn getFormField(fields: List<(String, String)>, name: String): Option<String> =
+    getParam(fields, name)
+
+// ============================================================
+// Response Helpers
+// ============================================================
+
+// Send a Response using HttpServer effect (convenience wrapper)
+pub fn sendResponse(resp: Response): Unit with {HttpServer} =
+    HttpServer.respondWithHeaders(resp.status, resp.body, resp.headers)
+
 // ============================================================
 // Example Usage
 // ============================================================