clean up bytecode

.gitattributes

@@ -0,0 +1 @@
+*.mach binary merge=ours

.gitignore

@@ -1,6 +1,7 @@
 .git/
 .obj/
-website/
+website/public/
+website/.hugo_build.lock
 bin/
 build/
 *.zip
@@ -15,6 +16,7 @@ build/
 source/shaders/*.h
 .DS_Store
 *.html
+!website/themes/**/*.html
 .vscode
 *.icns
 icon.ico

CLAUDE.md

@@ -1,25 +1,136 @@
-# Code style
-All code is done with 2 spaces for indentation.
+# ƿit (pit) Language Project
 
-For cell script and its integration files, objects are preferred over classes, and preferrably limited use of prototypes, make objects sendable between actors (.ce files).
+## Building
 
-## cell script format
-Cell script files end in .ce or .cm. Cell script is similar to Javascript but with some differences.
+Recompile after changes: `make`
+Bootstrap from scratch (first time): `make bootstrap`
+Run `cell --help` to see all CLI flags.
 
-Variables are delcared with 'var'. Var behaves like let.
-Constants are declared with 'def'.
-!= and == are strict, there is no !== or ===.
-There is no undefined, only null.
-There are no classes, only objects and prototypes.
-Prefer backticks for string interpolation. Otherwise, convering non strings with the text() function is required.
-Everything should be lowercase.
+## Code Style
 
-There are no arraybuffers, only blobs, which work with bits. They must be stoned like stone(blob) before being read from.
+All code uses 2 spaces for indentation. K&R style for C and Javascript.
 
-## c format
-For cell script integration files, everything should be declared static that can be. Most don't have headers at all. Files in a package are not shared between packages.
+## ƿit Script Quick Reference
 
-There is no undefined, so JS_IsNull and JS_NULL should be used only.
+ƿit script files: `.ce` (actors) and `.cm` (modules). The syntax is similar to JavaScript with important differences listed below.
 
-## how module loading is done in cell script
-Within a package, a c file, if using the correct macros (CELL_USE_FUNCS etc), will be loaded as a module with its name; so png.c inside ac package is loaded as <package>/png, giving you access to its functions.
+### Key Differences from JavaScript
+
+- `var` (mutable) and `def` (constant) — no `let` or `const`
+- `==` and `!=` are strict (no `===` or `!==`)
+- No `undefined` — only `null`
+- No classes — only objects and prototypes (`meme()`, `proto()`, `isa()`)
+- No `for...in`, `for...of`, spread (`...`), rest params, or default params
+- No named function declarations — use `var fn = function() {}` or arrow functions
+- Variables must be declared at function body level only (not in if/while/for/blocks)
+- All variables must be initialized at declaration (`var x` alone is an error; use `var x = null`)
+- No `try`/`catch`/`throw` — use `disrupt`/`disruption`
+- No arraybuffers — only `blob` (works with bits; must `stone(blob)` before reading)
+- Identifiers can contain `?` and `!` (e.g., `nil?`, `set!`, `is?valid`)
+- Prefer backticks for string interpolation; otherwise use `text()` to convert non-strings
+- Everything should be lowercase
+
+### Intrinsic Functions (always available, no `use()` needed)
+
+The creator functions are **polymorphic** — behavior depends on argument types:
+
+- `array(number)` — create array of size N filled with null
+- `array(number, value_or_fn)` — create array with initial values
+- `array(array)` — copy array
+- `array(array, fn)` — map
+- `array(array, array)` — concatenate
+- `array(array, from, to)` — slice
+- `array(record)` — get keys as array of text
+- **`array(text)` — split text into individual characters** (e.g., `array("hello")` → `["h","e","l","l","o"]`)
+- `array(text, separator)` — split by separator
+- `array(text, length)` — split into chunks of length
+
+- `text(array, separator)` — join array into text
+- `text(number)` or `text(number, radix)` — number to text
+- `text(text, from, to)` — substring
+
+- `number(text)` or `number(text, radix)` — parse text to number
+- `number(logical)` — boolean to number
+
+- `record(record)` — copy
+- `record(record, another)` — merge
+- `record(array_of_keys)` — create record from keys
+
+Other key intrinsics: `length()`, `stone()`, `is_stone()`, `print()`, `filter()`, `find()`, `reduce()`, `sort()`, `reverse()`, `some()`, `every()`, `starts_with()`, `ends_with()`, `meme()`, `proto()`, `isa()`, `splat()`, `apply()`, `extract()`, `replace()`, `search()`, `format()`, `lower()`, `upper()`, `trim()`
+
+Sensory functions: `is_array()`, `is_text()`, `is_number()`, `is_object()`, `is_function()`, `is_null()`, `is_logical()`, `is_integer()`, `is_stone()`, etc.
+
+### Standard Library (loaded with `use()`)
+
+- `blob` — binary data (bits, not bytes)
+- `time` — time constants and conversions
+- `math` — trig, logarithms, roots (`math/radians`, `math/turns`)
+- `json` — JSON encoding/decoding
+- `random` — random number generation
+
+### Actor Model
+
+- `.ce` files are actors (independent execution units, don't return values)
+- `.cm` files are modules (return a value, cached and frozen)
+- Actors never share memory; communicate via `$send()` message passing
+- Actor intrinsics start with `$`: `$me`, `$stop()`, `$send()`, `$start()`, `$delay()`, `$receiver()`, `$clock()`, `$portal()`, `$contact()`, `$couple()`, `$unneeded()`, `$connection()`, `$time_limit()`
+
+### Requestors (async composition)
+
+`sequence()`, `parallel()`, `race()`, `fallback()` — compose asynchronous operations. See docs/requestors.md.
+
+### Error Handling
+
+```javascript
+var fn = function() {
+  disrupt  // bare keyword, no value
+} disruption {
+  // handle error; can re-raise with disrupt
+}
+```
+
+### Push/Pop Syntax
+
+```javascript
+var a = [1, 2]
+a[] = 3       // push: [1, 2, 3]
+var v = a[]   // pop: v is 3, a is [1, 2]
+```
+
+## C Integration
+
+- Declare everything `static` that can be
+- Most files don't have headers; files in a package are not shared between packages
+- No undefined in C API: use `JS_IsNull` and `JS_NULL` only
+- A C file with correct macros (`CELL_USE_FUNCS` etc) is loaded as a module by its name (e.g., `png.c` in a package → `use('<package>/png')`)
+
+## Project Layout
+
+- `source/` — C source for the cell runtime and CLI
+- `docs/` — master documentation (Markdown), reflected on the website
+- `website/` — Hugo site; theme at `website/themes/knr/`
+- `internal/` — internal ƿit scripts (engine.cm etc.)
+- `packages/` — core packages
+- `Makefile` — build system (`make` to rebuild, `make bootstrap` for first build)
+
+## Testing
+
+After any C runtime changes, run all three test suites before considering the work done:
+
+```
+make                        # rebuild
+./cell --dev vm_suite       # VM-level tests (641 tests)
+./cell --dev test suite     # language-level tests (493 tests)
+./cell --dev fuzz           # fuzzer (100 iterations)
+```
+
+All three must pass with 0 failures.
+
+## Documentation
+
+The `docs/` folder is the single source of truth. The website at `website/` mounts it via Hugo. Key files:
+- `docs/language.md` — language syntax reference
+- `docs/functions.md` — all built-in intrinsic functions
+- `docs/actors.md` — actor model and actor intrinsics
+- `docs/requestors.md` — async requestor pattern
+- `docs/library/*.md` — intrinsic type reference (text, number, array, object) and standard library modules

Makefile

@@ -5,10 +5,16 @@
 # or manually build with meson once.
 #
 # The cell shop is at ~/.cell and core scripts are installed to ~/.cell/core
+#
+# See BUILDING.md for details on the bootstrap process and .mach files.
 
 CELL_SHOP = $(HOME)/.cell
 CELL_CORE_PACKAGE = $(CELL_SHOP)/packages/core
 
+# .cm sources that compile to .mach bytecode
+MACH_SOURCES = tokenize.cm parse.cm fold.cm mcode.cm \
+               internal/bootstrap.cm internal/engine.cm
+
 maker: install
 
 makecell:
@@ -16,7 +22,7 @@ makecell:
 	cp cell /opt/homebrew/bin/
 
 # Install core: symlink this directory to ~/.cell/core
-install: bootstrap $(CELL_SHOP)
+install: bootstrap .mach.stamp $(CELL_SHOP)
 	@echo "Linking cell core to $(CELL_CORE_PACKAGE)"
 	rm -rf $(CELL_CORE_PACKAGE)
 	ln -s $(PWD) $(CELL_CORE_PACKAGE)
@@ -40,6 +46,16 @@ libcell_runtime.dylib: $(CELL_SHOP)/build/dynamic
 cell_main: source/main.c libcell_runtime.dylib
 	cc -o cell_main source/main.c -L. -lcell_runtime -Wl,-rpath,@loader_path -Wl,-rpath,/opt/homebrew/lib
 
+# Regenerate .mach bytecode when any .cm source changes
+.mach.stamp: $(MACH_SOURCES)
+	./cell --dev regen
+	@touch $@
+
+# Force-regenerate all .mach bytecode files
+regen:
+	./cell --core . regen
+	@touch .mach.stamp
+
 # Create the cell shop directories
 $(CELL_SHOP):
 	mkdir -p $(CELL_SHOP)
@@ -57,8 +73,8 @@ static:
 
 # Bootstrap: build cell from scratch using meson (only needed once)
 # Also installs core scripts to ~/.cell/core
-bootstrap: 
-	meson setup build_bootstrap -Dbuildtype=debug -Db_sanitize=address
+bootstrap:
+	meson setup build_bootstrap -Dbuildtype=debugoptimized
 	meson compile -C build_bootstrap
 	cp build_bootstrap/cell .
 	cp build_bootstrap/libcell_runtime.dylib .
@@ -68,7 +84,7 @@ bootstrap:
 # Clean build artifacts
 clean:
 	rm -rf $(CELL_SHOP)/build build_bootstrap
-	rm -f cell cell_main libcell_runtime.dylib
+	rm -f cell cell_main libcell_runtime.dylib .mach.stamp
 
 # Ensure dynamic build directory exists
 $(CELL_SHOP)/build/dynamic: $(CELL_SHOP)
@@ -79,4 +95,4 @@ meson:
 	meson setup build_dbg -Dbuildtype=debugoptimized
 	meson install -C build_dbg
 
-.PHONY: cell static bootstrap clean meson install
+.PHONY: cell static bootstrap clean meson install regen

archive/miniz.c

@@ -319,7 +319,7 @@ JSValue js_reader_list(JSContext *js, JSValue self, int argc, JSValue *argv)
       JS_FreeValue(js, arr);
       return filename;
     }
-    JS_SetPropertyUint32(js, arr, arr_index++, filename);
+    JS_SetPropertyNumber(js, arr, arr_index++, filename);
   }
   
   return arr;
@@ -382,13 +382,13 @@ static const JSCFunctionListEntry js_reader_funcs[] = {
 JSValue js_miniz_use(JSContext *js)
 {
   JS_NewClassID(&js_reader_class_id);
-  JS_NewClass(JS_GetRuntime(js), js_reader_class_id, &js_reader_class);
+  JS_NewClass(js, js_reader_class_id, &js_reader_class);
   JSValue reader_proto = JS_NewObject(js);
   JS_SetPropertyFunctionList(js, reader_proto, js_reader_funcs, sizeof(js_reader_funcs) / sizeof(JSCFunctionListEntry));
   JS_SetClassProto(js, js_reader_class_id, reader_proto);
 
   JS_NewClassID(&js_writer_class_id);
-  JS_NewClass(JS_GetRuntime(js), js_writer_class_id, &js_writer_class);
+  JS_NewClass(js, js_writer_class_id, &js_writer_class);
   JSValue writer_proto = JS_NewObject(js);
   JS_SetPropertyFunctionList(js, writer_proto, js_writer_funcs, sizeof(js_writer_funcs) / sizeof(JSCFunctionListEntry));
   JS_SetClassProto(js, js_writer_class_id, writer_proto);

bench.ce

@@ -8,7 +8,7 @@ var os = use('os')
 var testlib = use('internal/testlib')
 var math = use('math/radians')
 
-if (!args) args = []
+var _args = args == null ? [] : args
 
 var target_pkg = null // null = current package
 var target_bench = null // null = all benchmarks, otherwise specific bench file
@@ -55,14 +55,19 @@ function stddev(arr, mean_val) {
 function percentile(arr, p) {
   if (length(arr) == 0) return 0
   var sorted = sort(arr)
-  var idx = floor(arr) * p / 100
+  var idx = floor(length(arr) * p / 100)
   if (idx >= length(arr)) idx = length(arr) - 1
   return sorted[idx]
 }
 
 // Parse arguments similar to test.ce
 function parse_args() {
-  if (length(args) == 0) {
+  var name = null
+  var lock = null
+  var resolved = null
+  var bench_path = null
+
+  if (length(_args) == 0) {
     if (!testlib.is_valid_package('.')) {
       log.console('No cell.toml found in current directory')
       return false
@@ -71,7 +76,7 @@ function parse_args() {
     return true
   }
 
-  if (args[0] == 'all') {
+  if (_args[0] == 'all') {
     if (!testlib.is_valid_package('.')) {
       log.console('No cell.toml found in current directory')
       return false
@@ -80,28 +85,28 @@ function parse_args() {
     return true
   }
 
-  if (args[0] == 'package') {
-    if (length(args) < 2) {
+  if (_args[0] == 'package') {
+    if (length(_args) < 2) {
       log.console('Usage: cell bench package <name> [bench]')
       log.console('       cell bench package all')
       return false
     }
 
-    if (args[1] == 'all') {
+    if (_args[1] == 'all') {
       all_pkgs = true
       log.console('Benchmarking all packages...')
       return true
     }
 
-    var name = args[1]
-    var lock = shop.load_lock()
+    name = _args[1]
+    lock = shop.load_lock()
     if (lock[name]) {
       target_pkg = name
     } else if (starts_with(name, '/') && testlib.is_valid_package(name)) {
       target_pkg = name
     } else {
       if (testlib.is_valid_package('.')) {
-        var resolved = pkg.alias_to_package(null, name)
+        resolved = pkg.alias_to_package(null, name)
         if (resolved) {
           target_pkg = resolved
         } else {
@@ -114,8 +119,8 @@ function parse_args() {
       }
     }
 
-    if (length(args) >= 3) {
-      target_bench = args[2]
+    if (length(_args) >= 3) {
+      target_bench = _args[2]
     }
 
     log.console(`Benchmarking package: ${target_pkg}`)
@@ -123,7 +128,7 @@ function parse_args() {
   }
 
   // cell bench benches/suite or cell bench <path>
-  var bench_path = args[0]
+  bench_path = _args[0]
 
   // Normalize path - add benches/ prefix if not present
   if (!starts_with(bench_path, 'benches/') && !starts_with(bench_path, '/')) {
@@ -160,12 +165,15 @@ function collect_benches(package_name, specific_bench) {
   var files = pkg.list_files(package_name)
   var bench_files = []
   arrfor(files, function(f) {
+    var bench_name = null
+    var match_name = null
+    var match_base = null
     if (starts_with(f, "benches/") && ends_with(f, ".cm")) {
       if (specific_bench) {
-        var bench_name = text(f, 0, -3)
-        var match_name = specific_bench
+        bench_name = text(f, 0, -3)
+        match_name = specific_bench
         if (!starts_with(match_name, 'benches/')) match_name = 'benches/' + match_name
-        var match_base = ends_with(match_name, '.cm') ? text(match_name, 0, -3) : match_name
+        match_base = ends_with(match_name, '.cm') ? text(match_name, 0, -3) : match_name
         if (bench_name != match_base) return
       }
       push(bench_files, f)
@@ -180,24 +188,25 @@ function calibrate_batch_size(bench_fn, is_batch) {
 
   var n = MIN_BATCH_SIZE
   var dt = 0
+  var start = 0
+  var new_n = 0
+  var calc = 0
+  var target_n = 0
 
   // Find a batch size that takes at least MIN_SAMPLE_NS
   while (n < MAX_BATCH_SIZE) {
-    // Ensure n is a valid number before calling
     if (!is_number(n) || n < 1) {
       n = 1
       break
     }
 
-    var start = os.now()
+    start = os.now()
     bench_fn(n)
     dt = os.now() - start
 
     if (dt >= MIN_SAMPLE_NS) break
 
-    // Double the batch size
-    var new_n = n * 2
-    // Check if multiplication produced a valid number
+    new_n = n * 2
     if (!is_number(new_n) || new_n > MAX_BATCH_SIZE) {
       n = MAX_BATCH_SIZE
       break
@@ -207,10 +216,9 @@ function calibrate_batch_size(bench_fn, is_batch) {
 
   // Adjust to target sample duration
   if (dt > 0 && dt < TARGET_SAMPLE_NS && is_number(n) && is_number(dt)) {
-    var calc = n * TARGET_SAMPLE_NS / dt
+    calc = n * TARGET_SAMPLE_NS / dt
     if (is_number(calc) && calc > 0) {
-      var target_n = floor(calc)
-      // Check if floor returned a valid number
+      target_n = floor(calc)
       if (is_number(target_n) && target_n > 0) {
         if (target_n > MAX_BATCH_SIZE) target_n = MAX_BATCH_SIZE
         if (target_n < MIN_BATCH_SIZE) target_n = MIN_BATCH_SIZE
@@ -219,7 +227,6 @@ function calibrate_batch_size(bench_fn, is_batch) {
     }
   }
 
-  // Safety check - ensure we always return a valid batch size
   if (!is_number(n) || n < 1) {
     n = 1
   }
@@ -230,72 +237,70 @@ function calibrate_batch_size(bench_fn, is_batch) {
 // Run a single benchmark function
 function run_single_bench(bench_fn, bench_name) {
   var timings_per_op = []
-
-  // Detect benchmark format:
-  // 1. Object with { setup, run, teardown } - structured format
-  // 2. Function that accepts (n) - batch format
-  // 3. Function that accepts () - legacy format
   var is_structured = is_object(bench_fn) && bench_fn.run
   var is_batch = false
   var batch_size = 1
   var setup_fn = null
   var run_fn = null
   var teardown_fn = null
+  var calibrate_fn = null
+  var _detect = null
+  var i = 0
+  var state = null
+  var start = 0
+  var duration = 0
+  var ns_per_op = 0
 
   if (is_structured) {
     setup_fn = bench_fn.setup || function() { return null }
     run_fn = bench_fn.run
-    teardown_fn = bench_fn.teardown || function(state) {}
+    teardown_fn = bench_fn.teardown || function(s) {}
 
     // Check if run function accepts batch size
-    try {
+    _detect = function() {
       var test_state = setup_fn()
       run_fn(1, test_state)
       is_batch = true
       if (teardown_fn) teardown_fn(test_state)
-    } catch (e) {
+    } disruption {
       is_batch = false
     }
+    _detect()
 
-    // Create wrapper for calibration
-    var calibrate_fn = function(n) {
-      var state = setup_fn()
-      run_fn(n, state)
-      if (teardown_fn) teardown_fn(state)
+    calibrate_fn = function(n) {
+      var s = setup_fn()
+      run_fn(n, s)
+      if (teardown_fn) teardown_fn(s)
     }
     batch_size = calibrate_batch_size(calibrate_fn, is_batch)
 
-    // Safety check for structured benchmarks
     if (!is_number(batch_size) || batch_size < 1) {
       batch_size = 1
     }
   } else {
     // Simple function format
-    try {
+    _detect = function() {
       bench_fn(1)
       is_batch = true
-    } catch (e) {
+    } disruption {
       is_batch = false
     }
+    _detect()
     batch_size = calibrate_batch_size(bench_fn, is_batch)
   }
 
-  // Safety check - ensure batch_size is valid
   if (!batch_size || batch_size < 1) {
     batch_size = 1
   }
 
   // Warmup phase
-  for (var i = 0; i < WARMUP_BATCHES; i++) {
-    // Ensure batch_size is valid before warmup
+  for (i = 0; i < WARMUP_BATCHES; i++) {
     if (!is_number(batch_size) || batch_size < 1) {
-      var type_str = is_null(batch_size) ? 'null' : is_number(batch_size) ? 'number' : is_text(batch_size) ? 'text' : is_object(batch_size) ? 'object' : is_array(batch_size) ? 'array' : is_function(batch_size) ? 'function' : is_logical(batch_size) ? 'logical' : 'unknown'
-      log.console(`WARNING: batch_size became ${type_str} = ${batch_size}, resetting to 1`)
       batch_size = 1
     }
 
     if (is_structured) {
-      var state = setup_fn()
+      state = setup_fn()
       if (is_batch) {
         run_fn(batch_size, state)
       } else {
@@ -312,35 +317,34 @@ function run_single_bench(bench_fn, bench_name) {
   }
 
   // Measurement phase - collect SAMPLES timing samples
-  for (var i = 0; i < SAMPLES; i++) {
-    // Double-check batch_size is valid (should never happen, but defensive)
+  for (i = 0; i < SAMPLES; i++) {
     if (!is_number(batch_size) || batch_size < 1) {
       batch_size = 1
     }
 
     if (is_structured) {
-      var state = setup_fn()
-      var start = os.now()
+      state = setup_fn()
+      start = os.now()
       if (is_batch) {
         run_fn(batch_size, state)
       } else {
         run_fn(state)
       }
-      var duration = os.now() - start
+      duration = os.now() - start
       if (teardown_fn) teardown_fn(state)
 
-      var ns_per_op = is_batch ? duration / batch_size : duration
+      ns_per_op = is_batch ? duration / batch_size : duration
       push(timings_per_op, ns_per_op)
     } else {
-      var start = os.now()
+      start = os.now()
       if (is_batch) {
         bench_fn(batch_size)
       } else {
         bench_fn()
       }
-      var duration = os.now() - start
+      duration = os.now() - start
 
-      var ns_per_op = is_batch ? duration / batch_size : duration
+      ns_per_op = is_batch ? duration / batch_size : duration
       push(timings_per_op, ns_per_op)
     }
   }
@@ -354,7 +358,6 @@ function run_single_bench(bench_fn, bench_name) {
   var p95_ns = percentile(timings_per_op, 95)
   var p99_ns = percentile(timings_per_op, 99)
 
-  // Calculate ops/s from median
   var ops_per_sec = 0
   if (median_ns > 0) {
     ops_per_sec = floor(1000000000 / median_ns)
@@ -408,18 +411,21 @@ function run_benchmarks(package_name, specific_bench) {
 
   arrfor(bench_files, function(f) {
     var mod_path = text(f, 0, -3)
+    var load_error = false
+    var bench_mod = null
+    var use_pkg = null
+    var benches = []
+    var error_result = null
 
     var file_result = {
       name: f,
       benchmarks: []
     }
 
-    try {
-      var bench_mod
-      var use_pkg = package_name ? package_name : fd.realpath('.')
+    var _load_file = function() {
+      use_pkg = package_name ? package_name : fd.realpath('.')
       bench_mod = shop.use(mod_path, use_pkg)
 
-      var benches = []
       if (is_function(bench_mod)) {
         push(benches, {name: 'main', fn: bench_mod})
       } else if (is_object(bench_mod)) {
@@ -432,8 +438,11 @@ function run_benchmarks(package_name, specific_bench) {
       if (length(benches) > 0) {
         log.console(`  ${f}`)
         arrfor(benches, function(b) {
-          try {
-            var result = run_single_bench(b.fn, b.name)
+          var bench_error = false
+          var result = null
+
+          var _run_bench = function() {
+            result = run_single_bench(b.fn, b.name)
             result.package = pkg_result.package
             push(file_result.benchmarks, result)
             pkg_result.total++
@@ -444,25 +453,32 @@ function run_benchmarks(package_name, specific_bench) {
             if (result.batch_size > 1) {
               log.console(`      batch: ${result.batch_size}  samples: ${result.samples}`)
             }
-          } catch (e) {
-            log.console(`    ERROR ${b.name}: ${e}`)
-            log.error(e)
-            var error_result = {
+          } disruption {
+            bench_error = true
+          }
+          _run_bench()
+          if (bench_error) {
+            log.console(`    ERROR ${b.name}`)
+            error_result = {
               package: pkg_result.package,
               name: b.name,
-              error: e.toString()
+              error: "benchmark disrupted"
             }
             push(file_result.benchmarks, error_result)
             pkg_result.total++
           }
         })
       }
-    } catch (e) {
-      log.console(`  Error loading ${f}: ${e}`)
-      var error_result = {
+    } disruption {
+      load_error = true
+    }
+    _load_file()
+    if (load_error) {
+      log.console(`  Error loading ${f}`)
+      error_result = {
         package: pkg_result.package,
         name: "load_module",
-        error: `Error loading module: ${e}`
+        error: "error loading module"
       }
       push(file_result.benchmarks, error_result)
       pkg_result.total++
@@ -478,15 +494,16 @@ function run_benchmarks(package_name, specific_bench) {
 
 // Run all benchmarks
 var all_results = []
+var packages = null
 
 if (all_pkgs) {
   if (testlib.is_valid_package('.')) {
     push(all_results, run_benchmarks(null, null))
   }
 
-  var packages = shop.list_packages()
-  arrfor(packages, function(pkg) {
-    push(all_results, run_benchmarks(pkg, null))
+  packages = shop.list_packages()
+  arrfor(packages, function(p) {
+    push(all_results, run_benchmarks(p, null))
   })
 } else {
   push(all_results, run_benchmarks(target_pkg, target_bench))

benches/actor_patterns.cm

@@ -0,0 +1,232 @@
+// actor_patterns.cm — Actor concurrency benchmarks
+// Message passing, fan-out/fan-in, mailbox throughput.
+// These use structured benchmarks with setup/run/teardown.
+
+// Note: actor benchmarks are measured differently from pure compute.
+// Each iteration sends messages and waits for results, so they're
+// inherently slower but test real concurrency costs.
+
+// Simple ping-pong: two actors sending messages back and forth
+// Since we can't create real actors from a module, we simulate
+// the message-passing patterns with function call overhead that
+// mirrors what the actor dispatch does.
+
+// Simulate message dispatch overhead
+function make_mailbox() {
+  return {
+    queue: [],
+    delivered: 0
+  }
+}
+
+function send(mailbox, msg) {
+  push(mailbox.queue, msg)
+  return null
+}
+
+function receive(mailbox) {
+  if (length(mailbox.queue) == 0) return null
+  mailbox.delivered++
+  return pop(mailbox.queue)
+}
+
+function drain(mailbox) {
+  var count = 0
+  while (length(mailbox.queue) > 0) {
+    pop(mailbox.queue)
+    count++
+  }
+  return count
+}
+
+// Ping-pong: simulate two actors exchanging messages
+function ping_pong(rounds) {
+  var box_a = make_mailbox()
+  var box_b = make_mailbox()
+  var i = 0
+  var msg = null
+
+  send(box_a, {type: "ping", val: 0})
+
+  for (i = 0; i < rounds; i++) {
+    // A receives and sends to B
+    msg = receive(box_a)
+    if (msg) {
+      send(box_b, {type: "pong", val: msg.val + 1})
+    }
+    // B receives and sends to A
+    msg = receive(box_b)
+    if (msg) {
+      send(box_a, {type: "ping", val: msg.val + 1})
+    }
+  }
+
+  return box_a.delivered + box_b.delivered
+}
+
+// Fan-out: one sender, N receivers
+function fan_out(n_receivers, messages_per) {
+  var receivers = []
+  var i = 0
+  var j = 0
+  for (i = 0; i < n_receivers; i++) {
+    push(receivers, make_mailbox())
+  }
+
+  // Send messages to all receivers
+  for (j = 0; j < messages_per; j++) {
+    for (i = 0; i < n_receivers; i++) {
+      send(receivers[i], {seq: j, data: j * 17})
+    }
+  }
+
+  // All receivers drain
+  var total = 0
+  for (i = 0; i < n_receivers; i++) {
+    total += drain(receivers[i])
+  }
+
+  return total
+}
+
+// Fan-in: N senders, one receiver
+function fan_in(n_senders, messages_per) {
+  var inbox = make_mailbox()
+  var i = 0
+  var j = 0
+
+  // Each sender sends messages
+  for (i = 0; i < n_senders; i++) {
+    for (j = 0; j < messages_per; j++) {
+      send(inbox, {sender: i, seq: j, data: i * 100 + j})
+    }
+  }
+
+  // Receiver processes all
+  var total = 0
+  var msg = null
+  msg = receive(inbox)
+  while (msg) {
+    total += msg.data
+    msg = receive(inbox)
+  }
+
+  return total
+}
+
+// Pipeline: chain of processors
+function pipeline(stages, items) {
+  var boxes = []
+  var i = 0
+  var j = 0
+  var msg = null
+
+  for (i = 0; i <= stages; i++) {
+    push(boxes, make_mailbox())
+  }
+
+  // Feed input
+  for (i = 0; i < items; i++) {
+    send(boxes[0], {val: i})
+  }
+
+  // Process each stage
+  for (j = 0; j < stages; j++) {
+    msg = receive(boxes[j])
+    while (msg) {
+      send(boxes[j + 1], {val: msg.val * 2 + 1})
+      msg = receive(boxes[j])
+    }
+  }
+
+  // Drain output
+  var total = 0
+  msg = receive(boxes[stages])
+  while (msg) {
+    total += msg.val
+    msg = receive(boxes[stages])
+  }
+
+  return total
+}
+
+// Request-response pattern (simulate RPC)
+function request_response(n_requests) {
+  var client_box = make_mailbox()
+  var server_box = make_mailbox()
+  var i = 0
+  var req = null
+  var resp = null
+  var total = 0
+
+  for (i = 0; i < n_requests; i++) {
+    // Client sends request
+    send(server_box, {id: i, payload: i * 3, reply_to: client_box})
+
+    // Server processes
+    req = receive(server_box)
+    if (req) {
+      send(req.reply_to, {id: req.id, result: req.payload * 2 + 1})
+    }
+
+    // Client receives response
+    resp = receive(client_box)
+    if (resp) {
+      total += resp.result
+    }
+  }
+
+  return total
+}
+
+return {
+  // Ping-pong: 10K rounds
+  ping_pong_10k: function(n) {
+    var i = 0
+    var x = 0
+    for (i = 0; i < n; i++) {
+      x += ping_pong(10000)
+    }
+    return x
+  },
+
+  // Fan-out: 100 receivers, 100 messages each
+  fan_out_100x100: function(n) {
+    var i = 0
+    var x = 0
+    for (i = 0; i < n; i++) {
+      x += fan_out(100, 100)
+    }
+    return x
+  },
+
+  // Fan-in: 100 senders, 100 messages each
+  fan_in_100x100: function(n) {
+    var i = 0
+    var x = 0
+    for (i = 0; i < n; i++) {
+      x += fan_in(100, 100)
+    }
+    return x
+  },
+
+  // Pipeline: 10 stages, 1000 items
+  pipeline_10x1k: function(n) {
+    var i = 0
+    var x = 0
+    for (i = 0; i < n; i++) {
+      x += pipeline(10, 1000)
+    }
+    return x
+  },
+
+  // Request-response: 5K requests
+  rpc_5k: function(n) {
+    var i = 0
+    var x = 0
+    for (i = 0; i < n; i++) {
+      x += request_response(5000)
+    }
+    return x
+  }
+}

benches/cli_tool.cm

@@ -0,0 +1,141 @@
+// cli_tool.cm — CLI tool simulation (macro benchmark)
+// Parse args + process data + transform + format output.
+// Simulates a realistic small utility program.
+
+var json = use('json')
+
+// Generate fake records
+function generate_records(n) {
+  var records = []
+  var x = 42
+  var i = 0
+  var status_vals = ["active", "inactive", "pending", "archived"]
+  var dept_vals = ["eng", "sales", "ops", "hr", "marketing"]
+  for (i = 0; i < n; i++) {
+    x = ((x * 1103515245 + 12345) & 0x7FFFFFFF) | 0
+    push(records, {
+      id: i + 1,
+      name: `user_${i}`,
+      score: (x % 1000) / 10,
+      status: status_vals[i % 4],
+      department: dept_vals[i % 5]
+    })
+  }
+  return records
+}
+
+// Filter records by field value
+function filter_records(records, field, value) {
+  var result = []
+  var i = 0
+  for (i = 0; i < length(records); i++) {
+    if (records[i][field] == value) {
+      push(result, records[i])
+    }
+  }
+  return result
+}
+
+// Group by a field
+function group_by(records, field) {
+  var groups = {}
+  var i = 0
+  var key = null
+  for (i = 0; i < length(records); i++) {
+    key = records[i][field]
+    if (!key) key = "unknown"
+    if (!groups[key]) groups[key] = []
+    push(groups[key], records[i])
+  }
+  return groups
+}
+
+// Aggregate: compute stats per group
+function aggregate(groups) {
+  var keys = array(groups)
+  var result = []
+  var i = 0
+  var j = 0
+  var grp = null
+  var total = 0
+  var mn = 0
+  var mx = 0
+  for (i = 0; i < length(keys); i++) {
+    grp = groups[keys[i]]
+    total = 0
+    mn = 999999
+    mx = 0
+    for (j = 0; j < length(grp); j++) {
+      total += grp[j].score
+      if (grp[j].score < mn) mn = grp[j].score
+      if (grp[j].score > mx) mx = grp[j].score
+    }
+    push(result, {
+      group: keys[i],
+      count: length(grp),
+      average: total / length(grp),
+      low: mn,
+      high: mx
+    })
+  }
+  return result
+}
+
+// Full pipeline: load → filter → sort → group → aggregate → encode
+function run_pipeline(n_records) {
+  // Generate data
+  var records = generate_records(n_records)
+
+  // Filter to active records
+  var filtered = filter_records(records, "status", "active")
+
+  // Sort by score
+  filtered = sort(filtered, "score")
+
+  // Limit to first 50
+  if (length(filtered) > 50) {
+    filtered = array(filtered, 0, 50)
+  }
+
+  // Group and aggregate
+  var groups = group_by(filtered, "department")
+  var stats = aggregate(groups)
+  stats = sort(stats, "average")
+
+  // Encode as JSON
+  var output = json.encode(stats)
+
+  return length(output)
+}
+
+return {
+  // Small dataset (100 records)
+  cli_pipeline_100: function(n) {
+    var i = 0
+    var x = 0
+    for (i = 0; i < n; i++) {
+      x += run_pipeline(100)
+    }
+    return x
+  },
+
+  // Medium dataset (1000 records)
+  cli_pipeline_1k: function(n) {
+    var i = 0
+    var x = 0
+    for (i = 0; i < n; i++) {
+      x += run_pipeline(1000)
+    }
+    return x
+  },
+
+  // Large dataset (10K records)
+  cli_pipeline_10k: function(n) {
+    var i = 0
+    var x = 0
+    for (i = 0; i < n; i++) {
+      x += run_pipeline(10000)
+    }
+    return x
+  }
+}

benches/deltablue.cm

@@ -0,0 +1,162 @@
+// deltablue.cm — Constraint solver kernel (DeltaBlue-inspired)
+// Dynamic dispatch, pointer chasing, object-heavy workload.
+
+def REQUIRED = 0
+def STRONG = 1
+def NORMAL = 2
+def WEAK = 3
+def WEAKEST = 4
+
+function make_variable(name, value) {
+  return {
+    name: name,
+    value: value,
+    constraints: [],
+    determined_by: null,
+    stay: true,
+    mark: 0
+  }
+}
+
+function make_constraint(strength, variables, satisfy_fn) {
+  return {
+    strength: strength,
+    variables: variables,
+    satisfy: satisfy_fn,
+    output: null
+  }
+}
+
+// Constraint propagation: simple forward solver
+function propagate(vars, constraints) {
+  var changed = true
+  var passes = 0
+  var max_passes = length(constraints) * 3
+  var i = 0
+  var c = null
+  var old_val = 0
+
+  while (changed && passes < max_passes) {
+    changed = false
+    passes++
+    for (i = 0; i < length(constraints); i++) {
+      c = constraints[i]
+      old_val = c.output ? c.output.value : null
+      c.satisfy(c)
+      if (c.output && c.output.value != old_val) {
+        changed = true
+      }
+    }
+  }
+  return passes
+}
+
+// Build a chain of equality constraints: v[i] = v[i-1] + 1
+function build_chain(n) {
+  var vars = []
+  var constraints = []
+  var i = 0
+  for (i = 0; i < n; i++) {
+    push(vars, make_variable(`v${i}`, 0))
+  }
+
+  // Set first variable
+  vars[0].value = 1
+
+  var c = null
+  for (i = 1; i < n; i++) {
+    c = make_constraint(NORMAL, [vars[i - 1], vars[i]], function(self) {
+      self.variables[1].value = self.variables[0].value + 1
+      self.output = self.variables[1]
+    })
+    push(constraints, c)
+    push(vars[i].constraints, c)
+  }
+
+  return {vars: vars, constraints: constraints}
+}
+
+// Build a projection: pairs of variables with scaling constraints
+function build_projection(n) {
+  var src = []
+  var dst = []
+  var constraints = []
+  var i = 0
+  for (i = 0; i < n; i++) {
+    push(src, make_variable(`src${i}`, i * 10))
+    push(dst, make_variable(`dst${i}`, 0))
+  }
+
+  var scale_c = null
+  for (i = 0; i < n; i++) {
+    scale_c = make_constraint(STRONG, [src[i], dst[i]], function(self) {
+      self.variables[1].value = self.variables[0].value * 2 + 1
+      self.output = self.variables[1]
+    })
+    push(constraints, scale_c)
+    push(dst[i].constraints, scale_c)
+  }
+
+  return {src: src, dst: dst, constraints: constraints}
+}
+
+// Edit constraint: change a source, re-propagate
+function run_edits(system, edits) {
+  var i = 0
+  var total_passes = 0
+  for (i = 0; i < edits; i++) {
+    system.vars[0].value = i
+    total_passes += propagate(system.vars, system.constraints)
+  }
+  return total_passes
+}
+
+return {
+  // Chain of 100 variables, propagate
+  chain_100: function(n) {
+    var i = 0
+    var chain = null
+    var x = 0
+    for (i = 0; i < n; i++) {
+      chain = build_chain(100)
+      x += propagate(chain.vars, chain.constraints)
+    }
+    return x
+  },
+
+  // Chain of 500 variables, propagate
+  chain_500: function(n) {
+    var i = 0
+    var chain = null
+    var x = 0
+    for (i = 0; i < n; i++) {
+      chain = build_chain(500)
+      x += propagate(chain.vars, chain.constraints)
+    }
+    return x
+  },
+
+  // Projection of 100 pairs
+  projection_100: function(n) {
+    var i = 0
+    var proj = null
+    var x = 0
+    for (i = 0; i < n; i++) {
+      proj = build_projection(100)
+      x += propagate(proj.src, proj.constraints)
+    }
+    return x
+  },
+
+  // Edit and re-propagate (incremental update)
+  chain_edit_100: function(n) {
+    var chain = build_chain(100)
+    var i = 0
+    var x = 0
+    for (i = 0; i < n; i++) {
+      chain.vars[0].value = i
+      x += propagate(chain.vars, chain.constraints)
+    }
+    return x
+  }
+}

benches/fibonacci.cm

@@ -0,0 +1,126 @@
+// fibonacci.cm — Fibonacci variants kernel
+// Tests recursion overhead, memoization patterns, iteration vs recursion.
+
+// Naive recursive (exponential) — measures call overhead
+function fib_naive(n) {
+  if (n <= 1) return n
+  return fib_naive(n - 1) + fib_naive(n - 2)
+}
+
+// Iterative (linear)
+function fib_iter(n) {
+  var a = 0
+  var b = 1
+  var i = 0
+  var tmp = 0
+  for (i = 0; i < n; i++) {
+    tmp = a + b
+    a = b
+    b = tmp
+  }
+  return a
+}
+
+// Memoized recursive (tests object property lookup + recursion)
+function make_memo_fib() {
+  var cache = {}
+  var fib = function(n) {
+    var key = text(n)
+    if (cache[key]) return cache[key]
+    var result = null
+    if (n <= 1) {
+      result = n
+    } else {
+      result = fib(n - 1) + fib(n - 2)
+    }
+    cache[key] = result
+    return result
+  }
+  return fib
+}
+
+// CPS (continuation passing style) — tests closure creation
+function fib_cps(n, cont) {
+  if (n <= 1) return cont(n)
+  return fib_cps(n - 1, function(a) {
+    return fib_cps(n - 2, function(b) {
+      return cont(a + b)
+    })
+  })
+}
+
+// Matrix exponentiation style (accumulator)
+function fib_matrix(n) {
+  var a = 1
+  var b = 0
+  var c = 0
+  var d = 1
+  var ta = 0
+  var tb = 0
+  var m = n
+  while (m > 0) {
+    if (m % 2 == 1) {
+      ta = a * d + b * c // wrong but stresses numeric ops
+      tb = b * d + a * c
+      a = ta
+      b = tb
+    }
+    ta = c * c + d * d
+    tb = d * (2 * c + d)
+    c = ta
+    d = tb
+    m = floor(m / 2)
+  }
+  return b
+}
+
+return {
+  fib_naive_25: function(n) {
+    var i = 0
+    var x = 0
+    for (i = 0; i < n; i++) x += fib_naive(25)
+    return x
+  },
+
+  fib_naive_30: function(n) {
+    var i = 0
+    var x = 0
+    for (i = 0; i < n; i++) x += fib_naive(30)
+    return x
+  },
+
+  fib_iter_80: function(n) {
+    var i = 0
+    var x = 0
+    for (i = 0; i < n; i++) x += fib_iter(80)
+    return x
+  },
+
+  fib_memo_100: function(n) {
+    var i = 0
+    var x = 0
+    var fib = null
+    for (i = 0; i < n; i++) {
+      fib = make_memo_fib()
+      x += fib(100)
+    }
+    return x
+  },
+
+  fib_cps_20: function(n) {
+    var i = 0
+    var x = 0
+    var identity = function(v) { return v }
+    for (i = 0; i < n; i++) {
+      x += fib_cps(20, identity)
+    }
+    return x
+  },
+
+  fib_matrix_80: function(n) {
+    var i = 0
+    var x = 0
+    for (i = 0; i < n; i++) x += fib_matrix(80)
+    return x
+  }
+}

benches/hash_workload.cm

@@ -0,0 +1,159 @@
+// hash_workload.cm — Hash-heavy / word-count / map-reduce kernel
+// Stresses record (object) creation, property access, and string handling.
+
+function make_words(count) {
+  // Generate a repeating word list to simulate text processing
+  var base_words = [
+    "the", "quick", "brown", "fox", "jumps", "over", "lazy", "dog",
+    "and", "cat", "sat", "on", "mat", "with", "hat", "bat",
+    "alpha", "beta", "gamma", "delta", "epsilon", "zeta", "eta", "theta",
+    "hello", "world", "foo", "bar", "baz", "qux", "quux", "corge"
+  ]
+  var words = []
+  var i = 0
+  for (i = 0; i < count; i++) {
+    push(words, base_words[i % length(base_words)])
+  }
+  return words
+}
+
+// Word frequency count
+function word_count(words) {
+  var freq = {}
+  var i = 0
+  var w = null
+  for (i = 0; i < length(words); i++) {
+    w = words[i]
+    if (freq[w]) {
+      freq[w] = freq[w] + 1
+    } else {
+      freq[w] = 1
+    }
+  }
+  return freq
+}
+
+// Find top-N words by frequency
+function top_n(freq, n) {
+  var keys = array(freq)
+  var pairs = []
+  var i = 0
+  for (i = 0; i < length(keys); i++) {
+    push(pairs, {word: keys[i], count: freq[keys[i]]})
+  }
+  var sorted = sort(pairs, "count")
+  // Return last N (highest counts)
+  var result = []
+  var start = length(sorted) - n
+  if (start < 0) start = 0
+  for (i = start; i < length(sorted); i++) {
+    push(result, sorted[i])
+  }
+  return result
+}
+
+// Histogram: group words by length
+function group_by_length(words) {
+  var groups = {}
+  var i = 0
+  var w = null
+  var k = null
+  for (i = 0; i < length(words); i++) {
+    w = words[i]
+    k = text(length(w))
+    if (!groups[k]) groups[k] = []
+    push(groups[k], w)
+  }
+  return groups
+}
+
+// Simple hash table with chaining (stress property access patterns)
+function hash_table_ops(n) {
+  var table = {}
+  var i = 0
+  var k = null
+  var collisions = 0
+
+  // Insert phase
+  for (i = 0; i < n; i++) {
+    k = `key_${i % 512}`
+    if (table[k]) collisions++
+    table[k] = i
+  }
+
+  // Lookup phase
+  var found = 0
+  for (i = 0; i < n; i++) {
+    k = `key_${i % 512}`
+    if (table[k]) found++
+  }
+
+  // Delete phase
+  var deleted = 0
+  for (i = 0; i < n; i += 3) {
+    k = `key_${i % 512}`
+    if (table[k]) {
+      delete table[k]
+      deleted++
+    }
+  }
+
+  return found - deleted + collisions
+}
+
+var words_1k = make_words(1000)
+var words_10k = make_words(10000)
+
+return {
+  // Word count on 1K words
+  wordcount_1k: function(n) {
+    var i = 0
+    var freq = null
+    for (i = 0; i < n; i++) {
+      freq = word_count(words_1k)
+    }
+    return freq
+  },
+
+  // Word count on 10K words
+  wordcount_10k: function(n) {
+    var i = 0
+    var freq = null
+    for (i = 0; i < n; i++) {
+      freq = word_count(words_10k)
+    }
+    return freq
+  },
+
+  // Word count + top-10 extraction
+  wordcount_top10: function(n) {
+    var i = 0
+    var freq = null
+    var top = null
+    for (i = 0; i < n; i++) {
+      freq = word_count(words_10k)
+      top = top_n(freq, 10)
+    }
+    return top
+  },
+
+  // Group words by length
+  group_by_len: function(n) {
+    var i = 0
+    var groups = null
+    for (i = 0; i < n; i++) {
+      groups = group_by_length(words_10k)
+    }
+    return groups
+  },
+
+  // Hash table insert/lookup/delete
+  hash_table: function(n) {
+    var i = 0
+    var x = 0
+    for (i = 0; i < n; i++) {
+      x += hash_table_ops(2048)
+    }
+    return x
+  }
+}

benches/json_walk.cm

@@ -0,0 +1,167 @@
+// json_walk.cm — JSON parse + walk + serialize kernel
+// Stresses strings, records, arrays, and recursive traversal.
+
+var json = use('json')
+
+function make_nested_object(depth, breadth) {
+  var obj = {}
+  var i = 0
+  var k = null
+  if (depth <= 0) {
+    for (i = 0; i < breadth; i++) {
+      k = `key_${i}`
+      obj[k] = i * 3.14
+    }
+    return obj
+  }
+  for (i = 0; i < breadth; i++) {
+    k = `node_${i}`
+    obj[k] = make_nested_object(depth - 1, breadth)
+  }
+  obj.value = depth
+  obj.name = `level_${depth}`
+  return obj
+}
+
+function make_array_data(size) {
+  var arr = []
+  var i = 0
+  for (i = 0; i < size; i++) {
+    push(arr, {
+      id: i,
+      name: `item_${i}`,
+      active: i % 2 == 0,
+      score: i * 1.5,
+      tags: [`tag_${i % 5}`, `tag_${(i + 1) % 5}`]
+    })
+  }
+  return arr
+}
+
+// Walk an object tree, counting nodes
+function walk_count(obj) {
+  var count = 1
+  var keys = null
+  var i = 0
+  var v = null
+  if (is_object(obj)) {
+    keys = array(obj)
+    for (i = 0; i < length(keys); i++) {
+      v = obj[keys[i]]
+      if (is_object(v) || is_array(v)) {
+        count += walk_count(v)
+      }
+    }
+  } else if (is_array(obj)) {
+    for (i = 0; i < length(obj); i++) {
+      v = obj[i]
+      if (is_object(v) || is_array(v)) {
+        count += walk_count(v)
+      }
+    }
+  }
+  return count
+}
+
+// Walk and extract all numbers
+function walk_sum(obj) {
+  var sum = 0
+  var keys = null
+  var i = 0
+  var v = null
+  if (is_object(obj)) {
+    keys = array(obj)
+    for (i = 0; i < length(keys); i++) {
+      v = obj[keys[i]]
+      if (is_number(v)) {
+        sum += v
+      } else if (is_object(v) || is_array(v)) {
+        sum += walk_sum(v)
+      }
+    }
+  } else if (is_array(obj)) {
+    for (i = 0; i < length(obj); i++) {
+      v = obj[i]
+      if (is_number(v)) {
+        sum += v
+      } else if (is_object(v) || is_array(v)) {
+        sum += walk_sum(v)
+      }
+    }
+  }
+  return sum
+}
+
+// Pre-build test data strings
+var nested_obj = make_nested_object(3, 4)
+var nested_json = json.encode(nested_obj)
+var array_data = make_array_data(200)
+var array_json = json.encode(array_data)
+
+return {
+  // Parse nested JSON
+  json_parse_nested: function(n) {
+    var i = 0
+    var obj = null
+    for (i = 0; i < n; i++) {
+      obj = json.decode(nested_json)
+    }
+    return obj
+  },
+
+  // Parse array-of-records JSON
+  json_parse_array: function(n) {
+    var i = 0
+    var arr = null
+    for (i = 0; i < n; i++) {
+      arr = json.decode(array_json)
+    }
+    return arr
+  },
+
+  // Encode nested object to JSON
+  json_encode_nested: function(n) {
+    var i = 0
+    var s = null
+    for (i = 0; i < n; i++) {
+      s = json.encode(nested_obj)
+    }
+    return s
+  },
+
+  // Encode array to JSON
+  json_encode_array: function(n) {
+    var i = 0
+    var s = null
+    for (i = 0; i < n; i++) {
+      s = json.encode(array_data)
+    }
+    return s
+  },
+
+  // Parse + walk + count
+  json_roundtrip_walk: function(n) {
+    var i = 0
+    var obj = null
+    var count = 0
+    for (i = 0; i < n; i++) {
+      obj = json.decode(nested_json)
+      count += walk_count(obj)
+    }
+    return count
+  },
+
+  // Parse + sum all numbers + re-encode
+  json_roundtrip_full: function(n) {
+    var i = 0
+    var obj = null
+    var sum = 0
+    var out = null
+    for (i = 0; i < n; i++) {
+      obj = json.decode(array_json)
+      sum += walk_sum(obj)
+      out = json.encode(obj)
+    }
+    return sum
+  }
+}

benches/micro_ops.cm

@@ -1,24 +1,24 @@
-// micro_ops.bench.ce (or .cm depending on your convention)
+// micro_ops.cm — microbenchmarks for core operations
 
-// Note: We use a function-local sink in each benchmark to avoid cross-contamination
 function blackhole(sink, x) {
-  // Prevent dead-code elimination
   return (sink + (x | 0)) | 0
 }
 
 function make_obj_xy(x, y) {
-  return { x, y }
+  return {x: x, y: y}
 }
 
 function make_obj_yx(x, y) {
-  // Different insertion order to force a different shape in many engines
-  return { y, x }
+  // Different insertion order to force a different shape
+  return {y: y, x: x}
 }
 
 function make_shapes(n) {
   var out = []
-  for (var i = 0; i < n; i++) {
-    var o = { a: i }
+  var i = 0
+  var o = null
+  for (i = 0; i < n; i++) {
+    o = {a: i}
     o[`p${i}`] = i
     push(out, o)
   }
@@ -27,13 +27,15 @@ function make_shapes(n) {
 
 function make_packed_array(n) {
   var a = []
-  for (var i = 0; i < n; i++) push(a, i)
+  var i = 0
+  for (i = 0; i < n; i++) push(a, i)
   return a
 }
 
 function make_holey_array(n) {
   var a = []
-  for (var i = 0; i < n; i += 2) a[i] = i
+  var i = 0
+  for (i = 0; i < n; i += 2) a[i] = i
   return a
 }
 
@@ -41,7 +43,8 @@ return {
   // 0) Baseline loop cost
   loop_empty: function(n) {
     var sink = 0
-    for (var i = 0; i < n; i++) {}
+    var i = 0
+    for (i = 0; i < n; i++) {}
     return blackhole(sink, n)
   },
 
@@ -49,35 +52,40 @@ return {
   i32_add: function(n) {
     var sink = 0
     var x = 1
-    for (var i = 0; i < n; i++) x = (x + 3) | 0
+    var i = 0
+    for (i = 0; i < n; i++) x = (x + 3) | 0
     return blackhole(sink, x)
   },
 
   f64_add: function(n) {
     var sink = 0
     var x = 1.0
-    for (var i = 0; i < n; i++) x = x + 3.14159
+    var i = 0
+    for (i = 0; i < n; i++) x = x + 3.14159
     return blackhole(sink, x | 0)
   },
 
   mixed_add: function(n) {
     var sink = 0
     var x = 1
-    for (var i = 0; i < n; i++) x = x + 0.25
+    var i = 0
+    for (i = 0; i < n; i++) x = x + 0.25
     return blackhole(sink, x | 0)
   },
 
   bit_ops: function(n) {
     var sink = 0
     var x = 0x12345678
-    for (var i = 0; i < n; i++) x = ((x << 5) ^ (x >>> 3)) | 0
+    var i = 0
+    for (i = 0; i < n; i++) x = ((x << 5) ^ (x >>> 3)) | 0
     return blackhole(sink, x)
   },
 
   overflow_path: function(n) {
     var sink = 0
     var x = 0x70000000
-    for (var i = 0; i < n; i++) x = (x + 0x10000000) | 0
+    var i = 0
+    for (i = 0; i < n; i++) x = (x + 0x10000000) | 0
     return blackhole(sink, x)
   },
 
@@ -85,7 +93,8 @@ return {
   branch_predictable: function(n) {
     var sink = 0
     var x = 0
-    for (var i = 0; i < n; i++) {
+    var i = 0
+    for (i = 0; i < n; i++) {
       if ((i & 7) != 0) x++
       else x += 2
     }
@@ -95,7 +104,8 @@ return {
   branch_alternating: function(n) {
     var sink = 0
     var x = 0
-    for (var i = 0; i < n; i++) {
+    var i = 0
+    for (i = 0; i < n; i++) {
       if ((i & 1) == 0) x++
       else x += 2
     }
@@ -105,29 +115,47 @@ return {
   // 3) Calls
   call_direct: function(n) {
     var sink = 0
-    function f(a) { return (a + 1) | 0 }
+    var f = function(a) { return (a + 1) | 0 }
     var x = 0
-    for (var i = 0; i < n; i++) x = f(x)
+    var i = 0
+    for (i = 0; i < n; i++) x = f(x)
     return blackhole(sink, x)
   },
 
   call_indirect: function(n) {
     var sink = 0
-    function f(a) { return (a + 1) | 0 }
+    var f = function(a) { return (a + 1) | 0 }
     var g = f
     var x = 0
-    for (var i = 0; i < n; i++) x = g(x)
+    var i = 0
+    for (i = 0; i < n; i++) x = g(x)
     return blackhole(sink, x)
   },
 
   call_closure: function(n) {
     var sink = 0
-    function make_adder(k) {
+    var make_adder = function(k) {
       return function(a) { return (a + k) | 0 }
     }
     var add3 = make_adder(3)
     var x = 0
-    for (var i = 0; i < n; i++) x = add3(x)
+    var i = 0
+    for (i = 0; i < n; i++) x = add3(x)
+    return blackhole(sink, x)
+  },
+
+  call_multi_arity: function(n) {
+    var sink = 0
+    var f0 = function() { return 1 }
+    var f1 = function(a) { return a + 1 }
+    var f2 = function(a, b) { return a + b }
+    var f3 = function(a, b, c) { return a + b + c }
+    var f4 = function(a, b, c, d) { return a + b + c + d }
+    var x = 0
+    var i = 0
+    for (i = 0; i < n; i++) {
+      x = (x + f0() + f1(i) + f2(i, 1) + f3(i, 1, 2) + f4(i, 1, 2, 3)) | 0
+    }
     return blackhole(sink, x)
   },
 
@@ -136,7 +164,8 @@ return {
     var sink = 0
     var o = make_obj_xy(1, 2)
     var x = 0
-    for (var i = 0; i < n; i++) x = (x + o.x) | 0
+    var i = 0
+    for (i = 0; i < n; i++) x = (x + o.x) | 0
     return blackhole(sink, x)
   },
 
@@ -145,20 +174,38 @@ return {
     var a = make_obj_xy(1, 2)
     var b = make_obj_yx(1, 2)
     var x = 0
-    for (var i = 0; i < n; i++) {
-      var o = (i & 1) == 0 ? a : b
+    var i = 0
+    var o = null
+    for (i = 0; i < n; i++) {
+      o = (i & 1) == 0 ? a : b
       x = (x + o.x) | 0
     }
     return blackhole(sink, x)
   },
 
+  prop_read_poly_4: function(n) {
+    var sink = 0
+    var shapes = [
+      {x: 1, y: 2},
+      {y: 2, x: 1},
+      {x: 1, z: 3, y: 2},
+      {w: 0, x: 1, y: 2}
+    ]
+    var x = 0
+    var i = 0
+    for (i = 0; i < n; i++) {
+      x = (x + shapes[i & 3].x) | 0
+    }
+    return blackhole(sink, x)
+  },
+
   prop_read_mega: function(n) {
     var sink = 0
     var objs = make_shapes(32)
     var x = 0
-    for (var i = 0; i < n; i++) {
-      var o = objs[i & 31]
-      x = (x + o.a) | 0
+    var i = 0
+    for (i = 0; i < n; i++) {
+      x = (x + objs[i & 31].a) | 0
     }
     return blackhole(sink, x)
   },
@@ -166,7 +213,8 @@ return {
   prop_write_mono: function(n) {
     var sink = 0
     var o = make_obj_xy(1, 2)
-    for (var i = 0; i < n; i++) o.x = (o.x + 1) | 0
+    var i = 0
+    for (i = 0; i < n; i++) o.x = (o.x + 1) | 0
     return blackhole(sink, o.x)
   },
 
@@ -175,14 +223,16 @@ return {
     var sink = 0
     var a = make_packed_array(1024)
     var x = 0
-    for (var i = 0; i < n; i++) x = (x + a[i & 1023]) | 0
+    var i = 0
+    for (i = 0; i < n; i++) x = (x + a[i & 1023]) | 0
     return blackhole(sink, x)
   },
 
   array_write_packed: function(n) {
     var sink = 0
     var a = make_packed_array(1024)
-    for (var i = 0; i < n; i++) a[i & 1023] = i
+    var i = 0
+    for (i = 0; i < n; i++) a[i & 1023] = i
     return blackhole(sink, a[17] | 0)
   },
 
@@ -190,9 +240,10 @@ return {
     var sink = 0
     var a = make_holey_array(2048)
     var x = 0
-    for (var i = 0; i < n; i++) {
-      var v = a[(i & 2047)]
-      // If "missing" is a special value in your language, this stresses that path too
+    var i = 0
+    var v = null
+    for (i = 0; i < n; i++) {
+      v = a[(i & 2047)]
       if (v) x = (x + v) | 0
     }
     return blackhole(sink, x)
@@ -201,21 +252,97 @@ return {
   array_push_steady: function(n) {
     var sink = 0
     var x = 0
-    for (var j = 0; j < n; j++) {
-      var a = []
-      for (var i = 0; i < 256; i++) push(a, i)
+    var j = 0
+    var i = 0
+    var a = null
+    for (j = 0; j < n; j++) {
+      a = []
+      for (i = 0; i < 256; i++) push(a, i)
       x = (x + length(a)) | 0
     }
     return blackhole(sink, x)
   },
 
+  array_push_pop: function(n) {
+    var sink = 0
+    var a = []
+    var x = 0
+    var i = 0
+    var v = 0
+    for (i = 0; i < n; i++) {
+      push(a, i)
+      if (length(a) > 64) {
+        v = pop(a)
+        x = (x + v) | 0
+      }
+    }
+    return blackhole(sink, x)
+  },
+
+  array_indexed_sum: function(n) {
+    var sink = 0
+    var a = make_packed_array(1024)
+    var x = 0
+    var j = 0
+    var i = 0
+    for (j = 0; j < n; j++) {
+      x = 0
+      for (i = 0; i < 1024; i++) {
+        x = (x + a[i]) | 0
+      }
+    }
+    return blackhole(sink, x)
+  },
+
   // 6) Strings
   string_concat_small: function(n) {
     var sink = 0
     var x = 0
-    for (var j = 0; j < n; j++) {
-      var s = ""
-      for (var i = 0; i < 16; i++) s = s + "x"
+    var j = 0
+    var i = 0
+    var s = null
+    for (j = 0; j < n; j++) {
+      s = ""
+      for (i = 0; i < 16; i++) s = s + "x"
+      x = (x + length(s)) | 0
+    }
+    return blackhole(sink, x)
+  },
+
+  string_concat_medium: function(n) {
+    var sink = 0
+    var x = 0
+    var j = 0
+    var i = 0
+    var s = null
+    for (j = 0; j < n; j++) {
+      s = ""
+      for (i = 0; i < 100; i++) s = s + "abcdefghij"
+      x = (x + length(s)) | 0
+    }
+    return blackhole(sink, x)
+  },
+
+  string_interpolation: function(n) {
+    var sink = 0
+    var x = 0
+    var i = 0
+    var s = null
+    for (i = 0; i < n; i++) {
+      s = `item_${i}_value_${i * 2}`
+      x = (x + length(s)) | 0
+    }
+    return blackhole(sink, x)
+  },
+
+  string_slice: function(n) {
+    var sink = 0
+    var base = "the quick brown fox jumps over the lazy dog"
+    var x = 0
+    var i = 0
+    var s = null
+    for (i = 0; i < n; i++) {
+      s = text(base, i % 10, i % 10 + 10)
       x = (x + length(s)) | 0
     }
     return blackhole(sink, x)
@@ -225,8 +352,10 @@ return {
   alloc_tiny_objects: function(n) {
     var sink = 0
     var x = 0
-    for (var i = 0; i < n; i++) {
-      var o = { a: i, b: i + 1, c: i + 2 }
+    var i = 0
+    var o = null
+    for (i = 0; i < n; i++) {
+      o = {a: i, b: i + 1, c: i + 2}
       x = (x + o.b) | 0
     }
     return blackhole(sink, x)
@@ -235,9 +364,12 @@ return {
   alloc_linked_list: function(n) {
     var sink = 0
     var head = null
-    for (var i = 0; i < n; i++) head = { v: i, next: head }
+    var i = 0
     var x = 0
-    var p = head
+    var p = null
+    for (i = 0; i < n; i++) head = {v: i, next: head}
+    x = 0
+    p = head
     while (p) {
       x = (x + p.v) | 0
       p = p.next
@@ -245,18 +377,118 @@ return {
     return blackhole(sink, x)
   },
 
-  // 8) meme-specific (adapt these to your exact semantics)
-  meme_clone_read: function(n) {
-    // If meme(obj) clones like Object.create / prototypal clone, this hits it hard.
-    // Replace with your exact meme call form.
+  alloc_arrays: function(n) {
     var sink = 0
-    var base = { x: 1, y: 2 }
     var x = 0
-    for (var i = 0; i < n; i++) {
-      var o = meme(base)
+    var i = 0
+    var a = null
+    for (i = 0; i < n; i++) {
+      a = [i, i + 1, i + 2, i + 3]
+      x = (x + a[2]) | 0
+    }
+    return blackhole(sink, x)
+  },
+
+  alloc_short_lived: function(n) {
+    var sink = 0
+    var x = 0
+    var i = 0
+    var o = null
+    // Allocate objects that immediately become garbage
+    for (i = 0; i < n; i++) {
+      o = {val: i, data: {inner: i + 1}}
+      x = (x + o.data.inner) | 0
+    }
+    return blackhole(sink, x)
+  },
+
+  alloc_long_lived_pressure: function(n) {
+    var sink = 0
+    var store = []
+    var x = 0
+    var i = 0
+    var o = null
+    // Keep first 1024 objects alive, churn the rest
+    for (i = 0; i < n; i++) {
+      o = {val: i, data: i * 2}
+      if (i < 1024) {
+        push(store, o)
+      }
+      x = (x + o.data) | 0
+    }
+    return blackhole(sink, x)
+  },
+
+  // 8) Meme (prototype clone)
+  meme_clone_read: function(n) {
+    var sink = 0
+    var base = {x: 1, y: 2}
+    var x = 0
+    var i = 0
+    var o = null
+    for (i = 0; i < n; i++) {
+      o = meme(base)
       x = (x + o.x) | 0
     }
     return blackhole(sink, x)
   },
 
+  // 9) Guard / type check paths
+  guard_hot_number: function(n) {
+    // Monomorphic number path — guards should hoist
+    var sink = 0
+    var x = 1
+    var i = 0
+    for (i = 0; i < n; i++) x = x + 1
+    return blackhole(sink, x | 0)
+  },
+
+  guard_mixed_types: function(n) {
+    // Alternating number/text — guards must stay
+    var sink = 0
+    var vals = [1, "a", 2, "b", 3, "c", 4, "d"]
+    var x = 0
+    var i = 0
+    for (i = 0; i < n; i++) {
+      if (is_number(vals[i & 7])) x = (x + vals[i & 7]) | 0
+    }
+    return blackhole(sink, x)
+  },
+
+  // 10) Reduce / higher-order
+  reduce_sum: function(n) {
+    var sink = 0
+    var a = make_packed_array(256)
+    var x = 0
+    var i = 0
+    for (i = 0; i < n; i++) {
+      x = (x + reduce(a, function(acc, v) { return acc + v }, 0)) | 0
+    }
+    return blackhole(sink, x)
+  },
+
+  filter_evens: function(n) {
+    var sink = 0
+    var a = make_packed_array(256)
+    var x = 0
+    var i = 0
+    for (i = 0; i < n; i++) {
+      x = (x + length(filter(a, function(v) { return v % 2 == 0 }))) | 0
+    }
+    return blackhole(sink, x)
+  },
+
+  arrfor_sum: function(n) {
+    var sink = 0
+    var a = make_packed_array(256)
+    var x = 0
+    var i = 0
+    var sum = 0
+    for (i = 0; i < n; i++) {
+      sum = 0
+      arrfor(a, function(v) { sum += v })
+      x = (x + sum) | 0
+    }
+    return blackhole(sink, x)
+  }
 }

benches/module_load.cm

@@ -0,0 +1,249 @@
+// module_load.cm — Module loading simulation (macro benchmark)
+// Simulates parsing many small modules, linking, and running.
+// Tests the "build scenario" pattern.
+
+var json = use('json')
+
+// Simulate a small module: parse token stream + build AST + evaluate
+function tokenize(src) {
+  var tokens = []
+  var i = 0
+  var ch = null
+  var chars = array(src)
+  var buf = ""
+
+  for (i = 0; i < length(chars); i++) {
+    ch = chars[i]
+    if (ch == " " || ch == "\n" || ch == "\t") {
+      if (length(buf) > 0) {
+        push(tokens, buf)
+        buf = ""
+      }
+    } else if (ch == "(" || ch == ")" || ch == "+" || ch == "-"
+            || ch == "*" || ch == "=" || ch == ";" || ch == ",") {
+      if (length(buf) > 0) {
+        push(tokens, buf)
+        buf = ""
+      }
+      push(tokens, ch)
+    } else {
+      buf = buf + ch
+    }
+  }
+  if (length(buf) > 0) push(tokens, buf)
+  return tokens
+}
+
+// Build a simple AST from tokens
+function parse_tokens(tokens) {
+  var ast = []
+  var i = 0
+  var tok = null
+  var node = null
+  for (i = 0; i < length(tokens); i++) {
+    tok = tokens[i]
+    if (tok == "var" || tok == "def") {
+      node = {type: "decl", kind: tok, name: null, value: null}
+      i++
+      if (i < length(tokens)) node.name = tokens[i]
+      i++ // skip =
+      i++
+      if (i < length(tokens)) node.value = tokens[i]
+      push(ast, node)
+    } else if (tok == "return") {
+      node = {type: "return", value: null}
+      i++
+      if (i < length(tokens)) node.value = tokens[i]
+      push(ast, node)
+    } else if (tok == "function") {
+      node = {type: "func", name: null, body: []}
+      i++
+      if (i < length(tokens)) node.name = tokens[i]
+      // Skip to matching )
+      while (i < length(tokens) && tokens[i] != ")") i++
+      push(ast, node)
+    } else {
+      push(ast, {type: "expr", value: tok})
+    }
+  }
+  return ast
+}
+
+// Evaluate: simple symbol table + resolution
+function evaluate(ast, env) {
+  var result = null
+  var i = 0
+  var node = null
+  for (i = 0; i < length(ast); i++) {
+    node = ast[i]
+    if (node.type == "decl") {
+      env[node.name] = node.value
+    } else if (node.type == "return") {
+      result = node.value
+      if (env[result]) result = env[result]
+    } else if (node.type == "func") {
+      env[node.name] = node
+    }
+  }
+  return result
+}
+
+// Generate fake module source code
+function generate_module(id, dep_count) {
+  var src = ""
+  var i = 0
+  src = src + "var _id = " + text(id) + ";\n"
+  for (i = 0; i < dep_count; i++) {
+    src = src + "var dep" + text(i) + " = use(mod_" + text(i) + ");\n"
+  }
+  src = src + "var x = " + text(id * 17) + ";\n"
+  src = src + "var y = " + text(id * 31) + ";\n"
+  src = src + "function compute(a, b) { return a + b; }\n"
+  src = src + "var result = compute(x, y);\n"
+  src = src + "return result;\n"
+  return src
+}
+
+// Simulate loading N modules with dependency chains
+function simulate_build(n_modules, deps_per_module) {
+  var modules = []
+  var loaded = {}
+  var i = 0
+  var j = 0
+  var src = null
+  var tokens = null
+  var ast = null
+  var env = null
+  var result = null
+  var total_tokens = 0
+  var total_nodes = 0
+
+  // Generate all module sources
+  for (i = 0; i < n_modules; i++) {
+    src = generate_module(i, deps_per_module)
+    push(modules, src)
+  }
+
+  // "Load" each module: tokenize → parse → evaluate
+  for (i = 0; i < n_modules; i++) {
+    tokens = tokenize(modules[i])
+    total_tokens += length(tokens)
+
+    ast = parse_tokens(tokens)
+    total_nodes += length(ast)
+
+    env = {}
+    // Resolve dependencies
+    for (j = 0; j < deps_per_module; j++) {
+      if (j < i) {
+        env["dep" + text(j)] = loaded["mod_" + text(j)]
+      }
+    }
+
+    result = evaluate(ast, env)
+    loaded["mod_" + text(i)] = result
+  }
+
+  return {
+    modules: n_modules,
+    total_tokens: total_tokens,
+    total_nodes: total_nodes,
+    last_result: result
+  }
+}
+
+// Dependency graph analysis (topological sort simulation)
+function topo_sort(n_modules, deps_per_module) {
+  // Build adjacency list
+  var adj = {}
+  var in_degree = {}
+  var i = 0
+  var j = 0
+  var name = null
+  var dep = null
+
+  for (i = 0; i < n_modules; i++) {
+    name = "mod_" + text(i)
+    adj[name] = []
+    in_degree[name] = 0
+  }
+
+  for (i = 0; i < n_modules; i++) {
+    name = "mod_" + text(i)
+    for (j = 0; j < deps_per_module; j++) {
+      if (j < i) {
+        dep = "mod_" + text(j)
+        push(adj[dep], name)
+        in_degree[name] = in_degree[name] + 1
+      }
+    }
+  }
+
+  // Kahn's algorithm
+  var queue = []
+  var keys = array(in_degree)
+  for (i = 0; i < length(keys); i++) {
+    if (in_degree[keys[i]] == 0) push(queue, keys[i])
+  }
+
+  var order = []
+  var current = null
+  var neighbors = null
+  var qi = 0
+  while (qi < length(queue)) {
+    current = queue[qi]
+    qi++
+    push(order, current)
+    neighbors = adj[current]
+    if (neighbors) {
+      for (i = 0; i < length(neighbors); i++) {
+        in_degree[neighbors[i]] = in_degree[neighbors[i]] - 1
+        if (in_degree[neighbors[i]] == 0) push(queue, neighbors[i])
+      }
+    }
+  }
+
+  return order
+}
+
+return {
+  // Small build: 50 modules, 3 deps each
+  build_50: function(n) {
+    var i = 0
+    var result = null
+    for (i = 0; i < n; i++) {
+      result = simulate_build(50, 3)
+    }
+    return result
+  },
+
+  // Medium build: 200 modules, 5 deps each
+  build_200: function(n) {
+    var i = 0
+    var result = null
+    for (i = 0; i < n; i++) {
+      result = simulate_build(200, 5)
+    }
+    return result
+  },
+
+  // Large build: 500 modules, 5 deps each
+  build_500: function(n) {
+    var i = 0
+    var result = null
+    for (i = 0; i < n; i++) {
+      result = simulate_build(500, 5)
+    }
+    return result
+  },
+
+  // Topo sort of 500 module dependency graph
+  topo_sort_500: function(n) {
+    var i = 0
+    var order = null
+    for (i = 0; i < n; i++) {
+      order = topo_sort(500, 5)
+    }
+    return order
+  }
+}

benches/nbody.cm

@@ -0,0 +1,160 @@
+// nbody.cm — N-body gravitational simulation kernel
+// Pure numeric + allocation workload. Classic VM benchmark.
+
+var math = use('math/radians')
+
+def PI = 3.141592653589793
+def SOLAR_MASS = 4 * PI * PI
+def DAYS_PER_YEAR = 365.24
+
+function make_system() {
+  // Sun + 4 Jovian planets
+  var sun = {x: 0, y: 0, z: 0, vx: 0, vy: 0, vz: 0, mass: SOLAR_MASS}
+
+  var jupiter = {
+    x: 4.84143144246472090,
+    y: -1.16032004402742839,
+    z: -0.103622044471123109,
+    vx: 0.00166007664274403694 * DAYS_PER_YEAR,
+    vy: 0.00769901118419740425 * DAYS_PER_YEAR,
+    vz: -0.0000690460016972063023 * DAYS_PER_YEAR,
+    mass: 0.000954791938424326609 * SOLAR_MASS
+  }
+
+  var saturn = {
+    x: 8.34336671824457987,
+    y: 4.12479856412430479,
+    z: -0.403523417114321381,
+    vx: -0.00276742510726862411 * DAYS_PER_YEAR,
+    vy: 0.00499852801234917238 * DAYS_PER_YEAR,
+    vz: 0.0000230417297573763929 * DAYS_PER_YEAR,
+    mass: 0.000285885980666130812 * SOLAR_MASS
+  }
+
+  var uranus = {
+    x: 12.8943695621391310,
+    y: -15.1111514016986312,
+    z: -0.223307578892655734,
+    vx: 0.00296460137564761618 * DAYS_PER_YEAR,
+    vy: 0.00237847173959480950 * DAYS_PER_YEAR,
+    vz: -0.0000296589568540237556 * DAYS_PER_YEAR,
+    mass: 0.0000436624404335156298 * SOLAR_MASS
+  }
+
+  var neptune = {
+    x: 15.3796971148509165,
+    y: -25.9193146099879641,
+    z: 0.179258772950371181,
+    vx: 0.00268067772490389322 * DAYS_PER_YEAR,
+    vy: 0.00162824170038242295 * DAYS_PER_YEAR,
+    vz: -0.0000951592254519715870 * DAYS_PER_YEAR,
+    mass: 0.0000515138902046611451 * SOLAR_MASS
+  }
+
+  var bodies = [sun, jupiter, saturn, uranus, neptune]
+
+  // Offset momentum
+  var px = 0
+  var py = 0
+  var pz = 0
+  var i = 0
+  for (i = 0; i < length(bodies); i++) {
+    px += bodies[i].vx * bodies[i].mass
+    py += bodies[i].vy * bodies[i].mass
+    pz += bodies[i].vz * bodies[i].mass
+  }
+  sun.vx = -px / SOLAR_MASS
+  sun.vy = -py / SOLAR_MASS
+  sun.vz = -pz / SOLAR_MASS
+
+  return bodies
+}
+
+function advance(bodies, dt) {
+  var n = length(bodies)
+  var i = 0
+  var j = 0
+  var bi = null
+  var bj = null
+  var dx = 0
+  var dy = 0
+  var dz = 0
+  var dist_sq = 0
+  var dist = 0
+  var mag = 0
+
+  for (i = 0; i < n; i++) {
+    bi = bodies[i]
+    for (j = i + 1; j < n; j++) {
+      bj = bodies[j]
+      dx = bi.x - bj.x
+      dy = bi.y - bj.y
+      dz = bi.z - bj.z
+      dist_sq = dx * dx + dy * dy + dz * dz
+      dist = math.sqrt(dist_sq)
+      mag = dt / (dist_sq * dist)
+
+      bi.vx -= dx * bj.mass * mag
+      bi.vy -= dy * bj.mass * mag
+      bi.vz -= dz * bj.mass * mag
+      bj.vx += dx * bi.mass * mag
+      bj.vy += dy * bi.mass * mag
+      bj.vz += dz * bi.mass * mag
+    }
+  }
+
+  for (i = 0; i < n; i++) {
+    bi = bodies[i]
+    bi.x += dt * bi.vx
+    bi.y += dt * bi.vy
+    bi.z += dt * bi.vz
+  }
+}
+
+function energy(bodies) {
+  var e = 0
+  var n = length(bodies)
+  var i = 0
+  var j = 0
+  var bi = null
+  var bj = null
+  var dx = 0
+  var dy = 0
+  var dz = 0
+  for (i = 0; i < n; i++) {
+    bi = bodies[i]
+    e += 0.5 * bi.mass * (bi.vx * bi.vx + bi.vy * bi.vy + bi.vz * bi.vz)
+    for (j = i + 1; j < n; j++) {
+      bj = bodies[j]
+      dx = bi.x - bj.x
+      dy = bi.y - bj.y
+      dz = bi.z - bj.z
+      e -= (bi.mass * bj.mass) / math.sqrt(dx * dx + dy * dy + dz * dz)
+    }
+  }
+  return e
+}
+
+return {
+  nbody_1k: function(n) {
+    var i = 0
+    var j = 0
+    var bodies = null
+    for (i = 0; i < n; i++) {
+      bodies = make_system()
+      for (j = 0; j < 1000; j++) advance(bodies, 0.01)
+      energy(bodies)
+    }
+  },
+
+  nbody_10k: function(n) {
+    var i = 0
+    var j = 0
+    var bodies = null
+    for (i = 0; i < n; i++) {
+      bodies = make_system()
+      for (j = 0; j < 10000; j++) advance(bodies, 0.01)
+      energy(bodies)
+    }
+  }
+}

benches/ray_tracer.cm

@@ -0,0 +1,154 @@
+// ray_tracer.cm — Simple ray tracer kernel
+// Control flow + numeric + allocation. Classic VM benchmark.
+
+var math = use('math/radians')
+
+function vec(x, y, z) {
+  return {x: x, y: y, z: z}
+}
+
+function vadd(a, b) {
+  return {x: a.x + b.x, y: a.y + b.y, z: a.z + b.z}
+}
+
+function vsub(a, b) {
+  return {x: a.x - b.x, y: a.y - b.y, z: a.z - b.z}
+}
+
+function vmul(v, s) {
+  return {x: v.x * s, y: v.y * s, z: v.z * s}
+}
+
+function vdot(a, b) {
+  return a.x * b.x + a.y * b.y + a.z * b.z
+}
+
+function vnorm(v) {
+  var len = math.sqrt(vdot(v, v))
+  if (len == 0) return vec(0, 0, 0)
+  return vmul(v, 1 / len)
+}
+
+function make_sphere(center, radius, color) {
+  return {
+    center: center,
+    radius: radius,
+    color: color
+  }
+}
+
+function intersect_sphere(origin, dir, sphere) {
+  var oc = vsub(origin, sphere.center)
+  var b = vdot(oc, dir)
+  var c = vdot(oc, oc) - sphere.radius * sphere.radius
+  var disc = b * b - c
+  if (disc < 0) return -1
+  var sq = math.sqrt(disc)
+  var t1 = -b - sq
+  var t2 = -b + sq
+  if (t1 > 0.001) return t1
+  if (t2 > 0.001) return t2
+  return -1
+}
+
+function make_scene() {
+  var spheres = [
+    make_sphere(vec(0, -1, 5), 1, vec(1, 0, 0)),
+    make_sphere(vec(2, 0, 6), 1, vec(0, 1, 0)),
+    make_sphere(vec(-2, 0, 4), 1, vec(0, 0, 1)),
+    make_sphere(vec(0, 1, 4.5), 0.5, vec(1, 1, 0)),
+    make_sphere(vec(1, -0.5, 3), 0.3, vec(1, 0, 1)),
+    make_sphere(vec(0, -101, 5), 100, vec(0.5, 0.5, 0.5))
+  ]
+  var light = vnorm(vec(1, 1, -1))
+  return {spheres: spheres, light: light}
+}
+
+function trace(origin, dir, scene) {
+  var closest_t = 999999
+  var closest_sphere = null
+  var i = 0
+  var t = 0
+  for (i = 0; i < length(scene.spheres); i++) {
+    t = intersect_sphere(origin, dir, scene.spheres[i])
+    if (t > 0 && t < closest_t) {
+      closest_t = t
+      closest_sphere = scene.spheres[i]
+    }
+  }
+
+  if (!closest_sphere) return vec(0.2, 0.3, 0.5) // sky color
+
+  var hit = vadd(origin, vmul(dir, closest_t))
+  var normal = vnorm(vsub(hit, closest_sphere.center))
+  var diffuse = vdot(normal, scene.light)
+  if (diffuse < 0) diffuse = 0
+
+  // Shadow check
+  var shadow_origin = vadd(hit, vmul(normal, 0.001))
+  var in_shadow = false
+  for (i = 0; i < length(scene.spheres); i++) {
+    if (scene.spheres[i] != closest_sphere) {
+      t = intersect_sphere(shadow_origin, scene.light, scene.spheres[i])
+      if (t > 0) {
+        in_shadow = true
+        break
+      }
+    }
+  }
+
+  var ambient = 0.15
+  var intensity = in_shadow ? ambient : ambient + diffuse * 0.85
+  return vmul(closest_sphere.color, intensity)
+}
+
+function render(width, height, scene) {
+  var aspect = width / height
+  var fov = 1.0
+  var total_r = 0
+  var total_g = 0
+  var total_b = 0
+  var y = 0
+  var x = 0
+  var u = 0
+  var v = 0
+  var dir = null
+  var color = null
+  var origin = vec(0, 0, 0)
+
+  for (y = 0; y < height; y++) {
+    for (x = 0; x < width; x++) {
+      u = (2 * (x + 0.5) / width - 1) * aspect * fov
+      v = (1 - 2 * (y + 0.5) / height) * fov
+      dir = vnorm(vec(u, v, 1))
+      color = trace(origin, dir, scene)
+      total_r += color.x
+      total_g += color.y
+      total_b += color.z
+    }
+  }
+
+  return {r: total_r, g: total_g, b: total_b}
+}
+
+var scene = make_scene()
+
+return {
+  raytrace_32x32: function(n) {
+    var i = 0
+    var result = null
+    for (i = 0; i < n; i++) {
+      result = render(32, 32, scene)
+    }
+    return result
+  },
+
+  raytrace_64x64: function(n) {
+    var i = 0
+    var result = null
+    for (i = 0; i < n; i++) {
+      result = render(64, 64, scene)
+    }
+    return result
+  }
+}

benches/richards.cm

@@ -0,0 +1,251 @@
+// richards.cm — Richards benchmark (scheduler simulation)
+// Object-ish workload: dynamic dispatch, state machines, queuing.
+
+def IDLE = 0
+def WORKER = 1
+def HANDLER_A = 2
+def HANDLER_B = 3
+def DEVICE_A = 4
+def DEVICE_B = 5
+def NUM_TASKS = 6
+
+def TASK_RUNNING = 0
+def TASK_WAITING = 1
+def TASK_HELD = 2
+def TASK_SUSPENDED = 3
+
+function make_packet(link, id, kind) {
+  return {link: link, id: id, kind: kind, datum: 0, data: array(4, 0)}
+}
+
+function scheduler() {
+  var tasks = array(NUM_TASKS, null)
+  var current = null
+  var queue_count = 0
+  var hold_count = 0
+  var v1 = 0
+  var v2 = 0
+  var w_id = HANDLER_A
+  var w_datum = 0
+  var h_a_queue = null
+  var h_a_count = 0
+  var h_b_queue = null
+  var h_b_count = 0
+  var dev_a_pkt = null
+  var dev_b_pkt = null
+
+  var find_next = function() {
+    var best = null
+    var i = 0
+    for (i = 0; i < NUM_TASKS; i++) {
+      if (tasks[i] && tasks[i].state == TASK_RUNNING) {
+        if (!best || tasks[i].priority > best.priority) {
+          best = tasks[i]
+        }
+      }
+    }
+    return best
+  }
+
+  var hold_self = function() {
+    hold_count++
+    if (current) current.state = TASK_HELD
+    return find_next()
+  }
+
+  var release = function(id) {
+    var t = tasks[id]
+    if (!t) return find_next()
+    if (t.state == TASK_HELD) t.state = TASK_RUNNING
+    if (t.priority > (current ? current.priority : -1)) return t
+    return current
+  }
+
+  var queue_packet = function(pkt) {
+    var t = tasks[pkt.id]
+    var p = null
+    if (!t) return find_next()
+    queue_count++
+    pkt.link = null
+    pkt.id = current ? current.id : 0
+    if (!t.queue) {
+      t.queue = pkt
+      t.state = TASK_RUNNING
+      if (t.priority > (current ? current.priority : -1)) return t
+    } else {
+      p = t.queue
+      while (p.link) p = p.link
+      p.link = pkt
+    }
+    return current
+  }
+
+  // Idle task
+  tasks[IDLE] = {id: IDLE, priority: 0, queue: null, state: TASK_RUNNING,
+    hold_count: 0, queue_count: 0,
+    fn: function(pkt) {
+      v1--
+      if (v1 == 0) return hold_self()
+      if ((v2 & 1) == 0) {
+        v2 = v2 >> 1
+        return release(DEVICE_A)
+      }
+      v2 = (v2 >> 1) ^ 0xD008
+      return release(DEVICE_B)
+    }
+  }
+
+  // Worker task
+  tasks[WORKER] = {id: WORKER, priority: 1000, queue: null, state: TASK_SUSPENDED,
+    hold_count: 0, queue_count: 0,
+    fn: function(pkt) {
+      var i = 0
+      if (!pkt) return hold_self()
+      w_id = (w_id == HANDLER_A) ? HANDLER_B : HANDLER_A
+      pkt.id = w_id
+      pkt.datum = 0
+      for (i = 0; i < 4; i++) {
+        w_datum++
+        if (w_datum > 26) w_datum = 1
+        pkt.data[i] = 65 + w_datum
+      }
+      return queue_packet(pkt)
+    }
+  }
+
+  // Handler A
+  tasks[HANDLER_A] = {id: HANDLER_A, priority: 2000, queue: null, state: TASK_SUSPENDED,
+    hold_count: 0, queue_count: 0,
+    fn: function(pkt) {
+      var p = null
+      if (pkt) { h_a_queue = pkt; h_a_count++ }
+      if (h_a_queue) {
+        p = h_a_queue
+        h_a_queue = p.link
+        if (h_a_count < 3) return queue_packet(p)
+        return release(DEVICE_A)
+      }
+      return hold_self()
+    }
+  }
+
+  // Handler B
+  tasks[HANDLER_B] = {id: HANDLER_B, priority: 3000, queue: null, state: TASK_SUSPENDED,
+    hold_count: 0, queue_count: 0,
+    fn: function(pkt) {
+      var p = null
+      if (pkt) { h_b_queue = pkt; h_b_count++ }
+      if (h_b_queue) {
+        p = h_b_queue
+        h_b_queue = p.link
+        if (h_b_count < 3) return queue_packet(p)
+        return release(DEVICE_B)
+      }
+      return hold_self()
+    }
+  }
+
+  // Device A
+  tasks[DEVICE_A] = {id: DEVICE_A, priority: 4000, queue: null, state: TASK_SUSPENDED,
+    hold_count: 0, queue_count: 0,
+    fn: function(pkt) {
+      var p = null
+      if (pkt) { dev_a_pkt = pkt; return hold_self() }
+      if (dev_a_pkt) {
+        p = dev_a_pkt
+        dev_a_pkt = null
+        return queue_packet(p)
+      }
+      return hold_self()
+    }
+  }
+
+  // Device B
+  tasks[DEVICE_B] = {id: DEVICE_B, priority: 5000, queue: null, state: TASK_SUSPENDED,
+    hold_count: 0, queue_count: 0,
+    fn: function(pkt) {
+      var p = null
+      if (pkt) { dev_b_pkt = pkt; return hold_self() }
+      if (dev_b_pkt) {
+        p = dev_b_pkt
+        dev_b_pkt = null
+        return queue_packet(p)
+      }
+      return hold_self()
+    }
+  }
+
+  var run = function(iterations) {
+    var i = 0
+    var pkt1 = null
+    var pkt2 = null
+    var steps = 0
+    var pkt = null
+    var next = null
+
+    v1 = iterations
+    v2 = 0xBEEF
+    queue_count = 0
+    hold_count = 0
+    w_id = HANDLER_A
+    w_datum = 0
+    h_a_queue = null
+    h_a_count = 0
+    h_b_queue = null
+    h_b_count = 0
+    dev_a_pkt = null
+    dev_b_pkt = null
+
+    for (i = 0; i < NUM_TASKS; i++) {
+      if (tasks[i]) {
+        tasks[i].state = (i == IDLE) ? TASK_RUNNING : TASK_SUSPENDED
+        tasks[i].queue = null
+      }
+    }
+
+    pkt1 = make_packet(null, WORKER, 1)
+    pkt2 = make_packet(pkt1, WORKER, 1)
+    tasks[WORKER].queue = pkt2
+    tasks[WORKER].state = TASK_RUNNING
+
+    current = find_next()
+    while (current && steps < iterations * 10) {
+      pkt = current.queue
+      if (pkt) {
+        current.queue = pkt.link
+        current.queue_count++
+      }
+      next = current.fn(pkt)
+      if (next) current = next
+      else current = find_next()
+      steps++
+    }
+    return {queue_count: queue_count, hold_count: hold_count, steps: steps}
+  }
+
+  return {run: run}
+}
+
+return {
+  richards_100: function(n) {
+    var i = 0
+    var s = null
+    var result = null
+    for (i = 0; i < n; i++) {
+      s = scheduler()
+      result = s.run(100)
+    }
+    return result
+  },
+
+  richards_1k: function(n) {
+    var i = 0
+    var s = null
+    var result = null
+    for (i = 0; i < n; i++) {
+      s = scheduler()
+      result = s.run(1000)
+    }
+    return result
+  }
+}

benches/sorting.cm

@@ -0,0 +1,180 @@
+// sorting.cm — Sorting and searching kernel
+// Array manipulation, comparison-heavy, allocation patterns.
+
+function make_random_array(n, seed) {
+  var a = []
+  var x = seed
+  var i = 0
+  for (i = 0; i < n; i++) {
+    x = ((x * 1103515245 + 12345) & 0x7FFFFFFF) | 0
+    push(a, x % 10000)
+  }
+  return a
+}
+
+function make_descending(n) {
+  var a = []
+  var i = 0
+  for (i = n - 1; i >= 0; i--) push(a, i)
+  return a
+}
+
+// Manual quicksort (tests recursion + array mutation)
+function qsort(arr, lo, hi) {
+  var i = lo
+  var j = hi
+  var pivot = arr[floor((lo + hi) / 2)]
+  var tmp = 0
+  if (lo >= hi) return null
+  while (i <= j) {
+    while (arr[i] < pivot) i++
+    while (arr[j] > pivot) j--
+    if (i <= j) {
+      tmp = arr[i]
+      arr[i] = arr[j]
+      arr[j] = tmp
+      i++
+      j--
+    }
+  }
+  if (lo < j) qsort(arr, lo, j)
+  if (i < hi) qsort(arr, i, hi)
+  return null
+}
+
+// Merge sort (tests allocation + array creation)
+function msort(arr) {
+  var n = length(arr)
+  if (n <= 1) return arr
+  var mid = floor(n / 2)
+  var left = msort(array(arr, 0, mid))
+  var right = msort(array(arr, mid, n))
+  return merge(left, right)
+}
+
+function merge(a, b) {
+  var result = []
+  var i = 0
+  var j = 0
+  while (i < length(a) && j < length(b)) {
+    if (a[i] <= b[j]) {
+      push(result, a[i])
+      i++
+    } else {
+      push(result, b[j])
+      j++
+    }
+  }
+  while (i < length(a)) {
+    push(result, a[i])
+    i++
+  }
+  while (j < length(b)) {
+    push(result, b[j])
+    j++
+  }
+  return result
+}
+
+// Binary search
+function bsearch(arr, target) {
+  var lo = 0
+  var hi = length(arr) - 1
+  var mid = 0
+  while (lo <= hi) {
+    mid = floor((lo + hi) / 2)
+    if (arr[mid] == target) return mid
+    if (arr[mid] < target) lo = mid + 1
+    else hi = mid - 1
+  }
+  return -1
+}
+
+// Sort objects by field
+function sort_records(n) {
+  var records = []
+  var x = 42
+  var i = 0
+  for (i = 0; i < n; i++) {
+    x = ((x * 1103515245 + 12345) & 0x7FFFFFFF) | 0
+    push(records, {id: i, score: x % 10000, name: `item_${i}`})
+  }
+  return sort(records, "score")
+}
+
+return {
+  // Quicksort 1K random integers
+  qsort_1k: function(n) {
+    var i = 0
+    var a = null
+    for (i = 0; i < n; i++) {
+      a = make_random_array(1000, i)
+      qsort(a, 0, length(a) - 1)
+    }
+    return a
+  },
+
+  // Quicksort 10K random integers
+  qsort_10k: function(n) {
+    var i = 0
+    var a = null
+    for (i = 0; i < n; i++) {
+      a = make_random_array(10000, i)
+      qsort(a, 0, length(a) - 1)
+    }
+    return a
+  },
+
+  // Merge sort 1K (allocation heavy)
+  msort_1k: function(n) {
+    var i = 0
+    var result = null
+    for (i = 0; i < n; i++) {
+      result = msort(make_random_array(1000, i))
+    }
+    return result
+  },
+
+  // Built-in sort 1K
+  builtin_sort_1k: function(n) {
+    var i = 0
+    var result = null
+    for (i = 0; i < n; i++) {
+      result = sort(make_random_array(1000, i))
+    }
+    return result
+  },
+
+  // Sort worst case (descending → ascending)
+  sort_worst_case: function(n) {
+    var i = 0
+    var a = null
+    for (i = 0; i < n; i++) {
+      a = make_descending(1000)
+      qsort(a, 0, length(a) - 1)
+    }
+    return a
+  },
+
+  // Binary search in sorted array
+  bsearch_1k: function(n) {
+    var sorted = make_random_array(1000, 42)
+    sorted = sort(sorted)
+    var found = 0
+    var i = 0
+    for (i = 0; i < n; i++) {
+      if (bsearch(sorted, sorted[i % 1000]) >= 0) found++
+    }
+    return found
+  },
+
+  // Sort records by field
+  sort_records_500: function(n) {
+    var i = 0
+    var result = null
+    for (i = 0; i < n; i++) {
+      result = sort_records(500)
+    }
+    return result
+  }
+}

benches/spectral_norm.cm

@@ -0,0 +1,82 @@
+// spectral_norm.cm — Spectral norm kernel
+// Pure numeric, dense array access, mathematical computation.
+
+var math = use('math/radians')
+
+function eval_a(i, j) {
+  return 1.0 / ((i + j) * (i + j + 1) / 2 + i + 1)
+}
+
+function eval_a_times_u(n, u, au) {
+  var i = 0
+  var j = 0
+  var sum = 0
+  for (i = 0; i < n; i++) {
+    sum = 0
+    for (j = 0; j < n; j++) {
+      sum += eval_a(i, j) * u[j]
+    }
+    au[i] = sum
+  }
+}
+
+function eval_at_times_u(n, u, atu) {
+  var i = 0
+  var j = 0
+  var sum = 0
+  for (i = 0; i < n; i++) {
+    sum = 0
+    for (j = 0; j < n; j++) {
+      sum += eval_a(j, i) * u[j]
+    }
+    atu[i] = sum
+  }
+}
+
+function eval_ata_times_u(n, u, atau) {
+  var v = array(n, 0)
+  eval_a_times_u(n, u, v)
+  eval_at_times_u(n, v, atau)
+}
+
+function spectral_norm(n) {
+  var u = array(n, 1)
+  var v = array(n, 0)
+  var i = 0
+  var vbv = 0
+  var vv = 0
+
+  for (i = 0; i < 10; i++) {
+    eval_ata_times_u(n, u, v)
+    eval_ata_times_u(n, v, u)
+  }
+
+  vbv = 0
+  vv = 0
+  for (i = 0; i < n; i++) {
+    vbv += u[i] * v[i]
+    vv += v[i] * v[i]
+  }
+
+  return math.sqrt(vbv / vv)
+}
+
+return {
+  spectral_100: function(n) {
+    var i = 0
+    var result = 0
+    for (i = 0; i < n; i++) {
+      result = spectral_norm(100)
+    }
+    return result
+  },
+
+  spectral_200: function(n) {
+    var i = 0
+    var result = 0
+    for (i = 0; i < n; i++) {
+      result = spectral_norm(200)
+    }
+    return result
+  }
+}

benches/string_processing.cm

@@ -0,0 +1,188 @@
+// string_processing.cm — String-heavy kernel
+// Concat, split, search, replace, interning path stress.
+
+function make_lorem(paragraphs) {
+  var base = "Lorem ipsum dolor sit amet consectetur adipiscing elit sed do eiusmod tempor incididunt ut labore et dolore magna aliqua Ut enim ad minim veniam quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat"
+  var result = ""
+  var i = 0
+  for (i = 0; i < paragraphs; i++) {
+    if (i > 0) result = result + " "
+    result = result + base
+  }
+  return result
+}
+
+// Build a lookup table from text
+function build_index(txt) {
+  var words = array(txt, " ")
+  var index = {}
+  var i = 0
+  var w = null
+  for (i = 0; i < length(words); i++) {
+    w = words[i]
+    if (!index[w]) {
+      index[w] = []
+    }
+    push(index[w], i)
+  }
+  return index
+}
+
+// Levenshtein-like distance (simplified)
+function edit_distance(a, b) {
+  var la = length(a)
+  var lb = length(b)
+  if (la == 0) return lb
+  if (lb == 0) return la
+
+  // Use flat array for 2 rows of DP matrix
+  var prev = array(lb + 1, 0)
+  var curr = array(lb + 1, 0)
+  var i = 0
+  var j = 0
+  var cost = 0
+  var del = 0
+  var ins = 0
+  var sub = 0
+  var tmp = null
+  var ca = array(a)
+  var cb = array(b)
+
+  for (j = 0; j <= lb; j++) prev[j] = j
+  for (i = 1; i <= la; i++) {
+    curr[0] = i
+    for (j = 1; j <= lb; j++) {
+      cost = ca[i - 1] == cb[j - 1] ? 0 : 1
+      del = prev[j] + 1
+      ins = curr[j - 1] + 1
+      sub = prev[j - 1] + cost
+      curr[j] = del
+      if (ins < curr[j]) curr[j] = ins
+      if (sub < curr[j]) curr[j] = sub
+    }
+    tmp = prev
+    prev = curr
+    curr = tmp
+  }
+  return prev[lb]
+}
+
+var lorem_5 = make_lorem(5)
+var lorem_20 = make_lorem(20)
+
+return {
+  // Split text into words and count
+  string_split_count: function(n) {
+    var i = 0
+    var words = null
+    var count = 0
+    for (i = 0; i < n; i++) {
+      words = array(lorem_5, " ")
+      count += length(words)
+    }
+    return count
+  },
+
+  // Build word index (split + hash + array ops)
+  string_index_build: function(n) {
+    var i = 0
+    var idx = null
+    for (i = 0; i < n; i++) {
+      idx = build_index(lorem_5)
+    }
+    return idx
+  },
+
+  // Search for substrings
+  string_search: function(n) {
+    var targets = ["dolor", "minim", "quis", "magna", "ipsum"]
+    var i = 0
+    var j = 0
+    var count = 0
+    for (i = 0; i < n; i++) {
+      for (j = 0; j < length(targets); j++) {
+        if (search(lorem_20, targets[j])) count++
+      }
+    }
+    return count
+  },
+
+  // Replace operations
+  string_replace: function(n) {
+    var i = 0
+    var result = null
+    for (i = 0; i < n; i++) {
+      result = replace(lorem_5, "dolor", "DOLOR")
+      result = replace(result, "ipsum", "IPSUM")
+      result = replace(result, "amet", "AMET")
+    }
+    return result
+  },
+
+  // String concatenation builder
+  string_builder: function(n) {
+    var i = 0
+    var j = 0
+    var s = null
+    var total = 0
+    for (i = 0; i < n; i++) {
+      s = ""
+      for (j = 0; j < 50; j++) {
+        s = s + "key=" + text(j) + "&value=" + text(j * 17) + "&"
+      }
+      total += length(s)
+    }
+    return total
+  },
+
+  // Edit distance (DP + array + string ops)
+  edit_distance: function(n) {
+    var words = ["kitten", "sitting", "saturday", "sunday", "intention", "execution"]
+    var i = 0
+    var j = 0
+    var total = 0
+    for (i = 0; i < n; i++) {
+      for (j = 0; j < length(words) - 1; j++) {
+        total += edit_distance(words[j], words[j + 1])
+      }
+    }
+    return total
+  },
+
+  // Upper/lower/trim chain
+  string_transforms: function(n) {
+    var src = "  Hello World  "
+    var i = 0
+    var x = 0
+    var result = null
+    for (i = 0; i < n; i++) {
+      result = trim(src)
+      result = upper(result)
+      result = lower(result)
+      x += length(result)
+    }
+    return x
+  },
+
+  // Starts_with / ends_with (interning path)
+  string_prefix_suffix: function(n) {
+    var strs = [
+      "application/json",
+      "text/html",
+      "image/png",
+      "application/xml",
+      "text/plain"
+    ]
+    var i = 0
+    var j = 0
+    var count = 0
+    for (i = 0; i < n; i++) {
+      for (j = 0; j < length(strs); j++) {
+        if (starts_with(strs[j], "application/")) count++
+        if (ends_with(strs[j], "/json")) count++
+        if (starts_with(strs[j], "text/")) count++
+      }
+    }
+    return count
+  }
+}

benches/tree_ops.cm

@@ -0,0 +1,137 @@
+// tree_ops.cm — Tree data structure operations kernel
+// Pointer chasing, recursion, allocation patterns.
+
+// Binary tree: create, walk, transform, check
+function make_tree(depth) {
+  if (depth <= 0) return {val: 1, left: null, right: null}
+  return {
+    val: depth,
+    left: make_tree(depth - 1),
+    right: make_tree(depth - 1)
+  }
+}
+
+function tree_check(node) {
+  if (!node) return 0
+  if (!node.left) return node.val
+  return node.val + tree_check(node.left) - tree_check(node.right)
+}
+
+function tree_sum(node) {
+  if (!node) return 0
+  return node.val + tree_sum(node.left) + tree_sum(node.right)
+}
+
+function tree_depth(node) {
+  if (!node) return 0
+  var l = tree_depth(node.left)
+  var r = tree_depth(node.right)
+  return 1 + (l > r ? l : r)
+}
+
+function tree_count(node) {
+  if (!node) return 0
+  return 1 + tree_count(node.left) + tree_count(node.right)
+}
+
+// Transform tree: map values
+function tree_map(node, fn) {
+  if (!node) return null
+  return {
+    val: fn(node.val),
+    left: tree_map(node.left, fn),
+    right: tree_map(node.right, fn)
+  }
+}
+
+// Flatten tree to array (in-order)
+function tree_flatten(node, result) {
+  if (!node) return null
+  tree_flatten(node.left, result)
+  push(result, node.val)
+  tree_flatten(node.right, result)
+  return null
+}
+
+// Build sorted tree from array (balanced)
+function build_balanced(arr, lo, hi) {
+  if (lo > hi) return null
+  var mid = floor((lo + hi) / 2)
+  return {
+    val: arr[mid],
+    left: build_balanced(arr, lo, mid - 1),
+    right: build_balanced(arr, mid + 1, hi)
+  }
+}
+
+// Find a value in BST
+function bst_find(node, val) {
+  if (!node) return false
+  if (val == node.val) return true
+  if (val < node.val) return bst_find(node.left, val)
+  return bst_find(node.right, val)
+}
+
+return {
+  // Binary tree create + check (allocation heavy)
+  tree_create_check: function(n) {
+    var i = 0
+    var t = null
+    var x = 0
+    for (i = 0; i < n; i++) {
+      t = make_tree(10)
+      x += tree_check(t)
+    }
+    return x
+  },
+
+  // Deep tree traversals
+  tree_traversal: function(n) {
+    var t = make_tree(12)
+    var x = 0
+    var i = 0
+    for (i = 0; i < n; i++) {
+      x += tree_sum(t) + tree_depth(t) + tree_count(t)
+    }
+    return x
+  },
+
+  // Tree map (create new tree from old)
+  tree_transform: function(n) {
+    var t = make_tree(10)
+    var i = 0
+    var mapped = null
+    for (i = 0; i < n; i++) {
+      mapped = tree_map(t, function(v) { return v * 2 + 1 })
+    }
+    return mapped
+  },
+
+  // Flatten + rebuild (array <-> tree conversion)
+  tree_flatten_rebuild: function(n) {
+    var t = make_tree(10)
+    var i = 0
+    var flat = null
+    var rebuilt = null
+    for (i = 0; i < n; i++) {
+      flat = []
+      tree_flatten(t, flat)
+      rebuilt = build_balanced(flat, 0, length(flat) - 1)
+    }
+    return rebuilt
+  },
+
+  // BST search (pointer chasing)
+  bst_search: function(n) {
+    // Build a balanced BST of 1024 elements
+    var data = []
+    var i = 0
+    for (i = 0; i < 1024; i++) push(data, i)
+    var bst = build_balanced(data, 0, 1023)
+    var found = 0
+    for (i = 0; i < n; i++) {
+      if (bst_find(bst, i % 1024)) found++
+    }
+    return found
+  }
+}

bootstrap.ce

@@ -0,0 +1,42 @@
+// bootstrap.ce — regenerate .mach bytecode files consumed by the mach engine
+// usage: cell bootstrap.ce
+
+var fd = use("fd")
+var json = use("json")
+var tokenize = use("tokenize")
+var parse = use("parse")
+var fold = use("fold")
+
+var files = [
+  {src: "tokenize.cm", name: "tokenize", out: "tokenize.mach"},
+  {src: "parse.cm", name: "parse", out: "parse.mach"},
+  {src: "fold.cm", name: "fold", out: "fold.mach"},
+  {src: "mcode.cm", name: "mcode", out: "mcode.mach"},
+  {src: "internal/bootstrap.cm", name: "bootstrap", out: "internal/bootstrap.mach"},
+  {src: "internal/engine.cm", name: "engine", out: "internal/engine.mach"}
+]
+
+var i = 0
+var entry = null
+var src = null
+var tok_result = null
+var ast = null
+var folded = null
+var ast_json = null
+var bytecode = null
+var f = null
+
+while (i < length(files)) {
+  entry = files[i]
+  src = text(fd.slurp(entry.src))
+  tok_result = tokenize(src, entry.src)
+  ast = parse(tok_result.tokens, src, entry.src, tokenize)
+  folded = fold(ast)
+  ast_json = json.encode(folded)
+  bytecode = mach_compile_ast(entry.name, ast_json)
+  f = fd.open(entry.out, "w")
+  fd.write(f, bytecode)
+  fd.close(f)
+  print(`wrote ${entry.out}`)
+  i = i + 1
+}

compile.ce

@@ -0,0 +1,102 @@
+// compile.ce — compile a .cm module to native .dylib via QBE
+//
+// Usage:
+//   cell --core . compile.ce <file.cm>
+//
+// Produces <file>.dylib in the current directory.
+
+var fd = use('fd')
+var os = use('os')
+
+if (length(args) < 1) {
+  print('usage: cell --core . compile.ce <file.cm>')
+  return
+}
+
+var file = args[0]
+var base = file
+if (ends_with(base, '.cm')) {
+  base = text(base, 0, length(base) - 3)
+}
+
+var safe = replace(replace(base, '/', '_'), '-', '_')
+var symbol = 'js_' + safe + '_use'
+var tmp = '/tmp/qbe_' + safe
+var ssa_path = tmp + '.ssa'
+var s_path = tmp + '.s'
+var o_path = tmp + '.o'
+var rt_o_path = '/tmp/qbe_rt.o'
+var dylib_path = base + '.dylib'
+var cwd = fd.getcwd()
+var rc = 0
+
+// Step 1: emit QBE IL
+print('emit qbe...')
+rc = os.system('cd ' + cwd + ' && ./cell --core . --emit-qbe ' + file + ' > ' + ssa_path)
+if (rc != 0) {
+  print('failed to emit qbe il')
+  return
+}
+
+// Step 2: post-process — insert dead labels after ret/jmp, append wrapper
+// Use awk via shell to avoid blob/slurpwrite issues with long strings
+print('post-process...')
+var awk_cmd = `awk '
+  need_label && /^[[:space:]]*[^@}]/ && NF > 0 {
+    print "@_dead_" dead_id; dead_id++; need_label=0
+  }
+  /^@/ || /^}/ || NF==0 { need_label=0 }
+  /^[[:space:]]*ret / || /^[[:space:]]*jmp / { need_label=1; print; next }
+  { print }
+' ` + ssa_path + ` > ` + tmp + `_fixed.ssa`
+rc = os.system(awk_cmd)
+if (rc != 0) {
+  print('post-process failed')
+  return
+}
+
+// Append wrapper function — called as symbol(ctx) by os.dylib_symbol.
+// Delegates to cell_rt_module_entry which heap-allocates a frame
+// (so closures survive) and calls cell_main.
+var wrapper_cmd = `printf '\nexport function l $` + symbol + `(l %%ctx) {\n@entry\n  %%result =l call $cell_rt_module_entry(l %%ctx)\n  ret %%result\n}\n' >> ` + tmp + `_fixed.ssa`
+rc = os.system(wrapper_cmd)
+if (rc != 0) {
+  print('wrapper append failed')
+  return
+}
+
+// Step 3: compile QBE IL to assembly
+print('qbe compile...')
+rc = os.system('~/.local/bin/qbe -o ' + s_path + ' ' + tmp + '_fixed.ssa')
+if (rc != 0) {
+  print('qbe compilation failed')
+  return
+}
+
+// Step 4: assemble
+print('assemble...')
+rc = os.system('cc -c ' + s_path + ' -o ' + o_path)
+if (rc != 0) {
+  print('assembly failed')
+  return
+}
+
+// Step 5: compile runtime stubs (cached — skip if already built)
+if (!fd.is_file(rt_o_path)) {
+  print('compile runtime stubs...')
+  rc = os.system('cc -c ' + cwd + '/qbe_rt.c -o ' + rt_o_path + ' -fPIC')
+  if (rc != 0) {
+    print('runtime stubs compilation failed')
+    return
+  }
+}
+
+// Step 6: link dylib
+print('link...')
+rc = os.system('cc -shared -fPIC -undefined dynamic_lookup ' + o_path + ' ' + rt_o_path + ' -o ' + cwd + '/' + dylib_path)
+if (rc != 0) {
+  print('linking failed')
+  return
+}
+
+print('built: ' + dylib_path)

debug/debug.c

@@ -1,27 +1,15 @@
 #include "cell.h"
 
-// Return the current stack depth.
-JSC_CCALL(debug_stack_depth, return number2js(js,js_debugger_stack_depth(js)))
+// TODO: Reimplement stack depth for register VM
+JSC_CCALL(debug_stack_depth, return number2js(js, 0))
 
-// Return a backtrace of the current call stack.
-JSC_CCALL(debug_build_backtrace, return js_debugger_build_backtrace(js,NULL))
-
-// Return the closure variables for a given function.
-JSC_CCALL(debug_closure_vars, return js_debugger_closure_variables(js,argv[0]))
-
-JSC_CCALL(debug_set_closure_var,
-  js_debugger_set_closure_variable(js,argv[0],argv[1],argv[2]);
-  return JS_NULL;
-)
-
-// Return the local variables for a specific stack frame.
-JSC_CCALL(debug_local_vars, return js_debugger_local_variables(js, js2number(js,argv[0])))
-
-// Return metadata about a given function.
-JSC_CCALL(debug_fn_info, return js_debugger_fn_info(js, argv[0]))
-
-// Return an array of functions in the current backtrace.
-JSC_CCALL(debug_backtrace_fns, return js_debugger_backtrace_fns(js,NULL))
+// TODO: Reimplement debug introspection for register VM
+JSC_CCALL(debug_build_backtrace, return JS_NewArray(js))
+JSC_CCALL(debug_closure_vars, return JS_NewObject(js))
+JSC_CCALL(debug_set_closure_var, return JS_NULL;)
+JSC_CCALL(debug_local_vars, return JS_NewObject(js))
+JSC_CCALL(debug_fn_info, return JS_NewObject(js))
+JSC_CCALL(debug_backtrace_fns, return JS_NewArray(js))
 
 static const JSCFunctionListEntry js_debug_funcs[] = {
   MIST_FUNC_DEF(debug, stack_depth, 0),
@@ -37,4 +25,4 @@ JSValue js_debug_use(JSContext *js) {
   JSValue mod = JS_NewObject(js);
   JS_SetPropertyFunctionList(js,mod,js_debug_funcs,countof(js_debug_funcs));
   return mod;
-}
+}

debug/js.c

@@ -1,102 +1,21 @@
 #include "cell.h"
 
 JSC_CCALL(os_mem_limit, JS_SetMemoryLimit(JS_GetRuntime(js), js2number(js,argv[0])))
-JSC_CCALL(os_max_stacksize, JS_SetMaxStackSize(JS_GetRuntime(js), js2number(js,argv[0])))
+JSC_CCALL(os_max_stacksize, JS_SetMaxStackSize(js, js2number(js,argv[0])))
 
-// Compute the approximate size of a single JS value in memory.
+// TODO: Reimplement memory usage reporting for new allocator
 JSC_CCALL(os_calc_mem,
-  JSMemoryUsage mu;
-  JS_ComputeMemoryUsage(JS_GetRuntime(js),&mu);
   ret = JS_NewObject(js);
-  JS_SetPropertyStr(js,ret,"malloc_size",number2js(js,mu.malloc_size));
-  JS_SetPropertyStr(js,ret,"malloc_limit",number2js(js,mu.malloc_limit));
-  JS_SetPropertyStr(js,ret,"memory_used_size",number2js(js,mu.memory_used_size));
-  JS_SetPropertyStr(js,ret,"malloc_count",number2js(js,mu.malloc_count));
-  JS_SetPropertyStr(js,ret,"memory_used_count",number2js(js,mu.memory_used_count));
-  /* atom_count and atom_size removed - atoms are now just strings */
-  JS_SetPropertyStr(js,ret,"str_count",number2js(js,mu.str_count));
-  JS_SetPropertyStr(js,ret,"str_size",number2js(js,mu.str_size));
-  JS_SetPropertyStr(js,ret,"obj_count",number2js(js,mu.obj_count));
-  JS_SetPropertyStr(js,ret,"obj_size",number2js(js,mu.obj_size));
-  JS_SetPropertyStr(js,ret,"prop_count",number2js(js,mu.prop_count));
-  JS_SetPropertyStr(js,ret,"prop_size",number2js(js,mu.prop_size));
-  JS_SetPropertyStr(js,ret,"shape_count",number2js(js,mu.shape_count));
-  JS_SetPropertyStr(js,ret,"shape_size",number2js(js,mu.shape_size));
-  JS_SetPropertyStr(js,ret,"js_func_count",number2js(js,mu.js_func_count));
-  JS_SetPropertyStr(js,ret,"js_func_size",number2js(js,mu.js_func_size));
-  JS_SetPropertyStr(js,ret,"js_func_code_size",number2js(js,mu.js_func_code_size));
-  JS_SetPropertyStr(js,ret,"js_func_pc2line_count",number2js(js,mu.js_func_pc2line_count));
-  JS_SetPropertyStr(js,ret,"js_func_pc2line_size",number2js(js,mu.js_func_pc2line_size));
-  JS_SetPropertyStr(js,ret,"c_func_count",number2js(js,mu.c_func_count));
-  JS_SetPropertyStr(js,ret,"array_count",number2js(js,mu.array_count));
-  JS_SetPropertyStr(js,ret,"fast_array_count",number2js(js,mu.fast_array_count));
-  JS_SetPropertyStr(js,ret,"fast_array_elements",number2js(js,mu.fast_array_elements));
-  JS_SetPropertyStr(js,ret,"binary_object_count",number2js(js,mu.binary_object_count));
-  JS_SetPropertyStr(js,ret,"binary_object_size",number2js(js,mu.binary_object_size));
 )
 
-// Evaluate a string of JavaScript code in the current QuickJS context.
-JSC_SSCALL(os_eval,
-  if (!str2) return JS_ThrowReferenceError(js, "Second argument should be the script.");
-  if (!str) return JS_ThrowReferenceError(js, "First argument should be the name of the script.");
-  JSValue bytecode = JS_Compile(js, str2, strlen(str2), str);
-  if (JS_IsException(bytecode)) return bytecode;
-  ret = JS_Integrate(js, bytecode, JS_NULL);
-)
-
-// Compile a string of JavaScript code into a function object.
-JSC_SSCALL(js_compile,
-  if (!str2) return JS_ThrowReferenceError(js, "Second argument should be the script.");
-  if (!str) return JS_ThrowReferenceError(js, "First argument should be the name of the script.");
-  ret = JS_Compile(js, str2, strlen(str2), str);
-)
-
-// Link compiled bytecode with environment and execute.
-JSC_CCALL(js_integrate,
-  JSValue env = (argc > 1 && !JS_IsNull(argv[1])) ? argv[1] : JS_NULL;
-  ret = JS_Integrate(js, argv[0], env);
-)
-
-// Compile a function object into a bytecode blob.
-JSC_CCALL(js_compile_blob,
-  size_t size;
-  uint8_t *data = JS_WriteObject(js, &size, argv[0], JS_WRITE_OBJ_BYTECODE);
-  if (!data) {
-    return JS_ThrowInternalError(js, "Failed to serialize bytecode");
-  }
-  ret = js_new_blob_stoned_copy(js, data, size);
-  js_free(js, data);
-)
-
-// Compile a bytecode blob into a function object.
-JSC_CCALL(js_compile_unblob,
-  size_t size;
-  void *data = js_get_blob_data(js, &size, argv[0]);
-  if (data == -1) return JS_EXCEPTION;
-  if (!data) return JS_ThrowReferenceError(js, "No data present in blob.");
-  
-  return JS_ReadObject(js, data, size, JS_READ_OBJ_BYTECODE);
-)
-
-// Disassemble a function object into a string.
-JSC_CCALL(js_disassemble,
-  return js_debugger_fn_bytecode(js, argv[0]);
-)
-
-// Return metadata about a given function.
-JSC_CCALL(js_fn_info,
-  return js_debugger_fn_info(js, argv[0]);
-)
+// TODO: Reimplement for register VM
+JSC_CCALL(js_disassemble, return JS_NewArray(js);)
+JSC_CCALL(js_fn_info, return JS_NewObject(js);)
 
 static const JSCFunctionListEntry js_js_funcs[] = {
   MIST_FUNC_DEF(os, calc_mem, 0),
   MIST_FUNC_DEF(os, mem_limit, 1),
   MIST_FUNC_DEF(os, max_stacksize, 1),
-  MIST_FUNC_DEF(os, eval, 2),
-  MIST_FUNC_DEF(js, compile, 2),
-  MIST_FUNC_DEF(js, integrate, 2),
-  MIST_FUNC_DEF(js, compile_blob, 1),
-  MIST_FUNC_DEF(js, compile_unblob, 1),
   MIST_FUNC_DEF(js, disassemble, 1),
   MIST_FUNC_DEF(js, fn_info, 1),
 };
@@ -105,4 +24,4 @@ JSValue js_js_use(JSContext *js) {
   JSValue mod = JS_NewObject(js);
   JS_SetPropertyFunctionList(js,mod,js_js_funcs,countof(js_js_funcs));
   return mod;
-}
+}

diff.ce

@@ -0,0 +1,264 @@
+// diff.ce — differential testing: run tests optimized vs unoptimized, compare results
+//
+// Usage:
+//   cell diff                - diff all test files in current package
+//   cell diff suite          - diff a specific test file (tests/suite.cm)
+//   cell diff tests/foo      - diff a specific test file by path
+var shop = use('internal/shop')
+var pkg = use('package')
+var fd = use('fd')
+var time = use('time')
+
+var _args = args == null ? [] : args
+
+var analyze = use('os').analyze
+var run_ast_fn = use('os').run_ast_fn
+var run_ast_noopt_fn = use('os').run_ast_noopt_fn
+
+if (!run_ast_noopt_fn) {
+  log.console("error: run_ast_noopt_fn not available (rebuild bootstrap)")
+  $stop()
+  return
+}
+
+// Parse arguments: diff [test_path]
+var target_test = null
+if (length(_args) > 0) {
+  target_test = _args[0]
+}
+
+function is_valid_package(dir) {
+  var _dir = dir == null ? '.' : dir
+  return fd.is_file(_dir + '/cell.toml')
+}
+
+if (!is_valid_package('.')) {
+  log.console('No cell.toml found in current directory')
+  $stop()
+  return
+}
+
+// Collect test files
+function collect_tests(specific_test) {
+  var files = pkg.list_files(null)
+  var test_files = []
+  var i = 0
+  var f = null
+  var test_name = null
+  var match_name = null
+  var match_base = null
+  for (i = 0; i < length(files); i++) {
+    f = files[i]
+    if (starts_with(f, "tests/") && ends_with(f, ".cm")) {
+      if (specific_test) {
+        test_name = text(f, 0, -3)
+        match_name = specific_test
+        if (!starts_with(match_name, 'tests/')) match_name = 'tests/' + match_name
+        match_base = ends_with(match_name, '.cm') ? text(match_name, 0, -3) : match_name
+        if (test_name != match_base) continue
+      }
+      push(test_files, f)
+    }
+  }
+  return test_files
+}
+
+// Deep comparison of two values
+function values_equal(a, b) {
+  var i = 0
+  var ka = null
+  var kb = null
+  if (a == b) return true
+  if (is_null(a) && is_null(b)) return true
+  if (is_null(a) || is_null(b)) return false
+  if (is_array(a) && is_array(b)) {
+    if (length(a) != length(b)) return false
+    i = 0
+    while (i < length(a)) {
+      if (!values_equal(a[i], b[i])) return false
+      i = i + 1
+    }
+    return true
+  }
+  if (is_object(a) && is_object(b)) {
+    ka = array(a)
+    kb = array(b)
+    if (length(ka) != length(kb)) return false
+    i = 0
+    while (i < length(ka)) {
+      if (!values_equal(a[ka[i]], b[ka[i]])) return false
+      i = i + 1
+    }
+    return true
+  }
+  return false
+}
+
+function describe(val) {
+  if (is_null(val)) return "null"
+  if (is_text(val)) return `"${val}"`
+  if (is_number(val)) return text(val)
+  if (is_logical(val)) return text(val)
+  if (is_function(val)) return "<function>"
+  if (is_array(val)) return `[array length=${text(length(val))}]`
+  if (is_object(val)) return `{record keys=${text(length(array(val)))}}`
+  return "<unknown>"
+}
+
+// Run a single test file through both paths
+function diff_test_file(file_path) {
+  var mod_path = text(file_path, 0, -3)
+  var src_path = fd.realpath('.') + '/' + file_path
+  var src = null
+  var ast = null
+  var mod_opt = null
+  var mod_noopt = null
+  var results = {file: file_path, tests: [], passed: 0, failed: 0, errors: []}
+  var use_pkg = fd.realpath('.')
+  var opt_error = null
+  var noopt_error = null
+  var keys = null
+  var i = 0
+  var k = null
+  var opt_result = null
+  var noopt_result = null
+  var opt_err = null
+  var noopt_err = null
+  var _run_one_opt = null
+  var _run_one_noopt = null
+
+  // Build env for module loading
+  var make_env = function() {
+    return {
+      use: function(path) {
+        return shop.use(path, use_pkg)
+      }
+    }
+  }
+
+  // Read and parse
+  var _read = function() {
+    src = text(fd.slurp(src_path))
+    ast = analyze(src, src_path)
+  } disruption {
+    push(results.errors, `failed to parse ${file_path}`)
+    return results
+  }
+  _read()
+  if (length(results.errors) > 0) return results
+
+  // Run optimized
+  var _run_opt = function() {
+    mod_opt = run_ast_fn(mod_path, ast, make_env())
+  } disruption {
+    opt_error = "disrupted"
+  }
+  _run_opt()
+
+  // Run unoptimized
+  var _run_noopt = function() {
+    mod_noopt = run_ast_noopt_fn(mod_path, ast, make_env())
+  } disruption {
+    noopt_error = "disrupted"
+  }
+  _run_noopt()
+
+  // Compare module-level behavior
+  if (opt_error != noopt_error) {
+    push(results.errors, `module load mismatch: opt=${opt_error != null ? opt_error : "ok"} noopt=${noopt_error != null ? noopt_error : "ok"}`)
+    results.failed = results.failed + 1
+    return results
+  }
+  if (opt_error != null) {
+    // Both disrupted during load — that's consistent
+    results.passed = results.passed + 1
+    push(results.tests, {name: "<module>", status: "passed"})
+    return results
+  }
+
+  // If module returns a record of functions, test each one
+  if (is_object(mod_opt) && is_object(mod_noopt)) {
+    keys = array(mod_opt)
+    while (i < length(keys)) {
+      k = keys[i]
+      if (is_function(mod_opt[k]) && is_function(mod_noopt[k])) {
+        opt_result = null
+        noopt_result = null
+        opt_err = null
+        noopt_err = null
+
+        _run_one_opt = function() {
+          opt_result = mod_opt[k]()
+        } disruption {
+          opt_err = "disrupted"
+        }
+        _run_one_opt()
+
+        _run_one_noopt = function() {
+          noopt_result = mod_noopt[k]()
+        } disruption {
+          noopt_err = "disrupted"
+        }
+        _run_one_noopt()
+
+        if (opt_err != noopt_err) {
+          push(results.tests, {name: k, status: "failed"})
+          push(results.errors, `${k}: disruption mismatch opt=${opt_err != null ? opt_err : "ok"} noopt=${noopt_err != null ? noopt_err : "ok"}`)
+          results.failed = results.failed + 1
+        } else if (!values_equal(opt_result, noopt_result)) {
+          push(results.tests, {name: k, status: "failed"})
+          push(results.errors, `${k}: result mismatch opt=${describe(opt_result)} noopt=${describe(noopt_result)}`)
+          results.failed = results.failed + 1
+        } else {
+          push(results.tests, {name: k, status: "passed"})
+          results.passed = results.passed + 1
+        }
+      }
+      i = i + 1
+    }
+  } else {
+    // Compare direct return values
+    if (!values_equal(mod_opt, mod_noopt)) {
+      push(results.tests, {name: "<return>", status: "failed"})
+      push(results.errors, `return value mismatch: opt=${describe(mod_opt)} noopt=${describe(mod_noopt)}`)
+      results.failed = results.failed + 1
+    } else {
+      push(results.tests, {name: "<return>", status: "passed"})
+      results.passed = results.passed + 1
+    }
+  }
+
+  return results
+}
+
+// Main
+var test_files = collect_tests(target_test)
+log.console(`Differential testing: ${text(length(test_files))} file(s)`)
+
+var total_passed = 0
+var total_failed = 0
+var i = 0
+var result = null
+var j = 0
+
+while (i < length(test_files)) {
+  result = diff_test_file(test_files[i])
+  log.console(`  ${result.file}: ${text(result.passed)} passed, ${text(result.failed)} failed`)
+  j = 0
+  while (j < length(result.errors)) {
+    log.console(`    MISMATCH: ${result.errors[j]}`)
+    j = j + 1
+  }
+  total_passed = total_passed + result.passed
+  total_failed = total_failed + result.failed
+  i = i + 1
+}
+
+log.console(`----------------------------------------`)
+log.console(`Diff: ${text(total_passed)} passed, ${text(total_failed)} failed, ${text(total_passed + total_failed)} total`)
+
+if (total_failed > 0) {
+  log.console(`DIFFERENTIAL FAILURES DETECTED`)
+}
+
+$stop()

docs/.pages

@@ -1,9 +0,0 @@
-nav:
-  - index.md
-  - cellscript.md
-  - actors.md
-  - packages.md
-  - cli.md
-  - c-modules.md
-  - Standard Library: library
-

docs/_index.md

@@ -0,0 +1,91 @@
+---
+title: "Documentation"
+description: "ƿit language documentation"
+type: "docs"
+---
+
+![image](/images/wizard.png)
+
+ƿit is an actor-based scripting language for building concurrent applications. It combines a familiar C-like syntax with the actor model of computation, optimized for low memory usage and simplicity.
+
+## Key Features
+
+- **Actor Model** — isolated memory, message passing, no shared state
+- **Immutability** — `stone()` makes values permanently frozen
+- **Prototype Inheritance** — objects without classes
+- **C Integration** — seamlessly extend with native code
+- **Cross-Platform** — deploy to desktop, web, and embedded
+
+## Quick Start
+
+```javascript
+// hello.ce - A simple actor
+print("Hello, ƿit!")
+$stop()
+```
+
+```bash
+pit hello
+```
+
+## Language
+
+- [**ƿit Language**](/docs/language/) — syntax, types, and operators
+- [**Actors and Modules**](/docs/actors/) — the execution model
+- [**Requestors**](/docs/requestors/) — asynchronous composition
+- [**Packages**](/docs/packages/) — code organization and sharing
+
+## Reference
+
+- [**Built-in Functions**](/docs/functions/) — intrinsics reference
+- [text](/docs/library/text/) — text conversion and manipulation
+- [number](/docs/library/number/) — numeric conversion and operations
+- [array](/docs/library/array/) — array creation and manipulation
+- [object](/docs/library/object/) — object creation, prototypes, and serialization
+
+## Standard Library
+
+Modules loaded with `use()`:
+
+- [blob](/docs/library/blob/) — binary data
+- [time](/docs/library/time/) — time and dates
+- [math](/docs/library/math/) — trigonometry and math
+- [json](/docs/library/json/) — JSON encoding/decoding
+- [random](/docs/library/random/) — random numbers
+
+## Tools
+
+- [**Command Line**](/docs/cli/) — the `pit` tool
+- [**Testing**](/docs/testing/) — writing and running tests
+- [**Writing C Modules**](/docs/c-modules/) — native extensions
+
+## Architecture
+
+ƿit programs are organized into **packages**. Each package contains:
+
+- **Modules** (`.cm`) — return a value, cached and frozen
+- **Actors** (`.ce`) — run independently, communicate via messages
+- **C files** (`.c`) — compiled to native libraries
+
+Actors never share memory. They communicate by sending messages, which are automatically serialized. This makes concurrent programming safe and predictable.
+
+## Installation
+
+```bash
+# Clone and bootstrap
+git clone https://gitea.pockle.world/john/cell
+cd cell
+make bootstrap
+```
+
+The ƿit shop is stored at `~/.pit/`.
+
+## Development
+
+After making changes, recompile with:
+
+```bash
+make
+```
+
+Run `cell --help` to see all available CLI flags.

docs/actors.md

@@ -1,10 +1,15 @@
-# Actors and Modules
+---
+title: "Actors and Modules"
+description: "The ƿit execution model"
+weight: 20
+type: "docs"
+---
 
-Cell organizes code into two types of scripts: **modules** (`.cm`) and **actors** (`.ce`).
+ƿit organizes code into two types of scripts: **modules** (`.cm`) and **actors** (`.ce`).
 
 ## The Actor Model
 
-Cell is built on the actor model of computation. Each actor:
+ƿit is built on the actor model of computation. Each actor:
 
 - Has its own **isolated memory** — actors never share state
 - Runs to completion each **turn** — no preemption
@@ -21,13 +26,13 @@ A module is a script that **returns a value**. The returned value is cached and
 // math_utils.cm
 var math = use('math/radians')
 
-function distance(x1, y1, x2, y2) {
+var distance = function(x1, y1, x2, y2) {
   var dx = x2 - x1
   var dy = y2 - y1
   return math.sqrt(dx * dx + dy * dy)
 }
 
-function midpoint(x1, y1, x2, y2) {
+var midpoint = function(x1, y1, x2, y2) {
   return {
     x: (x1 + x2) / 2,
     y: (y1 + y2) / 2
@@ -60,12 +65,12 @@ An actor is a script that **does not return a value**. It runs as an independent
 
 ```javascript
 // worker.ce
-log.console("Worker started")
+print("Worker started")
 
-$on_message = function(msg) {
-  log.console("Received:", msg)
+$receiver(function(msg, reply) {
+  print("Received:", msg)
   // Process message...
-}
+})
 ```
 
 **Key properties:**
@@ -83,7 +88,7 @@ Actors have access to special functions prefixed with `$`:
 Reference to the current actor.
 
 ```javascript
-log.console($me)  // actor reference
+print($me)  // actor reference
 ```
 
 ### $stop()
@@ -100,7 +105,7 @@ Send a message to another actor.
 
 ```javascript
 $send(other_actor, {type: "ping", data: 42}, function(reply) {
-  log.console("Got reply:", reply)
+  print("Got reply:", reply)
 })
 ```
 
@@ -112,7 +117,7 @@ Start a new actor from a script.
 
 ```javascript
 $start(function(new_actor) {
-  log.console("Started:", new_actor)
+  print("Started:", new_actor)
 }, "worker")
 ```
 
@@ -122,7 +127,7 @@ Schedule a callback after a delay.
 
 ```javascript
 $delay(function() {
-  log.console("5 seconds later")
+  print("5 seconds later")
 }, 5)
 ```
 
@@ -169,19 +174,47 @@ $contact(function(connection) {
 
 ### $time_limit(requestor, seconds)
 
-Wrap a requestor with a timeout.
+Wrap a requestor with a timeout. See [Requestors](/docs/requestors/) for details.
 
 ```javascript
 $time_limit(my_requestor, 10)  // 10 second timeout
 ```
 
+### $couple(actor)
+
+Couple the current actor to another actor. When the coupled actor dies, the current actor also dies. Coupling is automatic between an actor and its overling (parent).
+
+```javascript
+$couple(other_actor)
+```
+
+### $unneeded(callback, seconds)
+
+Schedule the actor for removal after a specified time.
+
+```javascript
+$unneeded(function() {
+  // cleanup before removal
+}, 30)
+```
+
+### $connection(callback, actor, config)
+
+Get information about the connection to another actor, such as latency, bandwidth, and activity.
+
+```javascript
+$connection(function(info) {
+  print(info.latency)
+}, other_actor, {})
+```
+
 ## Module Resolution
 
-When you call `use('name')`, Cell searches:
+When you call `use('name')`, ƿit searches:
 
 1. **Current package** — files relative to package root
-2. **Dependencies** — packages declared in `cell.toml`
-3. **Core** — built-in Cell modules
+2. **Dependencies** — packages declared in `pit.toml`
+3. **Core** — built-in ƿit modules
 
 ```javascript
 // From within package 'myapp':
@@ -199,14 +232,14 @@ Files starting with underscore (`_helper.cm`) are private to the package.
 // main.ce - Entry point
 var config = use('config')
 
-log.console("Starting application...")
+print("Starting application...")
 
 $start(function(worker) {
   $send(worker, {task: "process", data: [1, 2, 3]})
 }, "worker")
 
 $delay(function() {
-  log.console("Shutting down")
+  print("Shutting down")
   $stop()
 }, 10)
 ```

docs/c-modules.md

@@ -1,6 +1,11 @@
-# Writing C Modules
+---
+title: "Writing C Modules"
+description: "Extending ƿit with native code"
+weight: 50
+type: "docs"
+---
 
-Cell makes it easy to extend functionality with C code. C files in a package are compiled into a dynamic library and can be imported like any other module.
+ƿit makes it easy to extend functionality with C code. C files in a package are compiled into a dynamic library and can be imported like any other module.
 
 ## Basic Structure
 
@@ -45,12 +50,12 @@ Where:
 - `<filename>` is the C file name without extension
 
 Examples:
-- `mypackage/math.c` → `js_mypackage_math_use`
-- `gitea.pockle.world/john/lib/render.c` → `js_gitea_pockle_world_john_lib_render_use`
+- `mypackage/math.c` -> `js_mypackage_math_use`
+- `gitea.pockle.world/john/lib/render.c` -> `js_gitea_pockle_world_john_lib_render_use`
 
 ## Required Headers
 
-Include `cell.h` for all Cell integration:
+Include `cell.h` for all ƿit integration:
 
 ```c
 #include "cell.h"
@@ -63,7 +68,7 @@ This provides:
 
 ## Conversion Functions
 
-### JavaScript ↔ C
+### JavaScript <-> C
 
 ```c
 // Numbers
@@ -201,7 +206,7 @@ static const JSCFunctionListEntry js_funcs[] = {
 CELL_USE_FUNCS(js_funcs)
 ```
 
-Usage in Cell:
+Usage in ƿit:
 
 ```javascript
 var vector = use('vector')
@@ -211,7 +216,7 @@ var n = vector.normalize(3, 4) // {x: 0.6, y: 0.8}
 var d = vector.dot(1, 0, 0, 1) // 0
 ```
 
-## Combining C and Cell
+## Combining C and ƿit
 
 A common pattern is to have a C file provide low-level functions and a `.cm` file provide a higher-level API:
 
@@ -224,7 +229,7 @@ A common pattern is to have a C file provide low-level functions and a `.cm` fil
 // vector.cm
 var native = this  // C module passed as 'this'
 
-function Vector(x, y) {
+var Vector = function(x, y) {
   return {x: x, y: y}
 }
 
@@ -244,11 +249,11 @@ return Vector
 C files are automatically compiled when you run:
 
 ```bash
-cell build
-cell update
+pit build
+pit update
 ```
 
-The resulting dynamic library is placed in `~/.cell/lib/`.
+The resulting dynamic library is placed in `~/.pit/lib/`.
 
 ## Platform-Specific Code
 
@@ -260,7 +265,7 @@ audio_playdate.c  # Playdate
 audio_emscripten.c # Web/Emscripten
 ```
 
-Cell selects the appropriate file based on the target platform.
+ƿit selects the appropriate file based on the target platform.
 
 ## Static Declarations
 

docs/cellscript.md

@@ -1,288 +0,0 @@
-# Cell Language
-
-Cell is a scripting language for actor-based programming. It combines a familiar syntax with a prototype-based object system and strict immutability semantics.
-
-## Basics
-
-### Variables and Constants
-
-```javascript
-var x = 10        // mutable variable (block-scoped like let)
-def PI = 3.14159  // constant (cannot be reassigned)
-```
-
-### Data Types
-
-Cell has six fundamental types:
-
-- **number** — DEC64 decimal floating point (no rounding errors)
-- **text** — Unicode strings
-- **logical** — `true` or `false`
-- **null** — the absence of a value (no `undefined`)
-- **array** — ordered, numerically-indexed sequences
-- **object** — key-value records with prototype inheritance
-- **blob** — binary data (bits, not bytes)
-- **function** — first-class callable values
-
-### Literals
-
-```javascript
-// Numbers
-42
-3.14
-1_000_000        // underscores for readability
-
-// Text
-"hello"
-'world'
-`template ${x}`  // string interpolation
-
-// Logical
-true
-false
-
-// Null
-null
-
-// Arrays
-[1, 2, 3]
-["a", "b", "c"]
-
-// Objects
-{name: "cell", version: 1}
-{x: 10, y: 20}
-```
-
-### Operators
-
-```javascript
-// Arithmetic
-+ - * / %
-**              // exponentiation
-
-// Comparison (always strict)
-==              // equals (like === in JS)
-!=              // not equals (like !== in JS)
-< > <= >=
-
-// Logical
-&& || !
-
-// Assignment
-= += -= *= /=
-```
-
-### Control Flow
-
-```javascript
-// Conditionals
-if (x > 0) {
-  log.console("positive")
-} else if (x < 0) {
-  log.console("negative")
-} else {
-  log.console("zero")
-}
-
-// Ternary
-var sign = x > 0 ? 1 : -1
-
-// Loops
-for (var i = 0; i < 10; i++) {
-  log.console(i)
-}
-
-for (var item of items) {
-  log.console(item)
-}
-
-for (var key in obj) {
-  log.console(key, obj[key])
-}
-
-while (condition) {
-  // body
-}
-
-// Control
-break
-continue
-return value
-throw "error message"
-```
-
-### Functions
-
-```javascript
-// Named function
-function add(a, b) {
-  return a + b
-}
-
-// Anonymous function
-var multiply = function(a, b) {
-  return a * b
-}
-
-// Arrow function
-var square = x => x * x
-var sum = (a, b) => a + b
-
-// Rest parameters
-function log_all(...args) {
-  for (var arg of args) log.console(arg)
-}
-
-// Default parameters
-function greet(name, greeting = "Hello") {
-  return `${greeting}, ${name}!`
-}
-```
-
-All closures capture `this` (like arrow functions in JavaScript).
-
-## Arrays
-
-Arrays are **distinct from objects**. They are ordered, numerically-indexed sequences. You cannot add arbitrary string keys to an array.
-
-```javascript
-var arr = [1, 2, 3]
-arr[0]              // 1
-arr[2] = 10         // [1, 2, 10]
-length(arr)         // 3
-
-// Array spread
-var more = [...arr, 4, 5]  // [1, 2, 10, 4, 5]
-```
-
-## Objects
-
-Objects are key-value records with prototype-based inheritance.
-
-```javascript
-var point = {x: 10, y: 20}
-point.x             // 10
-point["y"]          // 20
-
-// Object spread
-var point3d = {...point, z: 30}
-
-// Prototype inheritance
-var colored_point = {__proto__: point, color: "red"}
-colored_point.x     // 10 (inherited)
-```
-
-### Prototypes
-
-```javascript
-// Create object with prototype
-var child = meme(parent)
-
-// Get prototype
-var p = proto(child)
-
-// Check prototype chain
-isa(child, parent)  // true
-```
-
-## Immutability with Stone
-
-The `stone()` function makes values permanently immutable.
-
-```javascript
-var config = stone({
-  debug: true,
-  maxRetries: 3
-})
-
-config.debug = false  // Error! Stone objects cannot be modified
-```
-
-Stone is **deep** — all nested objects and arrays are also frozen. This cannot be reversed.
-
-```javascript
-stone.p(value)  // returns true if value is stone
-```
-
-## Built-in Functions
-
-### length(value)
-
-Returns the length of arrays (elements), text (codepoints), blobs (bits), or functions (arity).
-
-```javascript
-length([1, 2, 3])      // 3
-length("hello")        // 5
-length(function(a,b){}) // 2
-```
-
-### use(path)
-
-Import a module. Returns the cached, stone value.
-
-```javascript
-var math = use('math/radians')
-var json = use('json')
-```
-
-### isa(value, type)
-
-Check type or prototype chain.
-
-```javascript
-is_number(42)        // true
-is_text("hi")        // true
-is_array([1,2])      // true
-is_object({})        // true
-isa(child, parent)     // true if parent is in prototype chain
-```
-
-### reverse(array)
-
-Returns a new array with elements in reverse order.
-
-```javascript
-reverse([1, 2, 3])  // [3, 2, 1]
-```
-
-### logical(value)
-
-Convert to boolean.
-
-```javascript
-logical(0)        // false
-logical(1)        // true
-logical("true")   // true
-logical("false")  // false
-logical(null)     // false
-```
-
-## Logging
-
-```javascript
-log.console("message")   // standard output
-log.error("problem")     // error output
-```
-
-## Pattern Matching
-
-Cell supports regex patterns in string functions, but not standalone regex objects.
-
-```javascript
-text.search("hello world", /world/)
-replace("hello", /l/g, "L")
-```
-
-## Error Handling
-
-```javascript
-try {
-  riskyOperation()
-} catch (e) {
-  log.error(e)
-}
-
-throw "something went wrong"
-```
-
-If an actor has an uncaught error, it crashes.

docs/cli.md

@@ -1,138 +1,144 @@
-# Command Line Interface
+---
+title: "Command Line Interface"
+description: "The pit tool"
+weight: 40
+type: "docs"
+---
 
-Cell provides a command-line interface for managing packages, running scripts, and building applications.
+ƿit provides a command-line interface for managing packages, running scripts, and building applications.
 
 ## Basic Usage
 
 ```bash
-cell <command> [arguments]
+pit <command> [arguments]
 ```
 
 ## Commands
 
-### cell version
+### pit version
 
-Display the Cell version.
+Display the ƿit version.
 
 ```bash
-cell version
+pit version
 # 0.1.0
 ```
 
-### cell install
+### pit install
 
 Install a package to the shop.
 
 ```bash
-cell install gitea.pockle.world/john/prosperon
-cell install /Users/john/local/mypackage  # local path
+pit install gitea.pockle.world/john/prosperon
+pit install /Users/john/local/mypackage  # local path
 ```
 
-### cell update
+### pit update
 
 Update packages from remote sources.
 
 ```bash
-cell update              # update all packages
-cell update <package>    # update specific package
+pit update              # update all packages
+pit update <package>    # update specific package
 ```
 
-### cell remove
+### pit remove
 
 Remove a package from the shop.
 
 ```bash
-cell remove gitea.pockle.world/john/oldpackage
+pit remove gitea.pockle.world/john/oldpackage
 ```
 
-### cell list
+### pit list
 
 List installed packages.
 
 ```bash
-cell list              # list all installed packages
-cell list <package>    # list dependencies of a package
+pit list              # list all installed packages
+pit list <package>    # list dependencies of a package
 ```
 
-### cell ls
+### pit ls
 
 List modules and actors in a package.
 
 ```bash
-cell ls              # list files in current project
-cell ls <package>    # list files in specified package
+pit ls              # list files in current project
+pit ls <package>    # list files in specified package
 ```
 
-### cell build
+### pit build
 
 Build the current package.
 
 ```bash
-cell build
+pit build
 ```
 
-### cell test
+### pit test
 
-Run tests.
+Run tests. See [Testing](/docs/testing/) for the full guide.
 
 ```bash
-cell test            # run tests in current package
-cell test all        # run all tests
-cell test <package>  # run tests in specific package
+pit test            # run tests in current package
+pit test all        # run all tests
+pit test <package>  # run tests in specific package
+pit test suite --verify --diff  # with IR verification and differential testing
 ```
 
-### cell link
+### pit link
 
 Manage local package links for development.
 
 ```bash
-cell link add <canonical> <local_path>  # link a package
-cell link list                          # show all links
-cell link delete <canonical>            # remove a link
-cell link clear                         # remove all links
+pit link add <canonical> <local_path>  # link a package
+pit link list                          # show all links
+pit link delete <canonical>            # remove a link
+pit link clear                         # remove all links
 ```
 
-### cell fetch
+### pit fetch
 
 Fetch package sources without extracting.
 
 ```bash
-cell fetch <package>
+pit fetch <package>
 ```
 
-### cell upgrade
+### pit upgrade
 
-Upgrade the Cell installation itself.
+Upgrade the ƿit installation itself.
 
 ```bash
-cell upgrade
+pit upgrade
 ```
 
-### cell clean
+### pit clean
 
 Clean build artifacts.
 
 ```bash
-cell clean
+pit clean
 ```
 
-### cell help
+### pit help
 
 Display help information.
 
 ```bash
-cell help
-cell help <command>
+pit help
+pit help <command>
 ```
 
 ## Running Scripts
 
-Any `.ce` file in the Cell core can be run as a command:
+Any `.ce` file in the ƿit core can be run as a command:
 
 ```bash
-cell version    # runs version.ce
-cell build      # runs build.ce
-cell test       # runs test.ce
+pit version    # runs version.ce
+pit build      # runs build.ce
+pit test       # runs test.ce
 ```
 
 ## Package Locators
@@ -143,16 +149,16 @@ Packages are identified by locators:
 - **Local**: `/absolute/path/to/package`
 
 ```bash
-cell install gitea.pockle.world/john/prosperon
-cell install /Users/john/work/mylib
+pit install gitea.pockle.world/john/prosperon
+pit install /Users/john/work/mylib
 ```
 
 ## Configuration
 
-Cell stores its data in `~/.cell/`:
+ƿit stores its data in `~/.pit/`:
 
 ```
-~/.cell/
+~/.pit/
 ├── packages/       # installed packages
 ├── lib/            # compiled dynamic libraries
 ├── build/          # build cache
@@ -163,7 +169,7 @@ Cell stores its data in `~/.cell/`:
 
 ## Environment
 
-Cell reads the `HOME` environment variable to locate the shop directory.
+ƿit reads the `HOME` environment variable to locate the shop directory.
 
 ## Exit Codes
 

docs/compiler-tools.md

@@ -0,0 +1,264 @@
+---
+title: "Compiler Inspection Tools"
+description: "Tools for inspecting and debugging the compiler pipeline"
+weight: 50
+type: "docs"
+---
+
+ƿit includes a set of tools for inspecting the compiler pipeline at every stage. These are useful for debugging, testing optimizations, and understanding what the compiler does with your code.
+
+## Pipeline Overview
+
+The compiler runs in stages:
+
+```
+source → tokenize → parse → fold → mcode → streamline → output
+```
+
+Each stage has a corresponding dump tool that lets you see its output.
+
+| Stage       | Tool              | What it shows                          |
+|-------------|-------------------|----------------------------------------|
+| fold        | `dump_ast.cm`     | Folded AST as JSON                     |
+| mcode       | `dump_mcode.cm`   | Raw mcode IR before optimization       |
+| streamline  | `dump_stream.cm`  | Before/after instruction counts + IR   |
+| streamline  | `dump_types.cm`   | Optimized IR with type annotations     |
+| streamline  | `streamline.ce`   | Full optimized IR as JSON              |
+| all         | `ir_report.ce`    | Structured optimizer flight recorder   |
+
+All tools take a source file as input and run the pipeline up to the relevant stage.
+
+## Quick Start
+
+```bash
+# see raw mcode IR
+./cell --core . dump_mcode.cm myfile.ce
+
+# see what the optimizer changed
+./cell --core . dump_stream.cm myfile.ce
+
+# full optimizer report with events
+./cell --core . ir_report.ce --full myfile.ce
+```
+
+## dump_ast.cm
+
+Prints the folded AST as JSON. This is the output of the parser and constant folder, before mcode generation.
+
+```bash
+./cell --core . dump_ast.cm <file.ce|file.cm>
+```
+
+## dump_mcode.cm
+
+Prints the raw mcode IR before any optimization. Shows the instruction array as formatted text with opcode, operands, and program counter.
+
+```bash
+./cell --core . dump_mcode.cm <file.ce|file.cm>
+```
+
+## dump_stream.cm
+
+Shows a before/after comparison of the optimizer. For each function, prints:
+- Instruction count before and after
+- Number of eliminated instructions
+- The streamlined IR (nops hidden by default)
+
+```bash
+./cell --core . dump_stream.cm <file.ce|file.cm>
+```
+
+## dump_types.cm
+
+Shows the optimized IR with type annotations. Each instruction is followed by the known types of its slot operands, inferred by walking the instruction stream.
+
+```bash
+./cell --core . dump_types.cm <file.ce|file.cm>
+```
+
+## streamline.ce
+
+Runs the full pipeline (tokenize, parse, fold, mcode, streamline) and outputs the optimized IR as JSON. Useful for piping to `jq` or saving for comparison.
+
+```bash
+./cell --core . streamline.ce <file.ce|file.cm>
+```
+
+## ir_report.ce
+
+The optimizer flight recorder. Runs the full pipeline with structured logging and outputs machine-readable, diff-friendly JSON. This is the most detailed tool for understanding what the optimizer did and why.
+
+```bash
+./cell --core . ir_report.ce [options] <file.ce|file.cm>
+```
+
+### Options
+
+| Flag | Description |
+|------|-------------|
+| `--summary` | Per-pass JSON summaries with instruction counts and timing (default) |
+| `--events` | Include rewrite events showing each optimization applied |
+| `--types` | Include type delta records showing inferred slot types |
+| `--ir-before=PASS` | Print canonical IR before a specific pass |
+| `--ir-after=PASS` | Print canonical IR after a specific pass |
+| `--ir-all` | Print canonical IR before and after all passes |
+| `--full` | Everything: summary + events + types + ir-all |
+
+With no flags, `--summary` is the default.
+
+### Output Format
+
+Output is line-delimited JSON. Each line is a self-contained JSON object with a `type` field:
+
+**`type: "pass"`** — Per-pass summary with categorized instruction counts before and after:
+
+```json
+{
+  "type": "pass",
+  "pass": "eliminate_type_checks",
+  "fn": "fib",
+  "ms": 0.12,
+  "changed": true,
+  "before": {"instr": 77, "nop": 0, "guard": 16, "branch": 28, ...},
+  "after":  {"instr": 77, "nop": 1, "guard": 15, "branch": 28, ...},
+  "changes": {"guards_removed": 1, "nops_added": 1}
+}
+```
+
+**`type: "event"`** — Individual rewrite event with before/after instructions and reasoning:
+
+```json
+{
+  "type": "event",
+  "pass": "eliminate_type_checks",
+  "rule": "incompatible_type_forces_jump",
+  "at": 3,
+  "before": [["is_int", 5, 2, 4, 9], ["jump_false", 5, "rel_ni_2", 4, 9]],
+  "after": ["_nop_tc_1", ["jump", "rel_ni_2", 4, 9]],
+  "why": {"slot": 2, "known_type": "float", "checked_type": "int"}
+}
+```
+
+**`type: "types"`** — Inferred type information for a function:
+
+```json
+{
+  "type": "types",
+  "fn": "fib",
+  "param_types": {},
+  "slot_types": {"25": "null"}
+}
+```
+
+**`type: "ir"`** — Canonical IR text for a function at a specific point:
+
+```json
+{
+  "type": "ir",
+  "when": "before",
+  "pass": "all",
+  "fn": "fib",
+  "text": "fn fib (args=1, slots=26)\n  @0    access          s2, 2\n  ..."
+}
+```
+
+### Rewrite Rules
+
+Each pass records events with named rules:
+
+**eliminate_type_checks:**
+- `known_type_eliminates_guard` — type already known, guard removed
+- `incompatible_type_forces_jump` — type conflicts, conditional jump becomes unconditional
+- `num_subsumes_int_float` — num check satisfied by int or float
+- `dynamic_to_field` — load_dynamic/store_dynamic narrowed to field access
+- `dynamic_to_index` — load_dynamic/store_dynamic narrowed to index access
+
+**simplify_algebra:**
+- `add_zero`, `sub_zero`, `mul_one`, `div_one` — identity operations become moves
+- `mul_zero` — multiplication by zero becomes constant
+- `self_eq`, `self_ne` — same-slot comparisons become constants
+
+**simplify_booleans:**
+- `not_jump_false_fusion` — not + jump_false fused into jump_true
+- `not_jump_true_fusion` — not + jump_true fused into jump_false
+- `double_not` — not + not collapsed to move
+
+**eliminate_moves:**
+- `self_move` — move to same slot becomes nop
+
+**eliminate_dead_jumps:**
+- `jump_to_next` — jump to immediately following label becomes nop
+
+### Canonical IR Format
+
+The `--ir-all`, `--ir-before`, and `--ir-after` flags produce a deterministic text representation of the IR:
+
+```
+fn fib (args=1, slots=26)
+  @0    access          s2, 2
+  @1    is_int          s4, s1                          ; [guard]
+  @2    jump_false      s4, "rel_ni_2"                  ; [branch]
+  @3    --- nop (tc) ---
+  @4    jump            "rel_ni_2"                      ; [branch]
+  @5    lt_int          s3, s1, s2
+  @6    jump            "rel_done_4"                    ; [branch]
+      rel_ni_2:
+  @8    is_num          s4, s1                          ; [guard]
+```
+
+Properties:
+- `@N` is the raw array index, stable across passes (passes replace, never insert or delete)
+- `sN` prefix distinguishes slot operands from literal values
+- String operands are quoted
+- Labels appear as indented headers with a colon
+- Category tags in brackets: `[guard]`, `[branch]`, `[load]`, `[store]`, `[call]`, `[arith]`, `[move]`, `[const]`
+- Nops shown as `--- nop (reason) ---` with reason codes: `tc` (type check), `bl` (boolean), `mv` (move), `dj` (dead jump), `ur` (unreachable)
+
+### Examples
+
+```bash
+# what passes changed something?
+./cell --core . ir_report.ce --summary myfile.ce | jq 'select(.changed)'
+
+# list all rewrite rules that fired
+./cell --core . ir_report.ce --events myfile.ce | jq 'select(.type == "event") | .rule'
+
+# diff IR before and after optimization
+./cell --core . ir_report.ce --ir-all myfile.ce | jq -r 'select(.type == "ir") | .text'
+
+# full report for analysis
+./cell --core . ir_report.ce --full myfile.ce > report.json
+```
+
+## ir_stats.cm
+
+A utility module used by `ir_report.ce` and available for custom tooling. Not a standalone tool.
+
+```javascript
+var ir_stats = use("ir_stats")
+
+ir_stats.detailed_stats(func)                    // categorized instruction counts
+ir_stats.ir_fingerprint(func)                    // djb2 hash of instruction array
+ir_stats.canonical_ir(func, name, opts)          // deterministic text representation
+ir_stats.type_snapshot(slot_types)               // frozen copy of type map
+ir_stats.type_delta(before_types, after_types)   // compute type changes
+ir_stats.category_tag(op)                        // classify an opcode
+```
+
+### Instruction Categories
+
+`detailed_stats` classifies each instruction into one of these categories:
+
+| Category | Opcodes |
+|----------|---------|
+| load     | `load_field`, `load_index`, `load_dynamic`, `get`, `access` (non-constant) |
+| store    | `store_field`, `store_index`, `store_dynamic`, `set_var`, `put`, `push` |
+| branch   | `jump`, `jump_true`, `jump_false`, `jump_not_null` |
+| call     | `invoke`, `goinvoke` |
+| guard    | `is_int`, `is_text`, `is_num`, `is_bool`, `is_null`, `is_array`, `is_func`, `is_record`, `is_stone` |
+| arith    | `add_int`, `sub_int`, ..., `add_float`, ..., `concat`, `neg_int`, `neg_float`, bitwise ops |
+| move     | `move` |
+| const    | `int`, `true`, `false`, `null`, `access` (with constant value) |
+| label    | string entries that are not nops |
+| nop      | strings starting with `_nop_` |
+| other    | everything else (`frame`, `setarg`, `array`, `record`, `function`, `return`, etc.) |

docs/index.md

@@ -1,66 +0,0 @@
-# Cell
-
-![image](wizard.png)
-
-Cell is an actor-based scripting language for building concurrent applications. It combines a familiar C-like syntax with the actor model of computation, optimized for low memory usage and simplicity.
-
-## Key Features
-
-- **Actor Model** — isolated memory, message passing, no shared state
-- **Immutability** — `stone()` makes values permanently frozen
-- **Prototype Inheritance** — objects without classes
-- **C Integration** — seamlessly extend with native code
-- **Cross-Platform** — deploy to desktop, web, and embedded
-
-## Quick Start
-
-```javascript
-// hello.ce - A simple actor
-log.console("Hello, Cell!")
-$stop()
-```
-
-```bash
-cell hello
-```
-
-## Documentation
-
-- [**Cell Language**](cellscript.md) — syntax, types, and built-in functions
-- [**Actors and Modules**](actors.md) — the execution model
-- [**Packages**](packages.md) — code organization and sharing
-- [**Command Line**](cli.md) — the `cell` tool
-- [**Writing C Modules**](c-modules.md) — native extensions
-
-## Standard Library
-
-- [text](library/text.md) — string manipulation
-- [number](library/number.md) — numeric operations (functions are global: `floor()`, `max()`, etc.)
-- [array](library/array.md) — array utilities
-- [object](library/object.md) — object utilities
-- [blob](library/blob.md) — binary data
-- [time](library/time.md) — time and dates
-- [math](library/math.md) — trigonometry and math
-- [json](library/json.md) — JSON encoding/decoding
-- [random](library/random.md) — random numbers
-
-## Architecture
-
-Cell programs are organized into **packages**. Each package contains:
-
-- **Modules** (`.cm`) — return a value, cached and frozen
-- **Actors** (`.ce`) — run independently, communicate via messages
-- **C files** (`.c`) — compiled to native libraries
-
-Actors never share memory. They communicate by sending messages, which are automatically serialized. This makes concurrent programming safe and predictable.
-
-## Installation
-
-```bash
-# Clone and bootstrap
-git clone https://gitea.pockle.world/john/cell
-cd cell
-make bootstrap
-```
-
-The Cell shop is stored at `~/.cell/`.

docs/kim.md

@@ -0,0 +1,94 @@
+---
+title: "Kim Encoding"
+description: "Compact character and count encoding"
+weight: 80
+type: "docs"
+---
+
+Kim is a character and count encoding designed by Douglas Crockford. It encodes Unicode characters and variable-length integers using continuation bytes. Kim is simpler and more compact than UTF-8 for most text.
+
+## Continuation Bytes
+
+The fundamental idea in Kim is the continuation byte:
+
+```
+C  D  D  D  D  D  D  D
+```
+
+- **C** — continue bit. If 1, read another byte. If 0, this is the last byte.
+- **D** (7 bits) — data bits.
+
+To decode: shift the accumulator left by 7 bits, add the 7 data bits. If the continue bit is 1, repeat with the next byte. If 0, the value is complete.
+
+To encode: take the value, emit 7 bits at a time from most significant to least significant, setting the continue bit on all bytes except the last.
+
+## Character Encoding
+
+Kim encodes Unicode codepoints directly as continuation byte sequences:
+
+| Range | Bytes | Characters |
+|-------|-------|------------|
+| U+0000 to U+007F | 1 | ASCII |
+| U+0080 to U+3FFF | 2 | First quarter of BMP |
+| U+4000 to U+10FFFF | 3 | All other Unicode |
+
+Unlike UTF-8, there is no need for surrogate pairs or escapement. Every Unicode character, including emoji and characters from extended planes, is encoded in at most 3 bytes.
+
+### Examples
+
+```
+'A'       (U+0041)  →  41
+'é'       (U+00E9)  →  81 69
+'💩'      (U+1F4A9)  →  87 E9 29
+```
+
+## Count Encoding
+
+Kim is also used for encoding counts (lengths, sizes). The same continuation byte format represents non-negative integers of arbitrary size:
+
+| Range | Bytes |
+|-------|-------|
+| 0 to 127 | 1 |
+| 128 to 16383 | 2 |
+| 16384 to 2097151 | 3 |
+
+## Comparison with UTF-8
+
+| Property | Kim | UTF-8 |
+|----------|-----|-------|
+| ASCII | 1 byte | 1 byte |
+| BMP (first quarter) | 2 bytes | 2-3 bytes |
+| Full Unicode | 3 bytes | 3-4 bytes |
+| Self-synchronizing | No | Yes |
+| Sortable | No | Yes |
+| Simpler to implement | Yes | No |
+| Byte count for counts | Variable (7 bits/byte) | Not applicable |
+
+Kim trades self-synchronization (the ability to find character boundaries from any position) for simplicity and compactness. In practice, Kim text is accessed sequentially, so self-synchronization is not needed.
+
+## Usage in ƿit
+
+Kim is used internally by blobs and by the Nota message format.
+
+### In Blobs
+
+The `blob.write_text` and `blob.read_text` functions use Kim to encode text into binary data:
+
+```javascript
+var blob = use('blob')
+var b = blob.make()
+blob.write_text(b, "hello")  // Kim-encoded length + characters
+stone(b)
+var text = blob.read_text(b, 0)  // "hello"
+```
+
+### In Nota
+
+Nota uses Kim for two purposes:
+
+1. **Counts** — array lengths, text lengths, blob sizes, record pair counts
+2. **Characters** — text content within Nota messages
+
+The preamble byte of each Nota value incorporates the first few bits of a Kim-encoded count, with the continue bit indicating whether more bytes follow.
+
+See [Nota Format](#nota) for the full specification.

docs/language.md

@@ -0,0 +1,649 @@
+---
+title: "ƿit Language"
+description: "Syntax, types, operators, and built-in functions"
+weight: 10
+type: "docs"
+---
+
+ƿit is a scripting language for actor-based programming. It combines a familiar syntax with a prototype-based object system and strict immutability semantics.
+
+## Basics
+
+### Variables and Constants
+
+Variables are declared with `var`, constants with `def`. All declarations must be initialized and must appear at the function body level — not inside `if`, `while`, `for`, or `do` blocks.
+
+```javascript
+var x = 10
+var name = "pit"
+var empty = null
+
+def PI = 3.14159   // constant, cannot be reassigned
+
+var a = 1, b = 2, c = 3  // multiple declarations
+```
+
+### Data Types
+
+ƿit has eight fundamental types:
+
+- **number** — DEC64 decimal floating point (no rounding errors)
+- **text** — Unicode strings
+- **logical** — `true` or `false`
+- **null** — the absence of a value (no `undefined`)
+- **array** — ordered, numerically-indexed sequences
+- **object** — key-value records with prototype inheritance
+- **blob** — binary data (bits, not bytes)
+- **function** — first-class callable values
+
+### Literals
+
+```javascript
+// Numbers
+42
+3.14
+-5
+0
+1e3           // scientific notation (1000)
+
+// Text
+"hello"
+`template ${x}`   // string interpolation
+`${1 + 2}`        // expression interpolation
+
+// Logical
+true
+false
+
+// Null
+null
+
+// Arrays
+[1, 2, 3]
+[]
+
+// Objects
+{a: 1, b: "two"}
+{}
+
+// Regex
+/\d+/
+/hello/i          // with flags
+```
+
+## Operators
+
+### Arithmetic
+
+```javascript
+2 + 3      // 5
+5 - 3      // 2
+3 * 4      // 12
+12 / 4     // 3
+10 % 3     // 1
+2 ** 3     // 8 (exponentiation)
+```
+
+### Comparison
+
+All comparisons are strict — there is no type coercion.
+
+```javascript
+5 == 5     // true
+5 != 6     // true
+3 < 5      // true
+5 > 3      // true
+3 <= 3     // true
+5 >= 5     // true
+```
+
+### Logical
+
+```javascript
+true && true     // true
+true && false    // false
+false || true    // true
+false || false   // false
+!true            // false
+!false           // true
+```
+
+Logical operators short-circuit:
+
+```javascript
+var called = false
+var fn = function() { called = true; return true }
+var r = false && fn()   // fn() not called
+r = true || fn()        // fn() not called
+```
+
+### Bitwise
+
+```javascript
+5 & 3       // 1   (AND)
+5 | 3       // 7   (OR)
+5 ^ 3       // 6   (XOR)
+~0          // -1  (NOT)
+1 << 3      // 8   (left shift)
+8 >> 3      // 1   (right shift)
+-1 >>> 1    // 2147483647 (unsigned right shift)
+```
+
+### Unary
+
+```javascript
++5          // 5
+-5          // -5
+-(-5)       // 5
+```
+
+### Increment and Decrement
+
+```javascript
+var x = 5
+x++         // returns 5, x becomes 6 (postfix)
+++x         // returns 7, x becomes 7 (prefix)
+x--         // returns 7, x becomes 6 (postfix)
+--x         // returns 5, x becomes 5 (prefix)
+```
+
+### Compound Assignment
+
+```javascript
+var x = 10
+x += 3      // 13
+x -= 3      // 10
+x *= 2      // 20
+x /= 4     // 5
+x %= 3      // 2
+```
+
+### Ternary
+
+```javascript
+var a = true ? 1 : 2       // 1
+var b = false ? 1 : 2      // 2
+var c = true ? (false ? 1 : 2) : 3  // 2 (nested)
+```
+
+### Comma
+
+The comma operator evaluates all expressions and returns the last.
+
+```javascript
+var x = (1, 2, 3)  // 3
+```
+
+### In
+
+Test whether a key exists in an object.
+
+```javascript
+var o = {a: 1}
+"a" in o    // true
+"b" in o    // false
+```
+
+### Delete
+
+Remove a key from an object.
+
+```javascript
+var o = {a: 1, b: 2}
+delete o.a
+"a" in o    // false
+o.b         // 2
+```
+
+## Property Access
+
+### Dot and Bracket
+
+```javascript
+var o = {x: 10}
+o.x           // 10 (dot read)
+o.x = 20      // dot write
+o["x"]        // 20 (bracket read)
+var key = "x"
+o[key]        // 20 (computed bracket)
+o["y"] = 30   // bracket write
+```
+
+### Object as Key
+
+Objects can be used as keys in other objects.
+
+```javascript
+var k = {}
+var o = {}
+o[k] = 42
+o[k]          // 42
+o[{}]         // null (different object)
+k in o        // true
+delete o[k]
+k in o        // false
+```
+
+### Chained Access
+
+```javascript
+var d = {a: {b: [1, {c: 99}]}}
+d.a.b[1].c    // 99
+```
+
+## Arrays
+
+Arrays are **distinct from objects**. They are ordered, numerically-indexed sequences.
+
+```javascript
+var arr = [1, 2, 3]
+arr[0]              // 1
+arr[2] = 10         // [1, 2, 10]
+length(arr)         // 3
+```
+
+### Push and Pop
+
+```javascript
+var a = [1, 2]
+a[] = 3             // push: [1, 2, 3]
+length(a)           // 3
+var v = a[]         // pop: v is 3, a is [1, 2]
+length(a)           // 2
+```
+
+## Objects
+
+Objects are key-value records with prototype-based inheritance.
+
+```javascript
+var point = {x: 10, y: 20}
+point.x             // 10
+point["y"]          // 20
+```
+
+### Prototypes
+
+```javascript
+// Create object with prototype
+var parent = {x: 10}
+var child = meme(parent)
+child.x             // 10 (inherited)
+proto(child)        // parent
+
+// Override does not mutate parent
+child.x = 20
+parent.x            // 10
+```
+
+### Mixins
+
+```javascript
+var p = {a: 1}
+var m1 = {b: 2}
+var m2 = {c: 3}
+var child = meme(p, [m1, m2])
+child.a             // 1 (from prototype)
+child.b             // 2 (from mixin)
+child.c             // 3 (from mixin)
+```
+
+## Control Flow
+
+### If / Else
+
+```javascript
+var x = 0
+if (true) x = 1
+if (false) x = 2 else x = 3
+if (false) x = 4
+else if (true) x = 5
+else x = 6
+```
+
+### While
+
+```javascript
+var i = 0
+while (i < 5) i++
+
+// break
+i = 0
+while (true) {
+  if (i >= 3) break
+  i++
+}
+
+// continue
+var sum = 0
+i = 0
+while (i < 5) {
+  i++
+  if (i % 2 == 0) continue
+  sum += i
+}
+```
+
+### For
+
+Variables cannot be declared in the for initializer. Declare them at the function body level.
+
+```javascript
+var sum = 0
+var i = 0
+for (i = 0; i < 5; i++) sum += i
+
+// break
+sum = 0
+i = 0
+for (i = 0; i < 10; i++) {
+  if (i == 5) break
+  sum += i
+}
+
+// continue
+sum = 0
+i = 0
+for (i = 0; i < 5; i++) {
+  if (i % 2 == 0) continue
+  sum += i
+}
+
+// nested
+sum = 0
+var j = 0
+for (i = 0; i < 3; i++) {
+  for (j = 0; j < 3; j++) {
+    sum++
+  }
+}
+```
+
+## Functions
+
+### Function Expressions
+
+```javascript
+var add = function(a, b) { return a + b }
+add(2, 3)           // 5
+```
+
+### Arrow Functions
+
+```javascript
+var double = x => x * 2
+double(5)           // 10
+
+var sum = (a, b) => a + b
+sum(2, 3)           // 5
+
+var block = x => {
+  var y = x * 2
+  return y + 1
+}
+block(5)            // 11
+```
+
+### Return
+
+A function with no `return` returns `null`. An early `return` exits immediately.
+
+```javascript
+var fn = function() { var x = 1 }
+fn()                // null
+
+var fn2 = function() { return 1; return 2 }
+fn2()               // 1
+```
+
+### Arguments
+
+Extra arguments are ignored. Missing arguments are `null`.
+
+```javascript
+var fn = function(a, b) { return a + b }
+fn(1, 2, 3)        // 3 (extra arg ignored)
+
+var fn2 = function(a, b) { return a }
+fn2(1)              // 1 (b is null)
+```
+
+### Immediately Invoked Function Expression
+
+```javascript
+var r = (function(x) { return x * 2 })(21)  // 42
+```
+
+### Closures
+
+Functions capture variables from their enclosing scope.
+
+```javascript
+var make = function(x) {
+  return function(y) { return x + y }
+}
+var add5 = make(5)
+add5(3)             // 8
+```
+
+Captured variables can be mutated:
+
+```javascript
+var counter = function() {
+  var n = 0
+  return function() { n = n + 1; return n }
+}
+var c = counter()
+c()                 // 1
+c()                 // 2
+```
+
+### Recursion
+
+```javascript
+var fact = function(n) {
+  if (n <= 1) return 1
+  return n * fact(n - 1)
+}
+fact(5)             // 120
+```
+
+### This Binding
+
+When a function is called as a method, `this` refers to the object.
+
+```javascript
+var obj = {
+  val: 10,
+  get: function() { return this.val }
+}
+obj.get()           // 10
+```
+
+### Currying
+
+```javascript
+var f = function(a) {
+  return function(b) {
+    return function(c) { return a + b + c }
+  }
+}
+f(1)(2)(3)          // 6
+```
+
+## Identifiers
+
+Identifiers can contain `?` and `!` characters, both as suffixes and mid-name.
+
+```javascript
+var nil? = (x) => x == null
+nil?(null)          // true
+nil?(42)            // false
+
+var set! = (x) => x + 1
+set!(5)             // 6
+
+var is?valid = (x) => x > 0
+is?valid(3)         // true
+
+var do!stuff = () => 42
+do!stuff()          // 42
+```
+
+The `?` in an identifier is not confused with the ternary operator:
+
+```javascript
+var nil? = (x) => x == null
+var a = nil?(null) ? "yes" : "no"   // "yes"
+```
+
+## Type Checking
+
+### Type Functions
+
+```javascript
+is_number(42)           // true
+is_text("hi")           // true
+is_logical(true)        // true
+is_object({})           // true
+is_array([])            // true
+is_function(function(){})  // true
+is_null(null)           // true
+is_object([])           // false (array is not object)
+is_array({})            // false (object is not array)
+```
+
+### Truthiness
+
+Falsy values: `false`, `0`, `""`, `null`. Everything else is truthy.
+
+```javascript
+if (0) ...              // not entered
+if ("") ...             // not entered
+if (null) ...           // not entered
+if (1) ...              // entered
+if ("hi") ...           // entered
+if ({}) ...             // entered
+if ([]) ...             // entered
+```
+
+## Immutability with Stone
+
+The `stone()` function makes values permanently immutable.
+
+```javascript
+var o = {x: 1}
+is_stone(o)             // false
+stone(o)
+is_stone(o)             // true
+o.x = 2                 // disrupts!
+```
+
+Stone is **deep** — all nested objects and arrays are also frozen. This cannot be reversed.
+
+## Function Proxy
+
+A function with two parameters (`name`, `args`) acts as a proxy when properties are accessed on it. Any method call on the function dispatches through the proxy.
+
+```javascript
+var proxy = function(name, args) {
+  return `${name}:${length(args)}`
+}
+proxy.hello()           // "hello:0"
+proxy.add(1, 2)         // "add:2"
+proxy["method"]()       // "method:0"
+var m = "dynamic"
+proxy[m]()              // "dynamic:0"
+```
+
+For non-proxy functions, property access disrupts:
+
+```javascript
+var fn = function() { return 1 }
+fn.foo                  // disrupts
+fn.foo = 1              // disrupts
+```
+
+## Regex
+
+Regex literals are written with forward slashes, with optional flags.
+
+```javascript
+var r = /\d+/
+var result = extract("abc123", r)
+result[0]               // "123"
+
+var ri = /hello/i
+var result2 = extract("Hello", ri)
+result2[0]              // "Hello"
+```
+
+## Error Handling
+
+ƿit uses `disrupt` and `disruption` for error handling. A `disrupt` signals that something went wrong. The `disruption` block attached to a function catches it.
+
+```javascript
+var safe_divide = function(a, b) {
+  if (b == 0) disrupt
+  return a / b
+} disruption {
+  print("something went wrong")
+}
+```
+
+`disrupt` is a bare keyword — it does not carry a value. The `disruption` block knows that something went wrong, but not what.
+
+### Re-raising
+
+A `disruption` block can re-raise by calling `disrupt` again:
+
+```javascript
+var outer = function() {
+  var inner = function() { disrupt } disruption { disrupt }
+  inner()
+} disruption {
+  // caught here after re-raise
+}
+outer()
+```
+
+### Testing for Disruption
+
+```javascript
+var should_disrupt = function(fn) {
+  var caught = false
+  var wrapper = function() {
+    fn()
+  } disruption {
+    caught = true
+  }
+  wrapper()
+  return caught
+}
+```
+
+If an actor has an unhandled disruption, it crashes.
+
+## Self-Referencing Structures
+
+Objects can reference themselves:
+
+```javascript
+var o = {name: "root"}
+o.self = o
+o.self.self.name        // "root"
+```
+
+## Variable Shadowing
+
+Inner functions can shadow outer variables:
+
+```javascript
+var x = 10
+var fn = function() {
+  var x = 20
+  return x
+}
+fn()                    // 20
+x                       // 10
+```

docs/library/.pages

@@ -1,10 +0,0 @@
-nav:
-  - text.md
-  - number.md
-  - array.md
-  - object.md
-  - blob.md
-  - time.md
-  - math.md
-  - json.md
-  - random.md

docs/library/_index.md

@@ -0,0 +1,18 @@
+---
+title: "Standard Library"
+description: "ƿit standard library modules"
+weight: 90
+type: "docs"
+---
+
+The standard library provides modules loaded with `use()`.
+
+| Module | Description |
+|--------|-------------|
+| [blob](/docs/library/blob/) | Binary data (bits, not bytes) |
+| [time](/docs/library/time/) | Time constants and conversions |
+| [math](/docs/library/math/) | Trigonometry, logarithms, roots |
+| [json](/docs/library/json/) | JSON encoding and decoding |
+| [random](/docs/library/random/) | Random number generation |
+
+The `text`, `number`, `array`, and `object` functions are intrinsics — they are always available without `use`. See [Built-in Functions](/docs/functions/) for the full list, and the individual reference pages for [text](/docs/library/text/), [number](/docs/library/number/), [array](/docs/library/array/), and [object](/docs/library/object/).

docs/library/array.md

@@ -1,12 +1,19 @@
-# array
+---
+title: "array"
+description: "Array creation and manipulation"
+weight: 30
+type: "docs"
+---
 
-The `array` function and its methods handle array creation and manipulation.
+The `array` function is an intrinsic (always available, no `use()` needed). It is **polymorphic** — its behavior depends on the type of the first argument.
 
-## Creation
+## From a Number
+
+Create an array of a given size.
 
 ### array(number)
 
-Create an array of specified size, filled with `null`.
+All elements initialized to `null`.
 
 ```javascript
 array(3)  // [null, null, null]
@@ -14,24 +21,36 @@ array(3)  // [null, null, null]
 
 ### array(number, initial)
 
-Create an array with initial values.
+All elements initialized to a value. If initial is a function, it is called for each element (passed the index if arity >= 1).
 
 ```javascript
 array(3, 0)           // [0, 0, 0]
 array(3, i => i * 2)  // [0, 2, 4]
 ```
 
+## From an Array
+
+Copy, map, concat, or slice.
+
 ### array(array)
 
-Copy an array.
+Copy an array (mutable).
 
 ```javascript
 var copy = array(original)
 ```
 
+### array(array, function)
+
+Map — call function with each element, collect results.
+
+```javascript
+array([1, 2, 3], x => x * 2)  // [2, 4, 6]
+```
+
 ### array(array, from, to)
 
-Slice an array.
+Slice — extract a sub-array. Negative indices count from end.
 
 ```javascript
 array([1, 2, 3, 4, 5], 1, 4)  // [2, 3, 4]
@@ -40,32 +59,36 @@ array([1, 2, 3], -2)          // [2, 3]
 
 ### array(array, another)
 
-Concatenate arrays.
+Concatenate two arrays.
 
 ```javascript
 array([1, 2], [3, 4])  // [1, 2, 3, 4]
 ```
 
-### array(object)
+## From a Record
 
-Get keys of an object.
+### array(record)
+
+Get the keys of a record as an array of text.
 
 ```javascript
 array({a: 1, b: 2})  // ["a", "b"]
 ```
 
+## From Text
+
 ### array(text)
 
-Split text into grapheme clusters.
+Split text into individual characters (grapheme clusters). This is the standard way to iterate over characters in a string.
 
 ```javascript
-array("hello")       // ["h", "e", "l", "l", "o"]
-array("👨‍👩‍👧")          // ["👨‍👩‍👧"]
+array("hello")  // ["h", "e", "l", "l", "o"]
+array("ƿit")    // ["ƿ", "i", "t"]
 ```
 
 ### array(text, separator)
 
-Split text by separator.
+Split text by a separator string.
 
 ```javascript
 array("a,b,c", ",")  // ["a", "b", "c"]
@@ -73,7 +96,7 @@ array("a,b,c", ",")  // ["a", "b", "c"]
 
 ### array(text, length)
 
-Split text into chunks.
+Dice text into chunks of a given length.
 
 ```javascript
 array("abcdef", 2)  // ["ab", "cd", "ef"]
@@ -87,13 +110,13 @@ Iterate over elements.
 
 ```javascript
 array.for([1, 2, 3], function(el, i) {
-  log.console(i, el)
+  print(i, el)
 })
 
 // With early exit
 array.for([1, 2, 3, 4], function(el) {
   if (el > 2) return true
-  log.console(el)
+  print(el)
 }, false, true)  // prints 1, 2
 ```
 

docs/library/blob.md

@@ -1,4 +1,9 @@
-# blob
+---
+title: "blob"
+description: "Binary data containers (bits, not bytes)"
+weight: 50
+type: "docs"
+---
 
 Blobs are binary large objects — containers of bits (not bytes). They're used for encoding data, messages, images, network payloads, and more.
 

docs/library/json.md

@@ -1,4 +1,9 @@
-# json
+---
+title: "json"
+description: "JSON encoding and decoding"
+weight: 80
+type: "docs"
+---
 
 JSON encoding and decoding.
 
@@ -86,5 +91,5 @@ var config_text = json.encode(config, 2)
 
 // Load configuration
 var loaded = json.decode(config_text)
-log.console(loaded.debug)  // true
+print(loaded.debug)  // true
 ```

docs/library/math.md

@@ -1,10 +1,15 @@
-# math
+---
+title: "math"
+description: "Trigonometry, logarithms, and roots"
+weight: 70
+type: "docs"
+---
 
-Cell provides three math modules with identical functions but different angle representations:
+ƿit provides three math modules with identical functions but different angle representations:
 
 ```javascript
 var math = use('math/radians')  // angles in radians
-var math = use('math/degrees')  // angles in degrees  
+var math = use('math/degrees')  // angles in degrees
 var math = use('math/cycles')   // angles in cycles (0-1)
 ```
 
@@ -35,7 +40,7 @@ math.tangent(math.pi / 4)  // 1 (radians)
 Inverse sine.
 
 ```javascript
-math.arc_sine(1)  // π/2 (radians)
+math.arc_sine(1)  // pi/2 (radians)
 ```
 
 ### arc_cosine(n)
@@ -43,7 +48,7 @@ math.arc_sine(1)  // π/2 (radians)
 Inverse cosine.
 
 ```javascript
-math.arc_cosine(0)  // π/2 (radians)
+math.arc_cosine(0)  // pi/2 (radians)
 ```
 
 ### arc_tangent(n, denominator)
@@ -51,9 +56,9 @@ math.arc_cosine(0)  // π/2 (radians)
 Inverse tangent. With two arguments, computes atan2.
 
 ```javascript
-math.arc_tangent(1)        // π/4 (radians)
-math.arc_tangent(1, 1)     // π/4 (radians)
-math.arc_tangent(-1, -1)   // -3π/4 (radians)
+math.arc_tangent(1)        // pi/4 (radians)
+math.arc_tangent(1, 1)     // pi/4 (radians)
+math.arc_tangent(-1, -1)   // -3pi/4 (radians)
 ```
 
 ## Exponentials and Logarithms
@@ -64,7 +69,7 @@ Euler's number raised to a power. Default power is 1.
 
 ```javascript
 math.e()     // 2.718281828...
-math.e(2)    // e²
+math.e(2)    // e^2
 ```
 
 ### ln(n)
@@ -130,21 +135,21 @@ math.e()  // 2.71828...
 var math = use('math/radians')
 
 // Distance between two points
-function distance(x1, y1, x2, y2) {
+var distance = function(x1, y1, x2, y2) {
   var dx = x2 - x1
   var dy = y2 - y1
   return math.sqrt(dx * dx + dy * dy)
 }
 
 // Angle between two points
-function angle(x1, y1, x2, y2) {
+var angle = function(x1, y1, x2, y2) {
   return math.arc_tangent(y2 - y1, x2 - x1)
 }
 
 // Rotate a point
-function rotate(x, y, angle) {
-  var c = math.cosine(angle)
-  var s = math.sine(angle)
+var rotate = function(x, y, a) {
+  var c = math.cosine(a)
+  var s = math.sine(a)
   return {
     x: x * c - y * s,
     y: x * s + y * c

docs/library/number.md

@@ -1,6 +1,11 @@
-# number
+---
+title: "number"
+description: "Numeric conversion and operations"
+weight: 20
+type: "docs"
+---
 
-The `number` function and its methods handle numeric conversion and operations.
+The `number` function is an intrinsic (always available, no `use()` needed). It is **polymorphic** — its behavior depends on the type of the first argument.
 
 ## Conversion
 
@@ -29,15 +34,15 @@ Parse formatted numbers.
 
 | Format | Description |
 |--------|-------------|
-| `""`   | Standard decimal |
-| `"u"`  | Underbar separator (1_000) |
-| `"d"`  | Comma separator (1,000) |
-| `"s"`  | Space separator (1 000) |
-| `"v"`  | European (1.000,50) |
-| `"b"`  | Binary |
-| `"o"`  | Octal |
-| `"h"`  | Hexadecimal |
-| `"j"`  | JavaScript style (0x, 0o, 0b prefixes) |
+| `""` | Standard decimal |
+| `"u"` | Underbar separator (1_000) |
+| `"d"` | Comma separator (1,000) |
+| `"s"` | Space separator (1 000) |
+| `"v"` | European (1.000,50) |
+| `"b"` | Binary |
+| `"o"` | Octal |
+| `"h"` | Hexadecimal |
+| `"j"` | JavaScript style (0x, 0o, 0b prefixes) |
 
 ```javascript
 number("1,000", "d")    // 1000
@@ -118,20 +123,20 @@ Get the fractional part.
 fraction(4.75)  // 0.75
 ```
 
-### min(...values)
+### min(a, b)
 
-Return the smallest value.
+Return the smaller of two numbers.
 
 ```javascript
-min(3, 1, 4, 1, 5)  // 1
+min(3, 5)  // 3
 ```
 
-### max(...values)
+### max(a, b)
 
-Return the largest value.
+Return the larger of two numbers.
 
 ```javascript
-max(3, 1, 4, 1, 5)  // 5
+max(3, 5)  // 5
 ```
 
 ### remainder(dividend, divisor)

docs/library/object.md

@@ -1,8 +1,13 @@
-# object
+---
+title: "object"
+description: "Object creation and manipulation"
+weight: 40
+type: "docs"
+---
 
-The `object` function and related utilities handle object creation and manipulation.
+The `object` function is an intrinsic (always available, no `use()` needed). It is **polymorphic** — its behavior depends on the types of its arguments.
 
-## Creation
+## From a Record
 
 ### object(obj)
 
@@ -29,6 +34,8 @@ Select specific keys.
 object({a: 1, b: 2, c: 3}, ["a", "c"])  // {a: 1, c: 3}
 ```
 
+## From an Array of Keys
+
 ### object(keys)
 
 Create object from keys (values are `true`).
@@ -60,9 +67,9 @@ object(["a", "b", "c"], (k, i) => i)  // {a: 0, b: 1, c: 2}
 Create a new object with the given prototype.
 
 ```javascript
-var animal = {speak: function() { log.console("...") }}
+var animal = {speak: function() { print("...") }}
 var dog = meme(animal)
-dog.speak = function() { log.console("woof") }
+dog.speak = function() { print("woof") }
 ```
 
 ### proto(obj)
@@ -104,9 +111,4 @@ var obj = {a: 1, b: 2, c: 3}
 
 // Get all keys
 var keys = array(obj)  // ["a", "b", "c"]
-
-// Iterate
-for (var key in obj) {
-  log.console(key, obj[key])
-}
 ```

docs/library/random.md

@@ -1,4 +1,9 @@
-# random
+---
+title: "random"
+description: "Random number generation"
+weight: 90
+type: "docs"
+---
 
 Random number generation.
 
@@ -43,7 +48,7 @@ var random = use('random')
 var coin_flip = random.random() < 0.5
 
 // Random element from array
-function pick(arr) {
+var pick = function(arr) {
   return arr[random.random_whole(length(arr))]
 }
 
@@ -51,11 +56,14 @@ var colors = ["red", "green", "blue"]
 var color = pick(colors)
 
 // Shuffle array
-function shuffle(arr) {
+var shuffle = function(arr) {
   var result = array(arr)  // copy
-  for (var i = length(result) - 1; i > 0; i--) {
-    var j = random.random_whole(i + 1)
-    var temp = result[i]
+  var i = length(result) - 1
+  var j = 0
+  var temp = null
+  for (i = length(result) - 1; i > 0; i--) {
+    j = random.random_whole(i + 1)
+    temp = result[i]
     result[i] = result[j]
     result[j] = temp
   }
@@ -63,8 +71,8 @@ function shuffle(arr) {
 }
 
 // Random in range
-function random_range(min, max) {
-  return min + random.random() * (max - min)
+var random_range = function(lo, hi) {
+  return lo + random.random() * (hi - lo)
 }
 
 var x = random_range(-10, 10)  // -10 to 10

docs/library/text.md

@@ -1,19 +1,28 @@
-# text
+---
+title: "text"
+description: "String conversion and manipulation"
+weight: 10
+type: "docs"
+---
 
-The `text` function and its methods handle string conversion and manipulation.
+The `text` function is an intrinsic (always available, no `use()` needed). It is **polymorphic** — its behavior depends on the type of the first argument.
 
-## Conversion
+To split text into characters, use `array(text)` — see [array](/docs/library/array/).
+
+## From an Array
 
 ### text(array, separator)
 
-Convert an array to text, joining elements with a separator (default: space).
+Join array elements into text with a separator (default: empty string).
 
 ```javascript
-text([1, 2, 3])           // "1 2 3"
-text([1, 2, 3], ", ")     // "1, 2, 3"
-text(["a", "b"], "-")     // "a-b"
+text(["h", "e", "l", "l", "o"])  // "hello"
+text([1, 2, 3], ", ")            // "1, 2, 3"
+text(["a", "b"], "-")            // "a-b"
 ```
 
+## From a Number
+
 ### text(number, radix)
 
 Convert a number to text. Radix is 2-36 (default: 10).
@@ -24,13 +33,16 @@ text(255, 16)    // "ff"
 text(255, 2)     // "11111111"
 ```
 
+## From Text
+
 ### text(text, from, to)
 
-Extract a substring from index `from` to `to`.
+Extract a substring from index `from` to `to`. Negative indices count from end.
 
 ```javascript
 text("hello world", 0, 5)   // "hello"
 text("hello world", 6)      // "world"
+text("hello", -3)            // "llo"
 ```
 
 ## Methods
@@ -101,7 +113,7 @@ text.format("{0} + {1} = {2}", [1, 2, 3])
 Unicode normalize the text (NFC form).
 
 ```javascript
-text.normalize("café")  // normalized form
+text.normalize("cafe\u0301")  // normalized form
 ```
 
 ### text.codepoint(text)
@@ -109,8 +121,7 @@ text.normalize("café")  // normalized form
 Get the Unicode codepoint of the first character.
 
 ```javascript
-text.codepoint("A")     // 65
-text.codepoint("😀")    // 128512
+text.codepoint("A")  // 65
 ```
 
 ### text.extract(text, pattern, from, to)

docs/library/time.md

@@ -1,4 +1,9 @@
-# time
+---
+title: "time"
+description: "Time constants and conversion functions"
+weight: 60
+type: "docs"
+---
 
 The time module provides time constants and conversion functions.
 
@@ -96,7 +101,7 @@ var last_week = now - time.week
 var later = now + (2 * time.hour)
 
 // Format future time
-log.console(time.text(tomorrow))
+print(time.text(tomorrow))
 ```
 
 ## Example
@@ -108,9 +113,9 @@ var time = use('time')
 var start = time.number()
 // ... do work ...
 var elapsed = time.number() - start
-log.console(`Took ${elapsed} seconds`)
+print(`Took ${elapsed} seconds`)
 
 // Schedule for tomorrow
 var tomorrow = time.number() + time.day
-log.console(`Tomorrow: ${time.text(tomorrow, "yyyy-MM-dd")}`)
+print(`Tomorrow: ${time.text(tomorrow, "yyyy-MM-dd")}`)
 ```

docs/memory.md

@@ -1,248 +0,0 @@
-# Cell actor scripting language
-
-Cell is a Misty [https://mistysystem.com](https://mistysystem.com) implementation.
-
-## Memory
-Values are 32 bit for 32 bit builds and 64 bit for 64 bit builds.
-
-### 32 bit value
-
-LSB = 0
-payload is a 31 bit signed int
-
-LSB = 01
-payload is a 30 bit pointer
-
-LSB = 11
-next 3 bits = special tag. 27 bits of payload.
-
-### 64 bit value
-LSB = 0
-payload is a 32 bit signed int, using high 32 bits
-
-LSB = 01
-payload is a 61 bit pointer
-
-LSB = 101
-Short float: a 61 bit double, with 3 less exponent bits
-
-LSB = 11
-Special tag: next 3 bits. 5 bits total. 59 bits of payload. 8 total special tags.
-
-Special tags:
-1: Bool. Payload is 0 or 1.
-2: null. payload is 0.
-3: exception.
-4: string.
-  Immediate string. Next 3 low bits = length in bytes. Rest is string data. This allows for strings up to 7 ascii letters. Encoded in utf8.
-
-## Numbers and math
-Cell can be compiled with different levels of exactness for numeracy. Any number which cannot be represented exactly becomes "null". Any numeric operation which includes "null" results in "null".
-
-Using short floats in a 64 bit system means you have doubles in the range of +- 10^38, not the full range of double. If you create a number out of that range, it's null.
-
-You can also compile a 64 bit system with full precision doubles, but this will use more memory and may be slower.
-
-You can also compile a 64 bit system with 32 bit floats, stored as a 32 bit int is. Again, out of the 32 bit float range = null.
-
-You can compile without floating point support at all; 32 bit ints are then used for fixed point calculations.
-
-Or, you can compile using Dec64, which is a 64 bit decimal floating point format, for exact precision.
-
-## Objects
-Objects are heap allocated, referenced by a pointer value. They are all preceded by an object header, the length of a word on the system.
-  
-### 64 bit build
-56 bits capacity
-1 bit memory reclamation flag: note that this obj has already been moved
-2 bit reserved (per object)
-1 bit stone: note that this obj is immutable
-3 bit type: note the type of the object
-1 bit: fwd: note that this obj is a forward linkage
-
-Last bit ..1:
-The forward type indicates that the object (an array, blob, pretext, or record) has grown beyond its capacity and is now residing at a new address. The remaining 63 bits contain the address of the enlarged object. Forward linkages are cleaned up by the memory reclaimer.
-
-Type 7: C light C object
-
-Header
-Pointer
-
-Capacity is an ID of a registered C type.
-Pointer is a pointer to the opaque C object.
-
-Type 0: Array
-Header
-Length
-Element[]
-
-Capacity is number of elements the array can hold. Length is number of elements in use. Number of words used by an array is capacity + 2.
-
-Type 1: blob
-Header
-Length
-Bit[]
-Capacity is number of bits the blob can hold. Length is number of bits in use. Bits follow, from [0] to [capacity - 1], with [0] bit in the most significant position of word 2, and [63] in the least significant position of word 2. The last word is zero filled, if necessary.
-
-Number of words used is (capacity + 63) // 64 + 2
-
-Type 2: Text
-Text has two forms, depending on if it is stone or not, which changes the meaning of its length word.
-
-Header
-Length(pretext) or Hash(text)
-Character[0] and character[1]
-
-Capacity of pretex is the number of characters it can hold. During stoning and reclamation, capacity is set to the length.
-
-The capacity of a text is its length.
-
-The length of a pretext is the number of characters it contains; it is not greater than the capacity.
-
-Hash of a text is used for organizing records. If the hash is zero, it's not been computed yet. All texts in the immutable memory have hashes.
-
-A text object contains UTF32 characters, packed two per word. If the number of characters is odd, the least significant half of the last word is zero filled.
-
-The number of words used by a text is (capacity + 1) // 2 + 2
-
-Type 3: Record
-
-A record is an array of fields represented as key/value pairs. Fields are located by hashes of texts, using open addressing with linear probing and lazy deletion. The load factor is less than 0.5.
-
-Header
-Prototype
-Length
-Key[0]
-Value[0]
-Key[1]
-Value[1]
-...
-
-The capacity is the number of fields the record can hold. It is a power of two minus one. It is at least twice the length.
-
-The length is the number of fields that the record currently contains.
-
-A field candidate number is identified by and(key.hash, capacity). In case of hash collision, advance to the next field. If this goes past the end, continue with field 1. Field 0 is reserved.
-
-The "exception" special tag is used to mark deleted entries in the object map.
-
-The number of words used by a record is (capacity + 1) * 2.
-
-Prototypes are searched for for properties if one cannot be found on the record itself. Prototypes can have prototypes.
-
-#### key[0] and value[0]
-These are reserved for internal use, and skipped over during key probing.
-
-The first 32 bits of key are used as a 32 bit integer key, if this object has ever been used as a key itself.
-
-The last 32 bits are used as an opaque C class key. C types can be registered with the system, and each are assigned a monotonically increasing number. In the case that this object has a C type, then the bottom 32 bits of key[0] are not 0. If that is the case, then a pointer to its C object is stored in value[0].
-
-#### Valid keys & Hashing
-Keys are stored directly in object maps. There are three possibilities for a vaild key: an object text, an object record, or an immediate text.
-
-In the case of an immediate text, the hash is computed on the fly using the fash64_hash_one function, before being used to look up the key in the object map. Direct value comparison is used to confirm the key.
-
-For object texts (texts longer than 7 ascii chars), the hash is stored in the text object itself. When an object text is used as a key, a stone version is created and interned. Any program static texts reference this stoned, interned text. When looking up a heap text as a key, it is first discovered if it's in the interned table. If it's not, the key is not in the object (since all keys are interned). If it is, the interned version is returned to check against the object map. The hash of the interned text is used to look up the key in the object map, and then direct pointer comparison is used to confirm the key.
-
-For record keys, these are unique; once a record is used as a key, it gets assigned a monotonically increasing 32 bit integer, stored in key[0]. When checking it in an object map, the integer is used directly as the key. If key[0] is 0, the record has not been used as a key yet. If it's not 0, fash64_hash_one is used to compute a hash of its ID, and then direct value pointer comparison is used to confirm.
-
-### Text interning
-Texts that cannot fit in an immediate, and which are used as an object key, create a stoned and interned version (the pointer which is used as the key). Any text literals are also stoned and interned.
-
-The interning table is an open addressed hash, with a load of 0.8, using a robin hood value. Probing is done using the text hash, confirmation is done using length, and then memcmp of the text.
-
-When the GC run, a new interned text table is created. Each text literal, and each text used as a key, is added to the new table, as the live objects are copied. This keeps the interning table from becoming a graveyard. Interned values are never deleted until a GC.
-
-Type 4: Function
-
-Header
-Code
-Outer
-A function object has zero capacity and is always stone.
-
-Code is a pointer to the code object that the function executes.
-
-Outer is a pointer to the frame that created this function object.
-
-Size is 3 words.
-
-Type 5: Frame
-
-Header
-Function
-Caller
-Return address
-
-The activation frame is created when a function is invoked to hold its linkages and state.
-
-The capacity is the number of slots, including the inputs, variables, temporaries, and the four words of overhead. A frame, unlike the other types, is never stone.
-
-The function is the address of the function object being called.
-
-The caller is the address of the frame that is invoking the function.
-
-The return address is the address of the instruction in the code that should be executed upon return.
-
-Next come the input arguments, if any.
-
-Then the variables closed over by the inner functions.
-
-Then the variables that are not closed over, followed by the temporaries.
-
-When a function returns, the caller is set to zero. This is a signal to the memory reclaimer that the frame can be reduced.
-
-Type 6: Code
-
-Header
-Arity
-Size
-Closure size
-Entry point
-Disruption point
-
-A code object exists in the actor's immutable memory. A code object never exists in mutable memory.
-
-A code object has a zero capacity and is always stone.
-
-The arity is the maximum number of inputs.
-
-The size is the capacity of an activation frame that will execute this code.
-
-The closure size is a reduced capacity for returned frames that survive memory reclamation.
-
-The entry point is the address at which to begin execution.
-
-The disruption point is the address of the disruption clause.
-
-### opaque C objects
-Records can have opaque C data attached to them.
-
-A C class can register a GC clean up, and a GC trace function. The trace function is called when the record is encountered in the live object graph; and it should mark any values it wants to keep alive in that function.
-
-The system maintains an array of live opaque C objects. When such an object is encountered, it marks it as live in the array. When the GC completes, it iterates this array and calls the GC clean up function for each C object in the array with alive=0. Alive is then cleared for the next GC cycle.
-
-## 32 bit build
-~3 bit type
-1 bit stone
-1 bit memory reclamation flag
-27 bit capacity
-
-Key differences here are
-
-blob max capacity is 2**27 bits = 2**24 bytes = 16 MB [this likely needs addressed]
-
-fwd is type ...0, and the pointer is 31 bits
-other types are
-111 array
-101 object
-011 blob
-001 
-
-## Memory
-Cell uses a single block of memory that it doles out as needed to the actors in its system.
-
-Actors are given a block of memory in standard sizes using a doubling buddy memory manager. An actor is given an immutable data section on birth, as well as a mutable data section. When its mutable data becomes full, it requests a new one. Actors utilize their mutable memory with a simple bump allocation. If there is not sufficient memory available, the actor suspends and its status changes to exhausted.
-
-The smallest block size is determined per platform, but it can be as small as 4KB on 64 bit systems.
-
-The actor is then given a new block of memory of the same size, and it runs a garbage collector to reclaim memory. It uses the cheney copying algorithm. If a disappointing amount of memory was reclaimed, it is noted, and the actor is given a larger block of memory on the next request.

docs/nota.md

@@ -0,0 +1,156 @@
+---
+title: "Nota Format"
+description: "Network Object Transfer Arrangement"
+weight: 85
+type: "docs"
+---
+
+Nota is a binary message format developed for use in the Procession Protocol. It provides a compact, JSON-like encoding that supports blobs, text, arrays, records, numbers, and symbols.
+
+Nota stands for Network Object Transfer Arrangement.
+
+## Design Philosophy
+
+JSON had three design rules: minimal, textual, and subset of JavaScript. The textual and JavaScript rules are no longer necessary. Nota maintains JSON's philosophy of being at the intersection of most programming languages and most data types, but departs by using counts instead of brackets and binary encoding instead of text.
+
+Nota uses Kim continuation bytes for counts and character encoding. See [Kim Encoding](#kim) for details.
+
+## Type Summary
+
+| Bits | Type |
+|------|------|
+| `000` | Blob |
+| `001` | Text |
+| `010` | Array |
+| `011` | Record |
+| `100` | Floating Point (positive exponent) |
+| `101` | Floating Point (negative exponent) |
+| `110` | Integer (zero exponent) |
+| `111` | Symbol |
+
+## Preambles
+
+Every Nota value starts with a preamble byte that is a Kim value with the three most significant bits used for type information.
+
+Most types provide 3 or 4 data bits in the preamble. If the Kim encoding of the data fits in those bits, it is incorporated directly and the continue bit is off. Otherwise the continue bit is on and the continuation follows.
+
+## Blob
+
+```
+C  0  0  0  D  D  D  D
+```
+
+- **C** — continue the number of bits
+- **DDDD** — the number of bits
+
+A blob is a string of bits. The data produces the number of bits. The number of bytes that follow: `floor((number_of_bits + 7) / 8)`. The final byte is padded with 0 if necessary.
+
+Example: A blob containing 25 bits `1111000011100011001000001`:
+
+```
+80 19 F0 E3 20 80
+```
+
+## Text
+
+```
+C  0  0  1  D  D  D  D
+```
+
+- **C** — continue the number of characters
+- **DDDD** — the number of characters
+
+The data produces the number of characters. Kim-encoded characters follow. ASCII characters are 1 byte, first quarter BMP characters are 2 bytes, all other Unicode characters are 3 bytes. Unlike JSON, there is never a need for escapement.
+
+Examples:
+
+```
+""          →  10
+"cat"       →  13 63 61 74
+```
+
+## Array
+
+```
+C  0  1  0  D  D  D  D
+```
+
+- **C** — continue the number of elements
+- **DDDD** — the number of elements
+
+An array is an ordered sequence of values. Following the preamble are the elements, each beginning with its own preamble. Nesting is encouraged.
+
+## Record
+
+```
+C  0  1  1  D  D  D  D
+```
+
+- **C** — continue the number of pairs
+- **DDDD** — the number of pairs
+
+A record is an unordered collection of key/value pairs. Keys must be text and must be unique within the record. Values can be any Nota type.
+
+## Floating Point
+
+```
+C  1  0  E  S  D  D  D
+```
+
+- **C** — continue the exponent
+- **E** — sign of the exponent
+- **S** — sign of the coefficient
+- **DDD** — three bits of the exponent
+
+Nota floating point represents numbers as `coefficient * 10^exponent`. The coefficient must be an integer. The preamble may contain the first three bits of the exponent, followed by the continuation of the exponent (if any), followed by the coefficient.
+
+Use the integer type when the exponent is zero.
+
+Examples:
+
+```
+-1.01                →  5A 65
+98.6                 →  51 87 5A
+-0.5772156649        →  D8 0A 95 C0 B0 BD 69
+-10000000000000      →  C8 0D 01
+```
+
+## Integer
+
+```
+C  1  1  0  S  D  D  D
+```
+
+- **C** — continue the integer
+- **S** — sign
+- **DDD** — three bits of the integer
+
+Integers in the range -7 to 7 fit in a single byte. Integers in the range -1023 to 1023 fit in two bytes. Integers in the range -131071 to 131071 fit in three bytes.
+
+Examples:
+
+```
+0      →  60
+2023   →  E0 8F 67
+-1     →  69
+```
+
+## Symbol
+
+```
+0  1  1  1  D  D  D  D
+```
+
+- **DDDD** — the symbol
+
+There are currently five symbols:
+
+```
+null     →  70
+false    →  72
+true     →  73
+private  →  78
+system   →  79
+```
+
+The private prefix must be followed by a record containing a private process address. The system prefix must be followed by a record containing a system message. All other symbols are reserved.

docs/packages.md

@@ -1,14 +1,19 @@
-# Packages
+---
+title: "Packages"
+description: "Code organization and sharing in ƿit"
+weight: 30
+type: "docs"
+---
 
-Packages are the fundamental unit of code organization and sharing in Cell.
+Packages are the fundamental unit of code organization and sharing in ƿit.
 
 ## Package Structure
 
-A package is a directory containing a `cell.toml` manifest:
+A package is a directory containing a `pit.toml` manifest:
 
 ```
 mypackage/
-├── cell.toml        # package manifest
+├── pit.toml         # package manifest
 ├── main.ce          # entry point (optional)
 ├── utils.cm         # module
 ├── helper/
@@ -17,7 +22,7 @@ mypackage/
 └── _internal.cm     # private module (underscore prefix)
 ```
 
-## cell.toml
+## pit.toml
 
 The package manifest declares metadata and dependencies:
 
@@ -38,11 +43,11 @@ mylib = "/Users/john/work/mylib"
 
 ## Module Resolution
 
-When importing with `use()`, Cell searches in order:
+When importing with `use()`, ƿit searches in order:
 
 1. **Local package** — relative to package root
-2. **Dependencies** — via aliases in `cell.toml`
-3. **Core** — built-in Cell modules
+2. **Dependencies** — via aliases in `pit.toml`
+3. **Core** — built-in ƿit modules
 
 ```javascript
 // In package 'myapp' with dependency: renderer = "gitea.pockle.world/john/renderer"
@@ -85,10 +90,10 @@ Local packages are symlinked into the shop, making development seamless.
 
 ## The Shop
 
-Cell stores all packages in the **shop** at `~/.cell/`:
+ƿit stores all packages in the **shop** at `~/.pit/`:
 
 ```
-~/.cell/
+~/.pit/
 ├── packages/
 │   ├── core -> gitea.pockle.world/john/cell
 │   ├── gitea.pockle.world/
@@ -134,20 +139,20 @@ target = "/Users/john/work/prosperon"
 
 ```bash
 # Install from remote
-cell install gitea.pockle.world/john/prosperon
+pit install gitea.pockle.world/john/prosperon
 
 # Install from local path
-cell install /Users/john/work/mylib
+pit install /Users/john/work/mylib
 ```
 
 ## Updating Packages
 
 ```bash
 # Update all
-cell update
+pit update
 
 # Update specific package
-cell update gitea.pockle.world/john/prosperon
+pit update gitea.pockle.world/john/prosperon
 ```
 
 ## Development Workflow
@@ -156,12 +161,12 @@ For active development, link packages locally:
 
 ```bash
 # Link a package for development
-cell link add gitea.pockle.world/john/prosperon /Users/john/work/prosperon
+pit link add gitea.pockle.world/john/prosperon /Users/john/work/prosperon
 
 # Changes to /Users/john/work/prosperon are immediately visible
 
 # Remove link when done
-cell link delete gitea.pockle.world/john/prosperon
+pit link delete gitea.pockle.world/john/prosperon
 ```
 
 ## C Extensions
@@ -170,14 +175,14 @@ C files in a package are compiled into a dynamic library:
 
 ```
 mypackage/
-├── cell.toml
+├── pit.toml
 ├── render.c      # compiled to mypackage.dylib
-└── render.cm     # optional Cell wrapper
+└── render.cm     # optional ƿit wrapper
 ```
 
-The library is named after the package and placed in `~/.cell/lib/`.
+The library is named after the package and placed in `~/.pit/lib/`.
 
-See [Writing C Modules](c-modules.md) for details.
+See [Writing C Modules](/docs/c-modules/) for details.
 
 ## Platform-Specific Files
 
@@ -190,4 +195,4 @@ mypackage/
 └── audio_emscripten.c # Web-specific
 ```
 
-Cell selects the appropriate file based on the build target.
+ƿit selects the appropriate file based on the build target.

docs/requestors.md

@@ -0,0 +1,176 @@
+---
+title: "Requestors"
+description: "Asynchronous work with requestors"
+weight: 25
+type: "docs"
+---
+
+Requestors are functions that encapsulate asynchronous work. They provide a structured way to compose callbacks, manage cancellation, and coordinate concurrent operations between actors.
+
+## What is a Requestor
+
+A requestor is a function with this signature:
+
+```javascript
+var my_requestor = function(callback, value) {
+  // Do async work, then call callback with result
+  // Return a cancel function
+}
+```
+
+- **callback** — called when the work completes: `callback(value, reason)`
+  - On success: `callback(result)` or `callback(result, null)`
+  - On failure: `callback(null, reason)` where reason explains the failure
+- **value** — input passed from the previous step (or the initial caller)
+- **return** — a cancel function, or null if cancellation is not supported
+
+The cancel function, when called, should abort the in-progress work.
+
+## Writing a Requestor
+
+```javascript
+var fetch_data = function(callback, url) {
+  $contact(function(connection) {
+    $send(connection, {get: url}, function(response) {
+      callback(response)
+    })
+  }, {host: url, port: 80})
+  return function() {
+    // clean up if needed
+  }
+}
+```
+
+A requestor that always succeeds immediately:
+
+```javascript
+var constant = function(callback, value) {
+  callback(42)
+}
+```
+
+A requestor that always fails:
+
+```javascript
+var broken = function(callback, value) {
+  callback(null, "something went wrong")
+}
+```
+
+## Composing Requestors
+
+ƿit provides four built-in functions for composing requestors into pipelines.
+
+### sequence(requestor_array)
+
+Run requestors one after another. Each result becomes the input to the next. The final result is passed to the callback.
+
+```javascript
+var pipeline = sequence([
+  fetch_user,
+  validate_permissions,
+  load_profile
+])
+
+pipeline(function(profile, reason) {
+  if (reason) {
+    print(reason)
+  } else {
+    print(profile.name)
+  }
+}, user_id)
+```
+
+If any step fails, the remaining steps are skipped and the failure propagates.
+
+### parallel(requestor_array, throttle, need)
+
+Start all requestors concurrently. Results are collected into an array matching the input order.
+
+```javascript
+var both = parallel([
+  fetch_profile,
+  fetch_settings
+])
+
+both(function(results, reason) {
+  var profile = results[0]
+  var settings = results[1]
+}, user_id)
+```
+
+- **throttle** — limit how many requestors run at once (null for no limit)
+- **need** — minimum number of successes required (default: all)
+
+### race(requestor_array, throttle, need)
+
+Like `parallel`, but returns as soon as the needed number of results arrive. Unfinished requestors are cancelled.
+
+```javascript
+var fastest = race([
+  fetch_from_cache,
+  fetch_from_network,
+  fetch_from_backup
+])
+
+fastest(function(results) {
+  // results[0] is whichever responded first
+}, request)
+```
+
+Default need is 1. Useful for redundant operations where only one result matters.
+
+### fallback(requestor_array)
+
+Try each requestor in order. If one fails, try the next. Return the first success.
+
+```javascript
+var resilient = fallback([
+  fetch_from_primary,
+  fetch_from_secondary,
+  use_cached_value
+])
+
+resilient(function(data, reason) {
+  if (reason) {
+    print("all sources failed")
+  }
+}, key)
+```
+
+## Timeouts
+
+Wrap any requestor with `$time_limit` to add a timeout:
+
+```javascript
+var timed = $time_limit(fetch_data, 5)  // 5 second timeout
+
+timed(function(result, reason) {
+  // reason will explain timeout if it fires
+}, url)
+```
+
+If the requestor does not complete within the time limit, it is cancelled and the callback receives a failure.
+
+## Requestors and Actors
+
+Requestors are particularly useful with actor messaging. Since `$send` is callback-based, it fits naturally:
+
+```javascript
+var ask_worker = function(callback, task) {
+  $send(worker, task, function(reply) {
+    callback(reply)
+  })
+}
+
+var pipeline = sequence([
+  ask_worker,
+  process_result,
+  store_result
+])
+
+pipeline(function(stored) {
+  print("done")
+  $stop()
+}, {type: "compute", data: [1, 2, 3]})
+```

docs/spec/.pages

@@ -0,0 +1,3 @@
+nav:
+  - pipeline.md
+  - mcode.md

docs/spec/c-runtime.md

@@ -0,0 +1,296 @@
+---
+title: "C Runtime for Native Code"
+description: "Minimum C runtime surface for QBE-generated native code"
+---
+
+## Overview
+
+QBE-generated native code calls into a C runtime for anything that touches the heap, dispatches dynamically, or requires GC awareness. The design principle: **native code handles control flow and integer math directly; everything else is a runtime call.**
+
+This document defines the runtime boundary — what must be in C, what QBE handles inline, and how to organize the C code to serve both the mcode interpreter and native code cleanly.
+
+## The Boundary
+
+### What native code does inline (no C calls)
+
+These operations compile to straight QBE instructions with no runtime involvement:
+
+- **Integer arithmetic**: `add`, `sub`, `mul` on NaN-boxed ints (shift right 1, operate, shift left 1)
+- **Integer comparisons**: extract int with shift, compare, produce tagged bool
+- **Control flow**: jumps, branches, labels, function entry/exit
+- **Slot access**: load/store to frame slots via `%fp` + offset
+- **NaN-box tagging**: integer tagging (`n << 1`), bool constants (`0x03`/`0x23`), null (`0x07`)
+- **Type tests**: `JS_IsInt` (LSB check), `JS_IsNumber`, `JS_IsText`, `JS_IsNull` — these are bit tests on the value, no heap access needed
+
+### What requires a C call
+
+Anything that:
+1. **Allocates** (arrays, records, strings, frames, function objects)
+2. **Touches the heap** (property get/set, array indexing, closure access)
+3. **Dispatches on type at runtime** (dynamic load/store, polymorphic arithmetic)
+4. **Calls user functions** (frame setup, argument passing, invocation)
+5. **Does string operations** (concatenation, comparison, conversion)
+
+## Runtime Functions
+
+### Tier 1: Essential (must exist for any program to run)
+
+These are called by virtually every QBE program.
+
+#### Intrinsic Lookup
+
+```c
+// Look up a built-in function by name. Called once per intrinsic per callsite.
+JSValue cell_rt_get_intrinsic(JSContext *ctx, const char *name);
+```
+
+Maps name → C function pointer wrapped in JSValue. This is the primary entry point for all built-in functions (`print`, `text`, `length`, `is_array`, etc). The native code never calls intrinsics directly — it always goes through `get_intrinsic` → `frame` → `invoke`.
+
+#### Function Calls
+
+```c
+// Allocate a call frame with space for nr_args arguments.
+JSValue cell_rt_frame(JSContext *ctx, JSValue fn, int nr_args);
+
+// Set argument idx in the frame.
+void cell_rt_setarg(JSValue frame, int idx, JSValue val);
+
+// Execute the function. Returns the result.
+JSValue cell_rt_invoke(JSContext *ctx, JSValue frame);
+```
+
+This is the universal calling convention. Every function call — user functions, intrinsics, methods — goes through frame/setarg/invoke. The frame allocates a `JSFrameRegister` on the GC heap, setarg fills slots, invoke dispatches.
+
+**Tail call variants:**
+
+```c
+JSValue cell_rt_goframe(JSContext *ctx, JSValue fn, int nr_args);
+void    cell_rt_goinvoke(JSContext *ctx, JSValue frame);
+```
+
+Same as frame/invoke but reuse the caller's stack position.
+
+### Tier 2: Property Access (needed by any program using records or arrays)
+
+```c
+// Record field by constant name.
+JSValue cell_rt_load_field(JSContext *ctx, JSValue obj, const char *name);
+void    cell_rt_store_field(JSContext *ctx, JSValue obj, JSValue val, const char *name);
+
+// Array element by integer index.
+JSValue cell_rt_load_index(JSContext *ctx, JSValue obj, JSValue idx);
+void    cell_rt_store_index(JSContext *ctx, JSValue obj, JSValue idx, JSValue val);
+
+// Dynamic — type of key unknown at compile time.
+JSValue cell_rt_load_dynamic(JSContext *ctx, JSValue obj, JSValue key);
+void    cell_rt_store_dynamic(JSContext *ctx, JSValue obj, JSValue key, JSValue val);
+```
+
+The typed variants (`load_field`/`load_index`) skip the key-type dispatch that `load_dynamic` must do. When parse and fold provide type information, QBE emit selects the typed variant and the streamline optimizer can narrow dynamic → typed.
+
+**Implementation**: These are thin wrappers around existing `JS_GetPropertyStr`/`JS_GetPropertyNumber`/`JS_GetProperty` and their `Set` counterparts.
+
+### Tier 3: Closures (needed by programs with nested functions)
+
+```c
+// Walk depth levels up the frame chain, read slot.
+JSValue cell_rt_get_closure(JSContext *ctx, JSValue fp, int depth, int slot);
+
+// Walk depth levels up, write slot.
+void    cell_rt_put_closure(JSContext *ctx, JSValue fp, JSValue val, int depth, int slot);
+```
+
+Closure variables live in outer frames. `depth` is how many `caller` links to follow; `slot` is the register index in that frame.
+
+### Tier 4: Object Construction (needed by programs creating arrays/records/functions)
+
+```c
+// Create a function object from a compiled function index.
+// The native code loader must maintain a function table.
+JSValue cell_rt_make_function(JSContext *ctx, int fn_id);
+```
+
+Array and record literals are currently compiled as intrinsic calls (`array(...)`, direct `{...}` construction) which go through the frame/invoke path. A future optimization could add:
+
+```c
+// Fast paths (optional, not yet needed)
+JSValue cell_rt_new_array(JSContext *ctx, int len);
+JSValue cell_rt_new_record(JSContext *ctx);
+```
+
+### Tier 5: Collection Operations
+
+```c
+// a[] = val (push) and var v = a[] (pop)
+void    cell_rt_push(JSContext *ctx, JSValue arr, JSValue val);
+JSValue cell_rt_pop(JSContext *ctx, JSValue arr);
+```
+
+### Tier 6: Error Handling
+
+```c
+// Trigger disruption. Jumps to the disrupt handler or unwinds.
+void cell_rt_disrupt(JSContext *ctx);
+```
+
+### Tier 7: Miscellaneous
+
+```c
+JSValue cell_rt_delete(JSContext *ctx, JSValue obj, JSValue key);
+JSValue cell_rt_typeof(JSContext *ctx, JSValue val);
+```
+
+### Tier 8: String and Float Helpers (called from QBE inline code, not from qbe_emit)
+
+These are called from the QBE IL that `qbe.cm` generates inline for arithmetic and comparison operations. They're not `cell_rt_` prefixed — they're lower-level:
+
+```c
+// Float arithmetic (when operands aren't both ints)
+JSValue qbe_float_add(JSContext *ctx, JSValue a, JSValue b);
+JSValue qbe_float_sub(JSContext *ctx, JSValue a, JSValue b);
+JSValue qbe_float_mul(JSContext *ctx, JSValue a, JSValue b);
+JSValue qbe_float_div(JSContext *ctx, JSValue a, JSValue b);
+JSValue qbe_float_mod(JSContext *ctx, JSValue a, JSValue b);
+JSValue qbe_float_pow(JSContext *ctx, JSValue a, JSValue b);
+JSValue qbe_float_neg(JSContext *ctx, JSValue v);
+JSValue qbe_float_inc(JSContext *ctx, JSValue v);
+JSValue qbe_float_dec(JSContext *ctx, JSValue v);
+
+// Float comparison (returns C int 0/1 for QBE branching)
+int qbe_float_cmp(JSContext *ctx, int op, JSValue a, JSValue b);
+
+// Bitwise ops on non-int values (convert to int32 first)
+JSValue qbe_bnot(JSContext *ctx, JSValue v);
+JSValue qbe_bitwise_and(JSContext *ctx, JSValue a, JSValue b);
+JSValue qbe_bitwise_or(JSContext *ctx, JSValue a, JSValue b);
+JSValue qbe_bitwise_xor(JSContext *ctx, JSValue a, JSValue b);
+JSValue qbe_shift_shl(JSContext *ctx, JSValue a, JSValue b);
+JSValue qbe_shift_sar(JSContext *ctx, JSValue a, JSValue b);
+JSValue qbe_shift_shr(JSContext *ctx, JSValue a, JSValue b);
+
+// String operations
+JSValue JS_ConcatString(JSContext *ctx, JSValue a, JSValue b);
+int     js_string_compare_value(JSContext *ctx, JSValue a, JSValue b, int eq_only);
+JSValue JS_NewString(JSContext *ctx, const char *str);
+JSValue __JS_NewFloat64(JSContext *ctx, double d);
+int     JS_ToBool(JSContext *ctx, JSValue v);
+
+// String/number type tests (inline-able but currently calls)
+int     JS_IsText(JSValue v);
+int     JS_IsNumber(JSValue v);
+
+// Tolerant equality (== on mixed types)
+JSValue cell_rt_eq_tol(JSContext *ctx, JSValue a, JSValue b);
+JSValue cell_rt_ne_tol(JSContext *ctx, JSValue a, JSValue b);
+
+// Text ordering comparisons
+JSValue cell_rt_lt_text(JSContext *ctx, JSValue a, JSValue b);
+JSValue cell_rt_le_text(JSContext *ctx, JSValue a, JSValue b);
+JSValue cell_rt_gt_text(JSContext *ctx, JSValue a, JSValue b);
+JSValue cell_rt_ge_text(JSContext *ctx, JSValue a, JSValue b);
+```
+
+## What Exists vs What Needs Writing
+
+### Already exists (in qbe_helpers.c)
+
+All `qbe_float_*`, `qbe_bnot`, `qbe_bitwise_*`, `qbe_shift_*`, `qbe_to_bool` — these are implemented and working.
+
+### Already exists (in runtime.c / quickjs.c) but not yet wrapped
+
+The underlying operations exist but aren't exposed with the `cell_rt_` names:
+
+| Runtime function | Underlying implementation |
+|---|---|
+| `cell_rt_load_field` | `JS_GetPropertyStr(ctx, obj, name)` |
+| `cell_rt_load_index` | `JS_GetPropertyNumber(ctx, obj, JS_VALUE_GET_INT(idx))` |
+| `cell_rt_load_dynamic` | `JS_GetProperty(ctx, obj, key)` |
+| `cell_rt_store_field` | `JS_SetPropertyStr(ctx, obj, name, val)` |
+| `cell_rt_store_index` | `JS_SetPropertyNumber(ctx, obj, JS_VALUE_GET_INT(idx), val)` |
+| `cell_rt_store_dynamic` | `JS_SetProperty(ctx, obj, key, val)` |
+| `cell_rt_delete` | `JS_DeleteProperty(ctx, obj, key)` |
+| `cell_rt_push` | `JS_ArrayPush(ctx, &arr, val)` |
+| `cell_rt_pop` | `JS_ArrayPop(ctx, arr)` |
+| `cell_rt_typeof` | type tag switch → `JS_NewString` |
+| `cell_rt_disrupt` | `JS_Throw(ctx, ...)` |
+| `cell_rt_eq_tol` / `cell_rt_ne_tol` | comparison logic in mcode.c `eq_tol`/`ne_tol` handler |
+| `cell_rt_lt_text` etc. | `js_string_compare_value` + wrap result |
+
+### Needs new code
+
+| Runtime function | What's needed |
+|---|---|
+| `cell_rt_get_intrinsic` | Look up intrinsic by name string, return JSValue function. Currently scattered across `js_cell_intrinsic_get` and the mcode handler. Needs a clean single entry point. |
+| `cell_rt_frame` | Allocate `JSFrameRegister`, set function slot, set argc. Exists in mcode.c `frame` handler but not as a callable function. |
+| `cell_rt_setarg` | Write to frame slot. Trivial: `frame->slots[idx + 1] = val` (slot 0 is `this`). |
+| `cell_rt_invoke` | Call the function in the frame. Needs to dispatch: native C function vs mach bytecode vs mcode. This is the critical piece — it must handle all function types. |
+| `cell_rt_goframe` / `cell_rt_goinvoke` | Tail call variants. Similar to frame/invoke but reuse caller frame. |
+| `cell_rt_make_function` | Create function object from index. Needs a function table (populated by the native loader). |
+| `cell_rt_get_closure` / `cell_rt_put_closure` | Walk frame chain. Exists inline in mcode.c `get`/`put` handlers. |
+
+## Recommended C File Organization
+
+```
+source/
+  cell_runtime.c    — NEW: all cell_rt_* functions (the native code API)
+  qbe_helpers.c     — existing: float/bitwise/shift helpers for inline QBE
+  runtime.c         — existing: JS_GetProperty, JS_SetProperty, etc.
+  quickjs.c         — existing: core VM, GC, value representation
+  mcode.c           — existing: mcode interpreter (can delegate to cell_runtime.c)
+```
+
+**`cell_runtime.c`** is the single file that defines the native code contract. It should:
+
+1. Include `quickjs-internal.h` for access to value representation and heap types
+2. Export all `cell_rt_*` functions with C linkage (no `static`)
+3. Keep each function thin — delegate to existing `JS_*` functions where possible
+4. Handle GC safety: after any allocation (frame, string, array), callers' frames may have moved
+
+### Implementation Priority
+
+**Phase 1** — Get "hello world" running natively:
+- `cell_rt_get_intrinsic` (to find `print` and `text`)
+- `cell_rt_frame`, `cell_rt_setarg`, `cell_rt_invoke` (to call them)
+- A loader that takes QBE output → assembles → links → calls `cell_main`
+
+**Phase 2** — Variables and arithmetic:
+- All property access (`load_field`, `load_index`, `store_*`, `load_dynamic`)
+- `cell_rt_make_function`, `cell_rt_get_closure`, `cell_rt_put_closure`
+
+**Phase 3** — Full language:
+- `cell_rt_push`, `cell_rt_pop`, `cell_rt_delete`, `cell_rt_typeof`
+- `cell_rt_disrupt`
+- `cell_rt_goframe`, `cell_rt_goinvoke`
+- Text comparison wrappers (`cell_rt_lt_text`, etc.)
+- Tolerant equality (`cell_rt_eq_tol`, `cell_rt_ne_tol`)
+
+## Calling Convention
+
+All `cell_rt_*` functions follow the same pattern:
+
+- First argument is always `JSContext *ctx`
+- Values are passed/returned as `JSValue` (64-bit, by value)
+- Frame pointers are `JSValue` (tagged pointer to `JSFrameRegister`)
+- String names are `const char *` (pointer to data section label)
+- Integer constants (slot indices, arg counts) are `int` / `long`
+
+Native code maintains `%ctx` (JSContext) and `%fp` (current frame pointer) as persistent values across the function body. All slot reads/writes go through `%fp` + offset.
+
+## What Should NOT Be in the C Runtime
+
+These are handled entirely by QBE-generated code:
+
+- **Integer arithmetic and comparisons** — bit operations on NaN-boxed values
+- **Control flow** — branches, loops, labels, jumps
+- **Boolean logic** — `and`/`or`/`not` on tagged values
+- **Constant loading** — integer constants are immediate, strings are data labels
+- **Type guard branches** — the `is_int`/`is_text`/`is_null` checks are inline bit tests; the branch to the float or text path is just a QBE `jnz`
+
+The `qbe.cm` macros already handle all of this. The arithmetic path looks like:
+
+```
+check both ints? → yes → inline int add → done
+                 → no  → call qbe_float_add (or JS_ConcatString for text)
+```
+
+The C runtime is only called on the slow paths (float, text, dynamic dispatch). The fast path (integer arithmetic, comparisons, branching) is fully native.

docs/spec/dec64.md

@@ -0,0 +1,77 @@
+---
+title: "DEC64 Numbers"
+description: "Decimal floating point representation"
+---
+
+## Overview
+
+ƿit uses DEC64 as its number format. DEC64 represents numbers as `coefficient * 10^exponent` in a 64-bit word. This eliminates the rounding errors that plague IEEE 754 binary floating point — `0.1 + 0.2` is exactly `0.3`.
+
+DEC64 was designed by Douglas Crockford as a general-purpose number type suitable for both business and scientific computation.
+
+## Format
+
+A DEC64 number is a 64-bit value:
+
+```
+[coefficient: 56 bits][exponent: 8 bits]
+```
+
+- **Coefficient** — a 56-bit signed integer (two's complement)
+- **Exponent** — an 8-bit signed integer (range: -127 to 127)
+
+The value of a DEC64 number is: `coefficient * 10^exponent`
+
+### Examples
+
+| Value | Coefficient | Exponent | Hex |
+|-------|------------|----------|-----|
+| `0` | 0 | 0 | `0000000000000000` |
+| `1` | 1 | 0 | `0000000000000100` |
+| `3.14159` | 314159 | -5 | `000000004CB2FFFB` |
+| `-1` | -1 | 0 | `FFFFFFFFFFFFFF00` |
+| `1000000` | 1 | 6 | `0000000000000106` |
+
+## Special Values
+
+### Null
+
+The exponent `0x80` (-128) indicates null. This is the only special value — there is no infinity, no NaN, no negative zero. Operations that would produce undefined results (such as division by zero) return null.
+
+```
+coefficient: any, exponent: 0x80  →  null
+```
+
+## Arithmetic Properties
+
+- **Exact decimals**: All decimal fractions with up to 17 significant digits are represented exactly
+- **No rounding**: `0.1 + 0.2 == 0.3` is true
+- **Integer range**: Exact integers up to 2^55 (about 3.6 * 10^16)
+- **Normalized on demand**: The runtime normalizes coefficients to remove trailing zeros when needed for comparison
+
+## Comparison with IEEE 754
+
+| Property | DEC64 | IEEE 754 double |
+|----------|-------|----------------|
+| Decimal fractions | Exact | Approximate |
+| Significant digits | ~17 | ~15-16 |
+| Special values | null only | NaN, ±Infinity, -0 |
+| Rounding errors | None (decimal) | Common |
+| Financial arithmetic | Correct | Requires libraries |
+| Scientific range | ±10^127 | ±10^308 |
+
+DEC64 trades a smaller exponent range for exact decimal arithmetic. Most applications never need exponents beyond ±127.
+
+## In ƿit
+
+All numbers in ƿit are DEC64. There is no separate integer type at the language level — the distinction is internal. The `is_integer` function checks whether a number has no fractional part.
+
+```javascript
+var x = 42        // coefficient: 42, exponent: 0
+var y = 3.14      // coefficient: 314, exponent: -2
+var z = 1000000   // coefficient: 1, exponent: 6 (normalized)
+
+is_integer(x)     // true
+is_integer(y)     // false
+1 / 0             // null
+```

docs/spec/gc.md

@@ -0,0 +1,82 @@
+---
+title: "Garbage Collection"
+description: "Cheney copying collector"
+---
+
+## Overview
+
+ƿit uses a Cheney copying collector for automatic memory management. Each actor has its own independent heap — actors never share mutable memory, so garbage collection is per-actor with no global pauses.
+
+## Algorithm
+
+The Cheney algorithm is a two-space copying collector:
+
+1. **Allocate new space** — a fresh memory block for the new heap
+2. **Copy roots** — copy all live root objects from old space to new space
+3. **Scan** — walk the new space, updating all internal references
+4. **Free old space** — the entire old heap is freed at once
+
+### Copying and Forwarding
+
+When an object is copied from old space to new space:
+
+1. The object's data is copied to the next free position in new space
+2. The old object's header is overwritten with a **forwarding pointer** (`OBJ_FORWARD`) containing the new address
+3. Future references to the old address find the forwarding pointer and follow it to the new location
+
+```
+Old space:                 New space:
+┌──────────────┐          ┌──────────────┐
+│ OBJ_FORWARD ─┼────────> │ copied object│
+│ (new addr)   │          │              │
+└──────────────┘          └──────────────┘
+```
+
+### Scan Phase
+
+After roots are copied, the collector scans new space linearly. For each object, it examines every JSValue field:
+
+- If the field points to old space, copy the referenced object (or follow its forwarding pointer if already copied)
+- If the field points to stone memory, skip it (stone objects are permanent)
+- If the field is an immediate value (integer, boolean, null, immediate string), skip it
+
+The scan continues until the scan pointer catches up with the allocation pointer — at that point, all live objects have been found and copied.
+
+## Roots
+
+The collector traces from these root sources:
+
+- **Global object** — all global variables
+- **Class prototypes** — built-in type prototypes
+- **Exception** — the current exception value
+- **Value stack** — all values on the operand stack
+- **Frame stack** — all stack frames (register VM and mcode)
+- **GC reference stack** — manually registered roots (via `JS_PUSH_VALUE` / `JS_POP_VALUE`)
+- **Parser constant pool** — during compilation, constants being built
+
+## Per-Actor Heaps
+
+Each actor maintains its own heap with independent collection:
+
+- No stop-the-world pauses across actors
+- No synchronization between collectors
+- Each actor's GC runs at the end of a turn (between message deliveries)
+- Heap sizes adapt independently based on each actor's allocation patterns
+
+## Heap Growth
+
+The collector uses a buddy allocator for heap blocks. After each collection, if less than 20% of the heap was recovered, the next block size is doubled. The new space size is: `max(live_estimate + alloc_size, next_block_size)`.
+
+All allocations within a heap block use bump allocation (advance a pointer), which is extremely fast.
+
+## Alignment
+
+All objects are aligned to 8-byte boundaries. Object sizes are rounded up to ensure this alignment, which guarantees that the low 3 bits of any heap pointer are always zero — available for JSValue tag bits.
+
+## Interaction with Stone Memory
+
+Stone memory objects (S bit set) are never copied by the collector. When the scanner encounters a pointer to stone memory, it leaves it unchanged. This means:
+
+- Stone objects are effectively permanent GC roots
+- No overhead for tracing through immutable object graphs
+- Module return values and interned strings impose zero GC cost

docs/spec/mach.md

@@ -0,0 +1,84 @@
+---
+title: "Register VM"
+description: "Binary encoding of the Mach bytecode interpreter"
+---
+
+## Overview
+
+The Mach VM is a register-based virtual machine that directly interprets the [Mcode IR](mcode.md) instruction set as compact 32-bit binary bytecode. It is modeled after Lua's register VM — operands are register indices rather than stack positions, reducing instruction count and improving performance.
+
+The Mach serializer (`mach.c`) converts streamlined mcode JSON into binary instructions. Since the Mach bytecode is a direct encoding of the mcode, the [Mcode IR](mcode.md) reference is the authoritative instruction set documentation.
+
+## Instruction Formats
+
+All instructions are 32 bits wide. Four encoding formats are used:
+
+### iABC — Three-Register
+
+```
+[op: 8][A: 8][B: 8][C: 8]
+```
+
+Used for operations on three registers: `R(A) = R(B) op R(C)`.
+
+### iABx — Register + Constant
+
+```
+[op: 8][A: 8][Bx: 16]
+```
+
+Used for loading constants: `R(A) = K(Bx)`.
+
+### iAsBx — Register + Signed Offset
+
+```
+[op: 8][A: 8][sBx: 16]
+```
+
+Used for conditional jumps: if `R(A)` then jump by `sBx`.
+
+### isJ — Signed Jump
+
+```
+[op: 8][sJ: 24]
+```
+
+Used for unconditional jumps with a 24-bit signed offset.
+
+## Registers
+
+Each function frame has a fixed number of register slots, determined at compile time:
+
+- **R(0)** — `this` binding
+- **R(1)..R(arity)** — function arguments
+- **R(arity+1)..** — local variables and temporaries
+
+## JSCodeRegister
+
+The compiled output for a function:
+
+```c
+struct JSCodeRegister {
+  uint16_t arity;           // argument count
+  uint16_t nr_slots;        // total register count
+  uint32_t cpool_count;     // constant pool size
+  JSValue *cpool;           // constant pool
+  uint32_t instr_count;     // instruction count
+  MachInstr32 *instructions; // 32-bit instruction array
+  uint32_t func_count;      // nested function count
+  JSCodeRegister **functions; // nested function table
+  JSValue name;             // function name
+  uint16_t disruption_pc;   // disruption handler offset
+};
+```
+
+The constant pool holds all non-immediate values referenced by `LOADK` instructions: strings, large numbers, and other constants.
+
+### Constant Pool Index Overflow
+
+Named property instructions (`LOAD_FIELD`, `STORE_FIELD`, `DELETE`) use the iABC format where the constant pool key index occupies an 8-bit field (max 255). When a function references more than 256 unique property names, the serializer automatically falls back to a two-instruction sequence:
+
+1. `LOADK tmp, key_index` — load the key string into a temporary register (iABx, 16-bit index)
+2. `LOAD_DYNAMIC` / `STORE_DYNAMIC` / `DELETEINDEX` — use the register-based variant
+
+This is transparent to the mcode compiler and streamline optimizer.

docs/spec/mcode.md

@@ -0,0 +1,346 @@
+---
+title: "Mcode IR"
+description: "Instruction set reference for the JSON-based intermediate representation"
+---
+
+## Overview
+
+Mcode is the intermediate representation at the center of the ƿit compilation pipeline. All source code is lowered to mcode before execution or native compilation. The mcode instruction set is the **authoritative reference** for the operations supported by the ƿit runtime — the Mach VM bytecode is a direct binary encoding of these same instructions.
+
+```
+Source → Tokenize → Parse → Fold → Mcode → Streamline → Machine
+```
+
+Mcode is produced by `mcode.cm`, optimized by `streamline.cm`, then either serialized to 32-bit bytecode for the Mach VM (`mach.c`), or lowered to QBE/LLVM IL for native compilation (`qbe_emit.cm`). See [Compilation Pipeline](pipeline.md) for the full overview.
+
+## Instruction Format
+
+Each instruction is a JSON array. The first element is the instruction name (string), followed by operands. The last two elements are line and column numbers for source mapping:
+
+```json
+["add_int", dest, a, b, line, col]
+["load_field", dest, obj, "key", line, col]
+["jump", "label_name"]
+```
+
+Operands are register slot numbers (integers), constant values (strings, numbers), or label names (strings).
+
+## Instruction Reference
+
+### Loading and Constants
+
+| Instruction | Operands | Description |
+|-------------|----------|-------------|
+| `access` | `dest, name` | Load variable by name (intrinsic or environment) |
+| `int` | `dest, value` | Load integer constant |
+| `true` | `dest` | Load boolean `true` |
+| `false` | `dest` | Load boolean `false` |
+| `null` | `dest` | Load `null` |
+| `move` | `dest, src` | Copy register value |
+| `function` | `dest, id` | Load nested function by index |
+| `regexp` | `dest, pattern` | Create regexp object |
+
+### Arithmetic — Integer
+
+| Instruction | Operands | Description |
+|-------------|----------|-------------|
+| `add_int` | `dest, a, b` | `dest = a + b` (integer) |
+| `sub_int` | `dest, a, b` | `dest = a - b` (integer) |
+| `mul_int` | `dest, a, b` | `dest = a * b` (integer) |
+| `div_int` | `dest, a, b` | `dest = a / b` (integer) |
+| `mod_int` | `dest, a, b` | `dest = a % b` (integer) |
+| `neg_int` | `dest, src` | `dest = -src` (integer) |
+
+### Arithmetic — Float
+
+| Instruction | Operands | Description |
+|-------------|----------|-------------|
+| `add_float` | `dest, a, b` | `dest = a + b` (float) |
+| `sub_float` | `dest, a, b` | `dest = a - b` (float) |
+| `mul_float` | `dest, a, b` | `dest = a * b` (float) |
+| `div_float` | `dest, a, b` | `dest = a / b` (float) |
+| `mod_float` | `dest, a, b` | `dest = a % b` (float) |
+| `neg_float` | `dest, src` | `dest = -src` (float) |
+
+### Arithmetic — Generic
+
+| Instruction | Operands | Description |
+|-------------|----------|-------------|
+| `pow` | `dest, a, b` | `dest = a ^ b` (exponentiation) |
+
+### Text
+
+| Instruction | Operands | Description |
+|-------------|----------|-------------|
+| `concat` | `dest, a, b` | `dest = a ~ b` (text concatenation) |
+
+### Comparison — Integer
+
+| Instruction | Operands | Description |
+|-------------|----------|-------------|
+| `eq_int` | `dest, a, b` | `dest = a == b` (integer) |
+| `ne_int` | `dest, a, b` | `dest = a != b` (integer) |
+| `lt_int` | `dest, a, b` | `dest = a < b` (integer) |
+| `le_int` | `dest, a, b` | `dest = a <= b` (integer) |
+| `gt_int` | `dest, a, b` | `dest = a > b` (integer) |
+| `ge_int` | `dest, a, b` | `dest = a >= b` (integer) |
+
+### Comparison — Float
+
+| Instruction | Operands | Description |
+|-------------|----------|-------------|
+| `eq_float` | `dest, a, b` | `dest = a == b` (float) |
+| `ne_float` | `dest, a, b` | `dest = a != b` (float) |
+| `lt_float` | `dest, a, b` | `dest = a < b` (float) |
+| `le_float` | `dest, a, b` | `dest = a <= b` (float) |
+| `gt_float` | `dest, a, b` | `dest = a > b` (float) |
+| `ge_float` | `dest, a, b` | `dest = a >= b` (float) |
+
+### Comparison — Text
+
+| Instruction | Operands | Description |
+|-------------|----------|-------------|
+| `eq_text` | `dest, a, b` | `dest = a == b` (text) |
+| `ne_text` | `dest, a, b` | `dest = a != b` (text) |
+| `lt_text` | `dest, a, b` | `dest = a < b` (lexicographic) |
+| `le_text` | `dest, a, b` | `dest = a <= b` (lexicographic) |
+| `gt_text` | `dest, a, b` | `dest = a > b` (lexicographic) |
+| `ge_text` | `dest, a, b` | `dest = a >= b` (lexicographic) |
+
+### Comparison — Boolean
+
+| Instruction | Operands | Description |
+|-------------|----------|-------------|
+| `eq_bool` | `dest, a, b` | `dest = a == b` (boolean) |
+| `ne_bool` | `dest, a, b` | `dest = a != b` (boolean) |
+
+### Comparison — Special
+
+| Instruction | Operands | Description |
+|-------------|----------|-------------|
+| `is_identical` | `dest, a, b` | Object identity check (same reference) |
+| `eq_tol` | `dest, a, b` | Equality with tolerance |
+| `ne_tol` | `dest, a, b` | Inequality with tolerance |
+
+### Type Checks
+
+Inlined from intrinsic function calls. Each sets `dest` to `true` or `false`.
+
+| Instruction | Operands | Description |
+|-------------|----------|-------------|
+| `is_int` | `dest, src` | Check if integer |
+| `is_num` | `dest, src` | Check if number (integer or float) |
+| `is_text` | `dest, src` | Check if text |
+| `is_bool` | `dest, src` | Check if logical |
+| `is_null` | `dest, src` | Check if null |
+| `is_array` | `dest, src` | Check if array |
+| `is_func` | `dest, src` | Check if function |
+| `is_record` | `dest, src` | Check if record (object) |
+| `is_stone` | `dest, src` | Check if stone (immutable) |
+| `is_proxy` | `dest, src` | Check if function proxy (arity 2) |
+
+### Logical
+
+| Instruction | Operands | Description |
+|-------------|----------|-------------|
+| `not` | `dest, src` | Logical NOT |
+| `and` | `dest, a, b` | Logical AND |
+| `or` | `dest, a, b` | Logical OR |
+
+### Bitwise
+
+| Instruction | Operands | Description |
+|-------------|----------|-------------|
+| `bitand` | `dest, a, b` | Bitwise AND |
+| `bitor` | `dest, a, b` | Bitwise OR |
+| `bitxor` | `dest, a, b` | Bitwise XOR |
+| `bitnot` | `dest, src` | Bitwise NOT |
+| `shl` | `dest, a, b` | Shift left |
+| `shr` | `dest, a, b` | Arithmetic shift right |
+| `ushr` | `dest, a, b` | Unsigned shift right |
+
+### Property Access
+
+Memory operations come in typed variants. The compiler selects the appropriate variant based on `type_tag` and `access_kind` annotations from parse and fold.
+
+| Instruction | Operands | Description |
+|-------------|----------|-------------|
+| `load_field` | `dest, obj, key` | Load record property by string key |
+| `store_field` | `obj, val, key` | Store record property by string key |
+| `load_index` | `dest, obj, idx` | Load array element by integer index |
+| `store_index` | `obj, val, idx` | Store array element by integer index |
+| `load_dynamic` | `dest, obj, key` | Load property (dispatches at runtime) |
+| `store_dynamic` | `obj, val, key` | Store property (dispatches at runtime) |
+| `delete` | `obj, key` | Delete property |
+| `in` | `dest, obj, key` | Check if property exists |
+| `length` | `dest, src` | Get length of array or text |
+
+### Object and Array Construction
+
+| Instruction | Operands | Description |
+|-------------|----------|-------------|
+| `record` | `dest` | Create empty record `{}` |
+| `array` | `dest, n` | Create empty array (elements added via `push`) |
+| `push` | `arr, val` | Push value to array |
+| `pop` | `dest, arr` | Pop value from array |
+
+### Function Calls
+
+Function calls are decomposed into three instructions:
+
+| Instruction | Operands | Description |
+|-------------|----------|-------------|
+| `frame` | `dest, fn, argc` | Allocate call frame for `fn` with `argc` arguments |
+| `setarg` | `frame, idx, val` | Set argument `idx` in call frame |
+| `invoke` | `frame, result` | Execute the call, store result |
+| `goframe` | `dest, fn, argc` | Allocate frame for async/concurrent call |
+| `goinvoke` | `frame, result` | Invoke async/concurrent call |
+
+### Variable Resolution
+
+| Instruction | Operands | Description |
+|-------------|----------|-------------|
+| `access` | `dest, name` | Load variable (intrinsic or module environment) |
+| `set_var` | `name, src` | Set top-level variable by name |
+| `get` | `dest, level, slot` | Get closure variable from parent scope |
+| `put` | `level, slot, src` | Set closure variable in parent scope |
+
+### Control Flow
+
+| Instruction | Operands | Description |
+|-------------|----------|-------------|
+| `LABEL` | `name` | Define a named label (not executed) |
+| `jump` | `label` | Unconditional jump |
+| `jump_true` | `cond, label` | Jump if `cond` is true |
+| `jump_false` | `cond, label` | Jump if `cond` is false |
+| `jump_not_null` | `val, label` | Jump if `val` is not null |
+| `return` | `src` | Return value from function |
+| `disrupt` | — | Trigger disruption (error) |
+
+## Typed Instruction Design
+
+A key design principle of mcode is that **every type check is an explicit instruction**. Arithmetic and comparison operations come in type-specialized variants (`add_int`, `add_float`, `eq_text`, etc.) rather than a single polymorphic instruction.
+
+When type information is available from the fold stage, the compiler emits the typed variant directly. When the type is unknown, the compiler emits a type-check/dispatch pattern:
+
+```json
+["is_int", check, a]
+["jump_false", check, "float_path"]
+["add_int", dest, a, b]
+["jump", "done"]
+["LABEL", "float_path"]
+["add_float", dest, a, b]
+["LABEL", "done"]
+```
+
+The [Streamline Optimizer](streamline.md) eliminates dead branches when types are statically known, collapsing the dispatch to a single typed instruction.
+
+## Intrinsic Inlining
+
+The mcode compiler recognizes calls to built-in intrinsic functions and emits direct opcodes instead of the generic frame/setarg/invoke call sequence:
+
+| Source call | Emitted instruction |
+|-------------|-------------------|
+| `is_array(x)` | `is_array dest, src` |
+| `is_function(x)` | `is_func dest, src` |
+| `is_object(x)` | `is_record dest, src` |
+| `is_stone(x)` | `is_stone dest, src` |
+| `is_integer(x)` | `is_int dest, src` |
+| `is_text(x)` | `is_text dest, src` |
+| `is_number(x)` | `is_num dest, src` |
+| `is_logical(x)` | `is_bool dest, src` |
+| `is_null(x)` | `is_null dest, src` |
+| `length(x)` | `length dest, src` |
+| `push(arr, val)` | `push arr, val` |
+
+## Function Proxy Decomposition
+
+When the compiler encounters a method call `obj.method(args)`, it emits a branching pattern to handle ƿit's function proxy protocol. An arity-2 function used as a proxy target receives the method name and argument array instead of a normal method call:
+
+```json
+["is_proxy", check, obj]
+["jump_false", check, "record_path"]
+
+["access", name_slot, "method"]
+["array", args_arr, N, arg0, arg1]
+["null", null_slot]
+["frame", f, obj, 2]
+["setarg", f, 0, null_slot]
+["setarg", f, 1, name_slot]
+["setarg", f, 2, args_arr]
+["invoke", f, dest]
+["jump", "done"]
+
+["LABEL", "record_path"]
+["load_field", method, obj, "method"]
+["frame", f2, method, N]
+["setarg", f2, 0, obj]
+["setarg", f2, 1, arg0]
+["invoke", f2, dest]
+
+["LABEL", "done"]
+```
+
+## Labels and Control Flow
+
+Control flow uses named labels instead of numeric offsets:
+
+```json
+["LABEL", "loop_start"]
+["add_int", 1, 1, 2]
+["jump_false", 3, "loop_end"]
+["jump", "loop_start"]
+["LABEL", "loop_end"]
+```
+
+Labels are collected into a name-to-index map during loading, enabling O(1) jump resolution. The Mach serializer converts label names to numeric offsets in the binary bytecode.
+
+## Nop Convention
+
+The streamline optimizer replaces eliminated instructions with nop strings (e.g., `_nop_tc_1`, `_nop_bl_2`). Nop strings are skipped during interpretation and native code emission but preserved in the instruction array to maintain positional stability for jump targets.
+
+## Internal Structures
+
+### JSMCode (Mcode Interpreter)
+
+```c
+struct JSMCode {
+  uint16_t nr_args;        // argument count
+  uint16_t nr_slots;       // register count
+  cJSON **instrs;          // instruction array
+  uint32_t instr_count;    // number of instructions
+
+  struct {
+    const char *name;      // label name
+    uint32_t index;        // instruction index
+  } *labels;
+  uint32_t label_count;
+
+  struct JSMCode **functions; // nested functions
+  uint32_t func_count;
+
+  cJSON *json_root;        // keeps JSON alive
+  const char *name;        // function name
+  const char *filename;    // source file
+  uint16_t disruption_pc;  // disruption handler offset
+};
+```
+
+### JSCodeRegister (Mach VM Bytecode)
+
+```c
+struct JSCodeRegister {
+  uint16_t arity;           // argument count
+  uint16_t nr_slots;        // total register count
+  uint32_t cpool_count;     // constant pool size
+  JSValue *cpool;           // constant pool
+  uint32_t instr_count;     // instruction count
+  MachInstr32 *instructions; // 32-bit instruction array
+  uint32_t func_count;      // nested function count
+  JSCodeRegister **functions; // nested function table
+  JSValue name;             // function name
+  uint16_t disruption_pc;   // disruption handler offset
+};
+```
+
+The Mach serializer (`mach.c`) converts the JSON mcode into compact 32-bit instructions with a constant pool. See [Register VM](mach.md) for the binary encoding formats.

docs/spec/objects.md

@@ -0,0 +1,141 @@
+---
+title: "Object Types"
+description: "Heap object header format and types"
+---
+
+## Object Header
+
+Every heap-allocated object begins with a 64-bit header word (`objhdr_t`):
+
+```
+[capacity: 56 bits][flags: 5 bits][type: 3 bits]
+```
+
+### Type Field (bits 0-2)
+
+| Value | Type | Description |
+|-------|------|-------------|
+| 0 | `OBJ_ARRAY` | Dynamic array of JSValues |
+| 1 | `OBJ_BLOB` | Binary data (bits) |
+| 2 | `OBJ_TEXT` | Unicode text string |
+| 3 | `OBJ_RECORD` | Key-value object with prototype chain |
+| 4 | `OBJ_FUNCTION` | Function (C, register, or mcode) |
+| 5 | `OBJ_CODE` | Compiled code |
+| 6 | `OBJ_FRAME` | Stack frame for closures |
+| 7 | `OBJ_FORWARD` | Forwarding pointer (GC) |
+
+### Flags (bits 3-7)
+
+- **Bit 3 (S)** — Stone flag. If set, the object is immutable and excluded from GC.
+- **Bit 4 (P)** — Properties flag.
+- **Bit 5 (A)** — Array flag.
+- **Bit 7 (R)** — Reserved.
+
+### Capacity (bits 8-63)
+
+The interpretation of the 56-bit capacity field depends on the object type.
+
+## Array
+
+```c
+struct JSArray {
+  objhdr_t header;     // type=0, capacity=element slots
+  word_t len;          // current number of elements
+  JSValue values[];    // inline flexible array
+};
+```
+
+Capacity is the number of JSValue slots allocated. Length is the number currently in use. Arrays grow by reallocating with a larger capacity.
+
+## Blob
+
+```c
+struct JSBlob {
+  objhdr_t header;     // type=1, capacity=allocated bits
+  word_t length;       // length in bits
+  uint8_t bits[];      // bit-packed data
+};
+```
+
+Blobs are bit-addressable. The length field tracks the exact number of bits written. A blob starts as antestone (mutable) for writing, then becomes stone (immutable) for reading.
+
+## Text
+
+```c
+struct JSText {
+  objhdr_t header;     // type=2, capacity=character slots
+  word_t length;       // length in codepoints (or hash if stoned)
+  word_t packed[];     // two UTF-32 chars per 64-bit word
+};
+```
+
+Text is stored as UTF-32, with two 32-bit codepoints packed per 64-bit word. When a text object is stoned, the length field is repurposed to cache the hash value (computed via `fash64`), since stoned text is immutable and the hash never changes.
+
+## Record
+
+```c
+struct JSRecord {
+  objhdr_t header;     // type=3, capacity=hash table slots
+  JSRecord *proto;     // prototype chain pointer
+  word_t len;          // number of entries
+  slot slots[];        // key-value pairs (hash table)
+};
+```
+
+Records use a hash table with linear probing. Slot 0 is reserved for internal metadata (class ID and record ID). Empty slots use `JS_NULL` as the key; deleted slots use `JS_EXCEPTION` as a tombstone.
+
+The prototype chain is a linked list of JSRecord pointers, traversed during property lookup.
+
+## Function
+
+```c
+struct JSFunction {
+  objhdr_t header;     // type=4
+  JSValue name;        // function name
+  int16_t length;      // arity (-1 for variadic)
+  uint8_t kind;        // C, register, or mcode
+  union {
+    struct { ... } cfunc;      // C function pointer
+    struct { ... } regvm;      // register VM code
+    struct { ... } mcode;      // mcode IR
+  } u;
+};
+```
+
+The kind field selects which union variant is active. Functions can be implemented in C (native), register code (mach VM), or mcode (JSON interpreter).
+
+## Frame
+
+```c
+struct JSFrame {
+  objhdr_t header;     // type=6, capacity=slot count
+  JSValue function;    // owning function
+  JSValue caller;      // parent frame
+  uint32_t return_pc;  // return address
+  JSValue slots[];     // [this][args][captured][locals][temps]
+};
+```
+
+Frames capture the execution context for closures. The slots array contains the function's `this` binding, arguments, captured upvalues, local variables, and temporaries. Frames are linked via the caller field for upvalue resolution across closure depth.
+
+## Forwarding Pointer
+
+```
+[pointer: 61 bits][111]
+```
+
+During garbage collection, when an object is copied to the new heap, the old header is replaced with a forwarding pointer to the new location. This is type 7 (`OBJ_FORWARD`) and stores the new address in bits 3-63. See [Garbage Collection](#gc) for details.
+
+## Object Sizing
+
+All objects are aligned to 8 bytes. The total size in bytes for each type:
+
+| Type | Size |
+|------|------|
+| Array | `8 + 8 + capacity * 8` |
+| Blob | `8 + 8 + ceil(capacity / 8)` |
+| Text | `8 + 8 + ceil(capacity / 2) * 8` |
+| Record | `8 + 8 + 8 + (capacity + 1) * 16` |
+| Function | `sizeof(JSFunction)` (fixed) |
+| Code | `sizeof(JSFunctionBytecode)` (fixed) |
+| Frame | `8 + 8 + 8 + 4 + capacity * 8` |

docs/spec/pipeline.md

@@ -0,0 +1,127 @@
+---
+title: "Compilation Pipeline"
+description: "Overview of the compilation stages and optimizations"
+---
+
+## Overview
+
+The compilation pipeline transforms source code through several stages, each adding information or lowering the representation toward execution. All backends share the same path through mcode and streamline.
+
+```
+Source → Tokenize → Parse → Fold → Mcode → Streamline → Machine
+```
+
+The final **machine** stage has two targets:
+
+- **Mach VM** — a register-based bytecode interpreter that directly executes the mcode instruction set as compact 32-bit binary
+- **Native code** — lowers mcode to QBE or LLVM intermediate language, then compiles to machine code for the target CPU architecture
+
+## Stages
+
+### Tokenize (`tokenize.cm`)
+
+Splits source text into tokens. Handles string interpolation by re-tokenizing template literal contents. Produces a token array with position information (line, column).
+
+### Parse (`parse.cm`)
+
+Converts tokens into an AST. Also performs semantic analysis:
+
+- **Scope records**: For each scope (global, function), builds a record mapping variable names to their metadata: `make` (var/def/function/input), `function_nr`, `nr_uses`, `closure` flag, and `level`.
+- **Type tags**: When the right-hand side of a `def` is a syntactically obvious type, stamps `type_tag` on the scope record entry. Derivable types: `"integer"`, `"number"`, `"text"`, `"array"`, `"record"`, `"function"`, `"logical"`. For `def` variables, type tags are also inferred from usage patterns: push (`x[] = v`) implies array, property access (`x.foo = v`) implies record, integer key implies array, text key implies record.
+- **Type error detection**: For `def` variables with known type tags, provably wrong operations are reported as compile errors: property access on arrays, push on non-arrays, text keys on arrays, integer keys on records. Only `def` variables are checked because `var` can be reassigned.
+- **Intrinsic resolution**: Names used but not locally bound are recorded in `ast.intrinsics`. Name nodes referencing intrinsics get `intrinsic: true`.
+- **Access kind**: Subscript (`[`) nodes get `access_kind`: `"index"` for numeric subscripts, `"field"` for string subscripts, omitted otherwise.
+- **Tail position**: Return statements where the expression is a call get `tail: true`.
+
+### Fold (`fold.cm`)
+
+Operates on the AST. Performs constant folding and type analysis:
+
+- **Constant folding**: Evaluates arithmetic on known constants at compile time (e.g., `5 + 10` becomes `15`).
+- **Constant propagation**: Tracks `def` bindings whose values are known constants.
+- **Type propagation**: Extends `type_tag` through operations. When both operands of an arithmetic op have known types, the result type is known. Propagates type tags to reference sites.
+- **Intrinsic specialization**: When an intrinsic call's argument types are known, stamps a `hint` on the call node. For example, `length(x)` where x is a known array gets `hint: "array_length"`. Type checks like `is_array(known_array)` are folded to `true`.
+- **Purity analysis**: Expressions with no side effects are marked pure (literals, name references, arithmetic on pure operands, calls to pure intrinsics). The pure intrinsic set contains only `is_*` sensory functions — they are the only intrinsics guaranteed to never disrupt regardless of argument types. Other intrinsics like `text`, `number`, and `length` can disrupt on wrong argument types and are excluded.
+- **Dead code elimination**: Removes unreachable branches when conditions are known constants. Removes unused `var`/`def` declarations with pure initializers. Removes standalone calls to pure intrinsics where the result is discarded.
+
+### Mcode (`mcode.cm`)
+
+Lowers the AST to a JSON-based intermediate representation with explicit operations. Key design principle: **every type check is an explicit instruction** so downstream optimizers can see and eliminate them.
+
+- **Typed load/store**: Emits `load_index` (array by integer), `load_field` (record by string), or `load_dynamic` (unknown) based on type information from fold.
+- **Decomposed calls**: Function calls are split into `frame` (create call frame) + `setarg` (set arguments) + `invoke` (execute call).
+- **Intrinsic access**: Intrinsic functions are loaded via `access` with an intrinsic marker rather than global lookup.
+- **Intrinsic inlining**: Type-check intrinsics (`is_array`, `is_text`, `is_number`, `is_integer`, `is_logical`, `is_null`, `is_function`, `is_object`, `is_stone`), `length`, and `push` are emitted as direct opcodes instead of frame/setarg/invoke call sequences.
+- **Disruption handler labels**: When a function has a disruption handler, a label is emitted before the handler code. This allows the streamline optimizer's unreachable code elimination to safely nop dead code after `return` without accidentally eliminating the handler.
+- **Tail call marking**: When a return statement's expression is a call and the function has no disruption handler, the final `invoke` is renamed to `tail_invoke`. This marks the call site for future tail call optimization. Functions with disruption handlers cannot use TCO because the handler frame must remain on the stack.
+
+See [Mcode IR](mcode.md) for the instruction format and complete instruction reference.
+
+### Streamline (`streamline.cm`)
+
+Optimizes the Mcode IR through a series of independent passes. Operates per-function:
+
+1. **Backward type inference**: Infers parameter types from how they are used in typed operators (`add_int`, `store_index`, `load_field`, `push`, `pop`, etc.). Immutable `def` parameters keep their inferred type across label join points.
+2. **Type-check elimination**: When a slot's type is known, eliminates `is_<type>` + conditional jump pairs. Narrows `load_dynamic`/`store_dynamic` to typed variants.
+3. **Algebraic simplification**: Rewrites identity operations (add 0, multiply 1, divide 1) and folds same-slot comparisons.
+4. **Boolean simplification**: Fuses `not` + conditional jump into a single jump with inverted condition.
+5. **Move elimination**: Removes self-moves (`move a, a`).
+6. **Unreachable elimination**: Nops dead code after `return` until the next label.
+7. **Dead jump elimination**: Removes jumps to the immediately following label.
+
+See [Streamline Optimizer](streamline.md) for detailed pass descriptions.
+
+### Machine
+
+The streamlined mcode is lowered to a machine target for execution.
+
+#### Mach VM (default)
+
+The Mach VM is a register-based virtual machine that directly interprets the mcode instruction set as 32-bit binary bytecode. The Mach serializer (`mach.c`) converts streamlined mcode JSON into compact 32-bit instructions with a constant pool. Since the mach bytecode is a direct encoding of the mcode, the [Mcode IR](mcode.md) reference serves as the authoritative instruction set documentation.
+
+```
+pit script.ce
+```
+
+#### Native Code (QBE / LLVM)
+
+Lowers the streamlined mcode to QBE or LLVM intermediate language for compilation to native machine code. Each mcode function becomes a native function that calls into the ƿit runtime (`cell_rt_*` functions) for operations that require the runtime (allocation, intrinsic dispatch, etc.).
+
+String constants are interned in a data section. Integer constants are encoded inline.
+
+```
+pit --emit-qbe script.ce > output.ssa
+```
+
+## Files
+
+| File | Role |
+|------|------|
+| `tokenize.cm` | Lexer |
+| `parse.cm` | Parser + semantic analysis |
+| `fold.cm` | Constant folding + type analysis |
+| `mcode.cm` | AST → Mcode IR lowering |
+| `streamline.cm` | Mcode IR optimizer |
+| `qbe_emit.cm` | Mcode IR → QBE IL emitter |
+| `qbe.cm` | QBE IL operation templates |
+| `internal/bootstrap.cm` | Pipeline orchestrator |
+
+## Debug Tools
+
+| File | Purpose |
+|------|---------|
+| `dump_mcode.cm` | Print raw Mcode IR before streamlining |
+| `dump_stream.cm` | Print IR after streamlining with before/after stats |
+| `dump_types.cm` | Print streamlined IR with type annotations |
+
+## Test Files
+
+| File | Tests |
+|------|-------|
+| `parse_test.ce` | Type tags, access_kind, intrinsic resolution |
+| `fold_test.ce` | Type propagation, purity, intrinsic hints |
+| `mcode_test.ce` | Typed load/store, decomposed calls |
+| `streamline_test.ce` | Optimization counts, IR before/after |
+| `qbe_test.ce` | End-to-end QBE IL generation |
+| `test_intrinsics.cm` | Inlined intrinsic opcodes (is_array, length, push, etc.) |
+| `test_backward.cm` | Backward type propagation for parameters |

docs/spec/stone.md

@@ -0,0 +1,82 @@
+---
+title: "Stone Memory"
+description: "Immutable arena allocation"
+---
+
+## Overview
+
+Stone memory is a separate allocation arena for immutable values. Objects in stone memory are permanent — they are never moved, never freed, and never touched by the garbage collector.
+
+The `stone()` function in ƿit petrifies a value, deeply freezing it and all its descendants. Stoned objects have the S bit set in their object header.
+
+## The Stone Arena
+
+Stone memory uses bump allocation from a contiguous arena:
+
+```
+stone_base ──────── stone_free ──────── stone_end
+[allocated objects] [free space        ]
+```
+
+Allocation advances `stone_free` forward. When the arena is exhausted, overflow pages are allocated via the system allocator and linked together:
+
+```c
+struct StonePage {
+  struct StonePage *next;
+  size_t size;
+  uint8_t data[];
+};
+```
+
+## The S Bit
+
+Bit 3 of the object header is the stone flag. When set:
+
+- The object is **immutable** — writes disrupt
+- The object is **excluded from GC** — the collector skips it entirely
+- For text objects, the length field caches the **hash** instead of the character count (since the text cannot change, the hash is computed once and reused)
+
+## What Gets Stoned
+
+When `stone(value)` is called:
+
+1. If the value is already stone, return immediately
+2. Recursively walk all nested values (array elements, record fields, etc.)
+3. Copy each mutable object into the stone arena
+4. Set the S bit on each copied object
+5. Return the stoned value
+
+The operation is deep — an entire object graph becomes permanently immutable.
+
+## Text Interning
+
+The stone arena maintains a hash table for text interning. When a text value is stoned, it is looked up in the intern table. If an identical string already exists in stone memory, the existing one is reused. This deduplicates strings and makes equality comparison O(1) for stoned text.
+
+The hash is computed with `fash64` over the packed UTF-32 words.
+
+## Usage Patterns
+
+### Module Return Values
+
+Every module's return value is automatically stoned:
+
+```javascript
+// config.cm
+return {
+  debug: true,
+  timeout: 30
+}
+// The returned object is stone — shared safely between actors
+```
+
+### Message Passing
+
+Messages between actors are stoned before delivery, ensuring actors never share mutable state.
+
+### Constants
+
+Literal objects and arrays that can be determined at compile time may be allocated directly in stone memory.
+
+## Relationship to GC
+
+The Cheney copying collector only operates on the mutable heap. During collection, when the collector encounters a pointer to stone memory (S bit set), it skips it — stone objects are roots that never move. This means stone memory acts as a permanent root set with zero GC overhead.

docs/spec/streamline.md

@@ -0,0 +1,361 @@
+---
+title: "Streamline Optimizer"
+description: "Mcode IR optimization passes"
+---
+
+## Overview
+
+The streamline optimizer (`streamline.cm`) runs a series of independent passes over the Mcode IR to eliminate redundant operations. Each pass is a standalone function that can be enabled, disabled, or reordered. Passes communicate only through the instruction array they mutate in place, replacing eliminated instructions with nop strings (e.g., `_nop_tc_1`).
+
+The optimizer runs after `mcode.cm` generates the IR and before the result is lowered to the Mach VM or emitted as QBE IL.
+
+```
+Fold (AST) → Mcode (JSON IR) → Streamline → Mach VM / QBE
+```
+
+## Type Lattice
+
+The optimizer tracks a type for each slot in the register file:
+
+| Type | Meaning |
+|------|---------|
+| `unknown` | No type information |
+| `int` | Integer |
+| `float` | Floating-point |
+| `num` | Number (subsumes int and float) |
+| `text` | String |
+| `bool` | Logical (true/false) |
+| `null` | Null value |
+| `array` | Array |
+| `record` | Record (object) |
+| `function` | Function |
+| `blob` | Binary blob |
+
+Subsumption: `int` and `float` both satisfy a `num` check.
+
+## Passes
+
+### 1. infer_param_types (backward type inference)
+
+Scans typed operators and generic arithmetic to determine what types their operands must be. For example, `subtract dest, a, b` implies both `a` and `b` are numbers.
+
+When a parameter slot (1..nr_args) is consistently inferred as a single type, that type is recorded. Since parameters are immutable (`def`), the inferred type holds for the entire function and persists across label join points (loop headers, branch targets).
+
+Backward inference rules:
+
+| Operator class | Operand type inferred |
+|---|---|
+| `subtract`, `multiply`, `divide`, `modulo`, `pow`, `negate` | T_NUM |
+| `eq_int`, `ne_int`, `lt_int`, `gt_int`, `le_int`, `ge_int`, bitwise ops | T_INT |
+| `eq_float`, `ne_float`, `lt_float`, `gt_float`, `le_float`, `ge_float` | T_FLOAT |
+| `concat`, text comparisons | T_TEXT |
+| `eq_bool`, `ne_bool`, `not`, `and`, `or` | T_BOOL |
+| `store_index` (object operand) | T_ARRAY |
+| `store_index` (index operand) | T_INT |
+| `store_field` (object operand) | T_RECORD |
+| `push` (array operand) | T_ARRAY |
+| `load_index` (object operand) | T_ARRAY |
+| `load_index` (index operand) | T_INT |
+| `load_field` (object operand) | T_RECORD |
+| `pop` (array operand) | T_ARRAY |
+
+Note: `add` is excluded from backward inference because it is polymorphic — it handles both numeric addition and text concatenation. Only operators that are unambiguously numeric can infer T_NUM.
+
+When a slot appears with conflicting type inferences, the result is `unknown`. INT + FLOAT conflicts produce `num`.
+
+**Nop prefix:** none (analysis only, does not modify instructions)
+
+### 2. infer_slot_write_types (slot write-type invariance)
+
+Scans all instructions to determine which non-parameter slots have a consistent write type. If every instruction that writes to a given slot produces the same type, that type is globally invariant and can safely persist across label join points.
+
+This analysis is sound because:
+- `alloc_slot()` in mcode.cm is monotonically increasing — temp slots are never reused
+- All local variable declarations must be at function body level and initialized — slots are written before any backward jumps to loop headers
+- `move` is conservatively treated as T_UNKNOWN, avoiding unsound transitive assumptions
+
+Write type mapping:
+
+| Instruction class | Write type |
+|---|---|
+| `int` | T_INT |
+| `true`, `false` | T_BOOL |
+| `null` | T_NULL |
+| `access` | type of literal value |
+| `array` | T_ARRAY |
+| `record` | T_RECORD |
+| `function` | T_FUNCTION |
+| `length` | T_INT |
+| bitwise ops | T_INT |
+| `concat` | T_TEXT |
+| bool ops, comparisons, `in` | T_BOOL |
+| generic arithmetic (`add`, `subtract`, `negate`, etc.) | T_UNKNOWN |
+| `move`, `load_field`, `load_index`, `load_dynamic`, `pop`, `get` | T_UNKNOWN |
+| `invoke`, `tail_invoke` | T_UNKNOWN |
+
+The result is a map of slot→type for slots where all writes agree on a single known type. Parameter slots (1..nr_args) and slot 0 are excluded.
+
+Common patterns this enables:
+
+- **Length variables** (`var len = length(arr)`): written by `length` (T_INT) only → invariant T_INT
+- **Boolean flags** (`var found = false; ... found = true`): written by `false` and `true` → invariant T_BOOL
+- **Locally-created containers** (`var arr = []`): written by `array` only → invariant T_ARRAY
+
+Note: Loop counters (`var i = 0; i = i + 1`) are NOT invariant because `add` produces T_UNKNOWN. However, if `i` is a function parameter used in arithmetic, backward inference from `subtract`/`multiply`/etc. will infer T_NUM for it, which persists across labels.
+
+**Nop prefix:** none (analysis only, does not modify instructions)
+
+### 3. eliminate_type_checks (type-check + jump elimination)
+
+Forward pass that tracks the known type of each slot. When a type check (`is_int`, `is_text`, `is_num`, etc.) is followed by a conditional jump, and the slot's type is already known, the check and jump can be eliminated or converted to an unconditional jump.
+
+Three cases:
+
+- **Known match** (e.g., `is_int` on a slot known to be `int`): both the check and the conditional jump are eliminated (nop'd).
+- **Known mismatch** (e.g., `is_text` on a slot known to be `int`): the check is nop'd and the conditional jump is rewritten to an unconditional `jump`.
+- **Unknown**: the check remains, but on fallthrough, the slot's type is narrowed to the checked type (enabling downstream eliminations).
+
+This pass also reduces `load_dynamic`/`store_dynamic` to `load_field`/`store_field` or `load_index`/`store_index` when the key slot's type is known.
+
+At label join points, all type information is reset except for parameter types from backward inference and write-invariant types from slot write-type analysis.
+
+**Nop prefix:** `_nop_tc_`
+
+### 4. simplify_algebra (same-slot comparison folding)
+
+Tracks known constant values. Folds same-slot comparisons:
+
+| Pattern | Rewrite |
+|---------|---------|
+| `eq_* dest, x, x` | `true dest` |
+| `le_* dest, x, x` | `true dest` |
+| `ge_* dest, x, x` | `true dest` |
+| `is_identical dest, x, x` | `true dest` |
+| `ne_* dest, x, x` | `false dest` |
+| `lt_* dest, x, x` | `false dest` |
+| `gt_* dest, x, x` | `false dest` |
+
+**Nop prefix:** none (rewrites in place, does not create nops)
+
+### 5. simplify_booleans (not + jump fusion)
+
+Peephole pass that eliminates unnecessary `not` instructions:
+
+| Pattern | Rewrite |
+|---------|---------|
+| `not d, x; jump_false d, L` | nop; `jump_true x, L` |
+| `not d, x; jump_true d, L` | nop; `jump_false x, L` |
+| `not d1, x; not d2, d1` | nop; `move d2, x` |
+
+This is particularly effective on `if (!cond)` patterns, which the compiler generates as `not; jump_false`. After this pass, they become a single `jump_true`.
+
+**Nop prefix:** `_nop_bl_`
+
+### 6. eliminate_moves (self-move elimination)
+
+Removes `move a, a` instructions where the source and destination are the same slot. These can arise from earlier passes rewriting binary operations into moves.
+
+**Nop prefix:** `_nop_mv_`
+
+### 7. eliminate_unreachable (dead code after return)
+
+Nops instructions after `return` until the next real label. Only `return` is treated as a terminal instruction; `disrupt` is not, because the disruption handler code immediately follows `disrupt` and must remain reachable.
+
+The mcode compiler emits a label at disruption handler entry points (see `emit_label(gen_label("disruption"))` in mcode.cm), which provides the label boundary that stops this pass from eliminating handler code.
+
+**Nop prefix:** `_nop_ur_`
+
+### 8. eliminate_dead_jumps (jump-to-next-label elimination)
+
+Removes `jump L` instructions where `L` is the immediately following label (skipping over any intervening nop strings). These are common after other passes eliminate conditional branches, leaving behind jumps that fall through naturally.
+
+**Nop prefix:** `_nop_dj_`
+
+## Pass Composition
+
+All passes run in sequence in `optimize_function`:
+
+```
+infer_param_types        → returns param_types map
+infer_slot_write_types   → returns write_types map
+eliminate_type_checks    → uses param_types + write_types
+simplify_algebra
+simplify_booleans
+eliminate_moves
+eliminate_unreachable
+eliminate_dead_jumps
+```
+
+Each pass is independent and can be commented out for testing or benchmarking.
+
+## Intrinsic Inlining
+
+Before streamlining, `mcode.cm` recognizes calls to built-in intrinsic functions and emits direct opcodes instead of the generic frame/setarg/invoke call sequence. This reduces a 6-instruction call pattern to a single instruction:
+
+| Call | Emitted opcode |
+|------|---------------|
+| `is_array(x)` | `is_array dest, src` |
+| `is_function(x)` | `is_func dest, src` |
+| `is_object(x)` | `is_record dest, src` |
+| `is_stone(x)` | `is_stone dest, src` |
+| `is_integer(x)` | `is_int dest, src` |
+| `is_text(x)` | `is_text dest, src` |
+| `is_number(x)` | `is_num dest, src` |
+| `is_logical(x)` | `is_bool dest, src` |
+| `is_null(x)` | `is_null dest, src` |
+| `length(x)` | `length dest, src` |
+| `push(arr, val)` | `push arr, val` |
+
+These inlined opcodes have corresponding Mach VM implementations in `mach.c`.
+
+## Unified Arithmetic
+
+Arithmetic operations use generic opcodes: `add`, `subtract`, `multiply`, `divide`, `modulo`, `pow`, `negate`. There are no type-dispatched variants (e.g., no `add_int`/`add_float`).
+
+The Mach VM dispatches at runtime with an int-first fast path via `reg_vm_binop()`: it checks `JS_VALUE_IS_BOTH_INT` first for fast integer arithmetic, then falls back to float conversion, text concatenation (for `add` only), or type error.
+
+Bitwise operations (`shl`, `shr`, `ushr`, `bitand`, `bitor`, `bitxor`, `bitnot`) remain integer-only and disrupt if operands are not integers.
+
+The QBE/native backend maps generic arithmetic to helper calls (`qbe.add`, `qbe.sub`, etc.). The vision for the native path is that with sufficient type inference, the backend can unbox proven-numeric values to raw registers, operate directly, and only rebox at boundaries (returns, calls, stores).
+
+## Debugging Tools
+
+Three dump tools inspect the IR at different stages:
+
+- **`dump_mcode.cm`** — prints the raw Mcode IR after `mcode.cm`, before streamlining
+- **`dump_stream.cm`** — prints the IR after streamlining, with before/after instruction counts
+- **`dump_types.cm`** — prints the streamlined IR with type annotations on each instruction
+
+Usage:
+```
+./cell --core . dump_mcode.cm <file.ce|file.cm>
+./cell --core . dump_stream.cm <file.ce|file.cm>
+./cell --core . dump_types.cm <file.ce|file.cm>
+```
+
+## Tail Call Marking
+
+When a function's return expression is a call (`stmt.tail == true` from the parser) and the function has no disruption handler, mcode.cm renames the final `invoke` instruction to `tail_invoke`. This is semantically identical to `invoke` in the current Mach VM, but marks the call site for future tail call optimization.
+
+The disruption handler restriction exists because TCO would discard the current frame, but the handler must remain on the stack to catch disruptions from the callee.
+
+`tail_invoke` is handled by the same passes as `invoke` in streamline (type tracking, algebraic simplification) and executes identically in the VM.
+
+## Type Propagation Architecture
+
+Type information flows through three compilation stages, each building on the previous:
+
+### Stage 1: Parse-time type tags (parse.cm)
+
+The parser assigns `type_tag` strings to scope variable entries when the type is syntactically obvious:
+
+- **From initializers**: `def a = []` → `type_tag: "array"`, `def n = 42` → `type_tag: "integer"`, `def r = {}` → `type_tag: "record"`
+- **From usage patterns** (def only): `def x = null; x[] = v` infers `type_tag: "array"` from the push. `def x = null; x.foo = v` infers `type_tag: "record"` from property access.
+- **Type error detection** (def only): When a `def` variable has a known type_tag, provably wrong operations are compile errors:
+  - Property access (`.`) on array
+  - Push (`[]`) on non-array
+  - Text key on array
+  - Integer key on record
+
+Only `def` (constant) variables participate in type inference and error detection. `var` variables can be reassigned, making their initializer type unreliable.
+
+### Stage 2: Fold-time type propagation (fold.cm)
+
+The fold pass extends type information through the AST:
+
+- **Intrinsic folding**: `is_array(known_array)` folds to `true`. `length(known_array)` gets `hint: "array_length"`.
+- **Purity analysis**: Expressions involving only `is_*` intrinsic calls with pure arguments are considered pure. This enables dead code elimination for unused `var`/`def` bindings with pure initializers, and elimination of standalone pure call statements.
+- **Dead code**: Unused pure `var`/`def` declarations are removed. Standalone calls to pure intrinsics (where the result is discarded) are removed. Unreachable branches with constant conditions are removed.
+
+The `pure_intrinsics` set currently contains only `is_*` sensory functions (`is_array`, `is_text`, `is_number`, `is_integer`, `is_function`, `is_logical`, `is_null`, `is_object`, `is_stone`). Other intrinsics like `text`, `number`, and `length` can disrupt on wrong argument types, so they are excluded — removing a call that would disrupt changes observable behavior.
+
+### Stage 3: Streamline-time type tracking (streamline.cm)
+
+The streamline optimizer uses a numeric type lattice (`T_INT`, `T_FLOAT`, `T_TEXT`, etc.) for fine-grained per-instruction tracking:
+
+- **Backward inference** (pass 1): Scans typed operators to infer parameter types. Since parameters are `def` (immutable), inferred types persist across label boundaries.
+- **Write-type invariance** (pass 2): Scans all instructions to find local slots where every write produces the same type. These invariant types persist across label boundaries alongside parameter types.
+- **Forward tracking** (pass 3): `track_types` follows instruction execution order, tracking the type of each slot. Known-type operations set their destination type (e.g., `concat` → T_TEXT, `length` → T_INT). Generic arithmetic produces T_UNKNOWN. Type checks on unknown slots narrow the type on fallthrough.
+- **Type check elimination** (pass 3): When a slot's type is already known, `is_<type>` + conditional jump pairs are eliminated or converted to unconditional jumps.
+- **Dynamic access narrowing** (pass 3): `load_dynamic`/`store_dynamic` are narrowed to `load_field`/`store_field` or `load_index`/`store_index` when the key type is known.
+
+Type information resets at label join points (since control flow merges could bring different types), except for parameter types from backward inference and write-invariant types from slot write-type analysis.
+
+## Future Work
+
+### Copy Propagation
+
+A basic-block-local copy propagation pass would replace uses of a copied variable with its source, enabling further move elimination. An implementation was attempted but encountered an unsolved bug where 2-position instruction operand replacement produces incorrect code during self-hosting (the replacement logic for 3-position instructions works correctly). The root cause is not yet understood. See the project memory files for detailed notes.
+
+### Expanded Purity Analysis
+
+The current purity set is conservative (only `is_*`). It could be expanded by:
+
+- **Argument-type-aware purity**: If all arguments to an intrinsic are known to be the correct types (via type_tag or slot_types), the call cannot disrupt and is safe to eliminate. For example, `length(known_array)` is pure but `length(unknown)` is not.
+- **User function purity**: Analyze user-defined function bodies during pre_scan. A function is pure if its body contains only pure expressions and calls to known-pure functions. This requires fixpoint iteration for mutual recursion.
+- **Callback-aware purity**: Intrinsics like `filter`, `find`, `reduce`, `some`, `every` are pure if their callback argument is pure.
+
+### Forward Type Narrowing from Typed Operations
+
+With unified arithmetic (generic `add`/`subtract`/`multiply`/`divide`/`modulo`/`negate` instead of typed variants), this approach is no longer applicable. Typed comparisons (`eq_int`, `lt_float`, etc.) still exist and their operands have known types, but these are already handled by backward inference.
+
+### Guard Hoisting for Parameters
+
+When a type check on a parameter passes (falls through), the parameter's type could be promoted to `param_types` so it persists across label boundaries. This would allow the first type check on a parameter to prove its type for the entire function. However, this is unsound for polymorphic parameters — if a function is called with different argument types, the first check would wrongly eliminate checks for subsequent types.
+
+A safe version would require proving that a parameter is monomorphic (called with only one type across all call sites), which requires interprocedural analysis.
+
+**Note:** For local variables (non-parameters), the write-type invariance analysis (pass 2) achieves a similar effect safely — if every write to a slot produces the same type, that type persists across labels without needing to hoist any guard.
+
+### Tail Call Optimization
+
+`tail_invoke` instructions are currently marked but execute identically to `invoke`. Actual TCO would reuse the current call frame instead of creating a new one. This requires:
+
+- Ensuring argument count matches (or the frame can be resized)
+- No live locals needed after the call (guaranteed by tail position)
+- No disruption handler on the current function (already enforced by the marking)
+- VM support in mach.c to rewrite the frame in place
+
+### Interprocedural Type Inference
+
+Currently all type inference is intraprocedural (within a single function). Cross-function analysis could:
+
+- Infer return types from function bodies
+- Propagate argument types from call sites to callees
+- Specialize functions for known argument types (cloning)
+
+### Strength Reduction
+
+Common patterns that could be lowered to cheaper operations when operand types are known:
+
+- `multiply x, 2` with proven-int operands → shift left
+- `divide x, 2` with proven-int → arithmetic shift right
+- `modulo x, power_of_2` with proven-int → bitwise and
+
+### Numeric Unboxing (QBE/native path)
+
+With unified arithmetic and backward type inference, the native backend can identify regions where numeric values remain in registers without boxing/unboxing:
+
+1. **Guard once**: When backward inference proves a parameter is T_NUM, emit a single type guard at function entry.
+2. **Unbox**: Convert the tagged JSValue to a raw double register.
+3. **Operate**: Use native FP/int instructions directly (no function calls, no tag checks).
+4. **Rebox**: Convert back to tagged JSValue only at rebox points (function returns, calls, stores to arrays/records).
+
+This requires inserting `unbox`/`rebox` IR annotations (no-ops in the Mach VM, meaningful only to QBE).
+
+### Loop-Invariant Code Motion
+
+Type checks that are invariant across loop iterations (checking a variable that doesn't change in the loop body) could be hoisted above the loop. This would require identifying loop boundaries and proving invariance.
+
+### Algebraic Identity Optimization
+
+With unified arithmetic, algebraic identities (x+0→x, x*1→x, x*0→0, x/1→x) require knowing operand values at compile time. Since generic `add`/`multiply` operate on any numeric type, the constant-tracking logic in `simplify_algebra` could be extended to handle these for known-constant slots.
+
+## Nop Convention
+
+Eliminated instructions are replaced with strings matching `_nop_<prefix>_<counter>`. The prefix identifies which pass created the nop. Nop strings are:
+
+- Skipped during interpretation (the VM ignores them)
+- Skipped during QBE emission
+- Not counted in instruction statistics
+- Preserved in the instruction array to maintain positional stability for jump targets

docs/spec/values.md

@@ -0,0 +1,96 @@
+---
+title: "Value Representation"
+description: "JSValue tagging and encoding"
+---
+
+## Overview
+
+Every value in ƿit is a 64-bit word called a JSValue. The runtime uses LSB (least significant bit) tagging to pack type information directly into the value, avoiding heap allocation for common types.
+
+## Tag Encoding
+
+The lowest bits of a JSValue determine its type:
+
+| LSB Pattern | Type | Payload |
+|-------------|------|---------|
+| `xxxxxxx0` | Integer | 31-bit signed integer in upper bits |
+| `xxxxx001` | Pointer | 61-bit aligned heap pointer |
+| `xxxxx101` | Short float | 8-bit exponent + 52-bit mantissa |
+| `xxxxx011` | Special | 5-bit tag selects subtype |
+
+### Integers
+
+If the least significant bit is 0, the value is an immediate 31-bit signed integer. The integer is stored in the upper bits, extracted via `v >> 1`.
+
+```
+[integer: 31 bits][0]
+```
+
+Range: -1073741824 to 1073741823. Numbers outside this range are stored as short floats or heap-allocated.
+
+### Pointers
+
+If the lowest 3 bits are `001`, the value is a pointer to a heap object. The pointer is 8-byte aligned, so the low 3 bits are available for the tag. The actual address is extracted by clearing the low 3 bits.
+
+```
+[pointer: 61 bits][001]
+```
+
+All heap objects (arrays, records, blobs, text, functions, etc.) are referenced through pointer-tagged JSValues.
+
+### Short Floats
+
+If the lowest 3 bits are `101`, the value encodes a floating-point number directly. The format uses an 8-bit exponent (bias 127) and 52-bit mantissa, similar to IEEE 754 but with reduced range.
+
+```
+[sign: 1][exponent: 8][mantissa: 52][101]
+```
+
+Range: approximately ±3.4 * 10^38. Numbers outside this range fall back to null. Zero is always positive zero.
+
+### Specials
+
+If the lowest 2 bits are `11`, the next 3 bits select a special type:
+
+| 5-bit Tag | Value |
+|-----------|-------|
+| `00011` | Boolean (true/false in upper bits) |
+| `00111` | Null |
+| `01111` | Exception marker |
+| `10111` | Uninitialized |
+| `11011` | Immediate string |
+| `11111` | Catch offset |
+
+## Immediate Strings
+
+Short ASCII strings (up to 7 characters) are packed directly into the JSValue without heap allocation:
+
+```
+[char6][char5][char4][char3][char2][char1][char0][length: 3][11011]
+```
+
+Each character occupies 8 bits. The length (0-7) is stored in bits 5-7. Only ASCII characters (0-127) qualify — any non-ASCII character forces heap allocation.
+
+```javascript
+var s = "hello"   // 5 chars, fits in immediate string
+var t = ""         // immediate (length 0)
+var u = "longtext" // 8 chars, heap-allocated
+```
+
+## Null
+
+Null is encoded as a special-tagged value with tag `00111`. There is no `undefined` in ƿit — only null.
+
+```javascript
+var x = null       // special tag null
+var y = 1 / 0      // also null (division by zero)
+var z = {}.missing // null (missing field)
+```
+
+## Boolean
+
+True and false are encoded as specials with tag `00011`, distinguished by a bit in the upper payload.
+
+## Summary
+
+The tagging scheme ensures that the most common values — small integers, booleans, null, and short strings — require zero heap allocation. This significantly reduces GC pressure and improves cache locality.

docs/testing.md

@@ -0,0 +1,170 @@
+---
+title: "Testing"
+description: "Writing and running tests in ƿit"
+weight: 45
+type: "docs"
+---
+
+ƿit has built-in support for writing and running tests. Tests live in the `tests/` directory of a package and are `.cm` modules that return a record of test functions.
+
+## Writing Tests
+
+A test file returns a record where each key starting with `test_` is a test function. A test passes if it returns `null` (or nothing). It fails if it returns a text string describing the failure.
+
+```javascript
+// tests/math.cm
+return {
+    test_addition: function() {
+        if (1 + 2 != 3) return "expected 3"
+    },
+
+    test_division: function() {
+        if (10 / 3 != 3.333333333333333333) return "unexpected result"
+    }
+}
+```
+
+Test functions take no arguments. Use early returns with a failure message to report errors:
+
+```javascript
+test_array_push: function() {
+    var a = [1, 2]
+    a[] = 3
+    if (length(a) != 3) return "expected length 3, got " + text(length(a))
+    if (a[2] != 3) return "expected a[2] to be 3"
+}
+```
+
+## Running Tests
+
+```bash
+pit test                          # run all tests in current package
+pit test suite                    # run a specific test file (tests/suite.cm)
+pit test tests/math               # same, with explicit path
+pit test all                      # run all tests in current package
+pit test package <name>           # run all tests in a named package
+pit test package <name> <test>    # run a specific test in a named package
+pit test package all              # run tests from all installed packages
+```
+
+### Flags
+
+```bash
+pit test suite -g          # run GC after each test (useful for detecting leaks)
+pit test suite --verify    # enable IR verification during compilation
+pit test suite --diff      # run each test optimized and unoptimized, compare results
+```
+
+`--verify` and `--diff` can be combined:
+
+```bash
+pit test suite --verify --diff
+```
+
+## IR Verification
+
+The `--verify` flag enables structural validation of the compiler's intermediate representation after each optimizer pass. This catches bugs like invalid slot references, broken jump targets, and malformed instructions.
+
+When verification fails, errors are printed with the pass name that introduced them:
+
+```
+[verify_ir] slot_bounds: slot 12 out of range 0..9 in instruction add_int
+[verify_ir] 1 errors after dead_code_elimination
+```
+
+IR verification adds overhead and is intended for development, not production use.
+
+## Differential Testing
+
+Differential testing runs each test through two paths — with the optimizer enabled and with it disabled — and compares results. Any mismatch between the two indicates an optimizer bug.
+
+### Inline Mode
+
+The `--diff` flag on `pit test` runs each test module through both paths during a normal test run:
+
+```bash
+pit test suite --diff
+```
+
+Output includes a mismatch count at the end:
+
+```
+Tests: 493 passed, 0 failed, 493 total
+Diff mismatches: 0
+```
+
+### Standalone Mode
+
+`pit diff` is a dedicated differential testing tool with detailed mismatch reporting:
+
+```bash
+pit diff                   # diff all test files in current package
+pit diff suite             # diff a specific test file
+pit diff tests/math        # same, with explicit path
+```
+
+For each test function, it reports whether the optimized and unoptimized results match:
+
+```
+  tests/suite.cm: 493 passed, 0 failed
+----------------------------------------
+Diff: 493 passed, 0 failed, 493 total
+```
+
+When a mismatch is found:
+
+```
+  tests/suite.cm: 492 passed, 1 failed
+    MISMATCH: test_foo: result mismatch opt=42 noopt=43
+```
+
+## Fuzz Testing
+
+The fuzzer generates random self-checking programs, compiles them, and runs them through both optimized and unoptimized paths. Each generated program contains test functions that validate their own expected results, so failures catch both correctness bugs and optimizer mismatches.
+
+```bash
+pit fuzz                   # 100 iterations, random seed
+pit fuzz 500               # 500 iterations, random seed
+pit fuzz --seed 42         # 100 iterations, deterministic seed
+pit fuzz 1000 --seed 42   # 1000 iterations, deterministic seed
+```
+
+The fuzzer generates programs that exercise:
+
+- Integer and float arithmetic with known expected results
+- Control flow (if/else, while loops)
+- Closures and captured variable mutation
+- Records and property access
+- Arrays and iteration
+- Higher-order functions
+- Disruption handling
+- Text concatenation
+
+On failure, the generated source is saved to `tests/fuzz_failures/` for reproduction:
+
+```
+Fuzzing: 1000 iterations, starting seed=42
+  FAIL seed=57: diff fuzz_3: opt=10 noopt=11
+    saved to tests/fuzz_failures/seed_57.cm
+----------------------------------------
+Fuzz: 999 passed, 1 failed, 1000 total
+Failures saved to tests/fuzz_failures/
+```
+
+Saved failure files are valid `.cm` modules that can be run directly or added to the test suite.
+
+## Test File Organization
+
+Tests live in the `tests/` directory of a package:
+
+```
+mypackage/
+├── pit.toml
+├── math.cm
+└── tests/
+    ├── suite.cm        # main test suite
+    ├── math.cm         # math-specific tests
+    └── disrupt.cm      # disruption tests
+```
+
+All `.cm` files under `tests/` are discovered automatically by `pit test`.

docs/wota.md

@@ -0,0 +1,119 @@
+---
+title: "Wota Format"
+description: "Word Object Transfer Arrangement"
+weight: 86
+type: "docs"
+---
+
+Wota is a binary message format for local inter-process communication. It is similar to Nota but works at word granularity (64-bit words) rather than byte granularity. Wota arrangements are less compact than Nota but faster to arrange and consume.
+
+Wota stands for Word Object Transfer Arrangement.
+
+## Type Summary
+
+| Byte | Type |
+|------|------|
+| `00` | Integer |
+| `01` | Floating Point |
+| `02` | Array |
+| `03` | Record |
+| `04` | Blob |
+| `05` | Text |
+| `07` | Symbol |
+
+## Preambles
+
+Every Wota value starts with a preamble word. The least significant byte contains the type. The remaining 56 bits contain type-specific data.
+
+## Blob
+
+A blob is a string of bits. The remaining field contains the number of bits. The number of words that follow: `floor((number_of_bits + 63) / 64)`. The first bit of the blob goes into the most significant bit of the first word. The final word is padded with 0.
+
+Example: A blob containing 25 bits `111100001110001100100001`:
+
+```
+0000000000001904    # preamble: 25 bits, type blob
+F0E3208000000000    # data (padded to 64 bits)
+```
+
+## Text
+
+The text is a string of UTF-32 characters packed 2 per word. The remaining field contains the number of characters. The number of words that follow: `floor((number_of_characters + 1) / 2)`. The final word is padded with 0.
+
+Example: `"cat"`:
+
+```
+0000000000000305    # preamble: 3 characters, type text
+0000006300000061    # 'c' and 'a'
+0000007400000000    # 't' and padding
+```
+
+## Array
+
+An array is an ordered sequence of values. The remaining field contains the number of elements. Following the preamble are the elements, each beginning with its own preamble. Nesting is encouraged. Cyclic structures are not allowed.
+
+Example: `["duck", "dragon"]`:
+
+```
+0000000000000202    # preamble: 2 elements, type array
+0000000000000405    # text "duck": 4 chars
+0000006400000074    # 'd' 't' (reversed pair order)
+000000630000006B    # 'c' 'k'
+0000000000000605    # text "dragon": 6 chars
+0000006400000072    # 'd' 'r'
+0000006100000067    # 'a' 'g'
+0000006F0000006E    # 'o' 'n'
+```
+
+## Record
+
+A record is a set of key/value pairs. Keys must be text. The remaining field contains the number of pairs.
+
+Example: `{"ox": ["O", "X"]}`:
+
+```
+0000000000000103    # preamble: 1 pair, type record
+0000000000000205    # key "ox": 2 chars
+0000006F00000078    # 'o' 'x'
+0000000000000202    # value: array of 2
+0000000000000105    # "O": 1 char
+0000004F00000000    # 'O'
+0000000000000105    # "X": 1 char
+0000005800000000    # 'X'
+```
+
+## Number
+
+Numbers are represented as DEC64. To arrange an integer, shift the integer up 8 bits. The number is incorporated directly into the preamble.
+
+Example: `7`:
+
+```
+0000000000000700    # integer 7 as DEC64
+```
+
+To arrange a floating point number, place the number in the word following the floating point preamble.
+
+Example: `4.25`:
+
+```
+0000000000000001    # preamble: type floating point
+000000000001A9FE    # DEC64 encoding of 4.25
+```
+
+Care must be taken when decoding that the least significant byte of the number is not `80` (the null exponent).
+
+## Symbol
+
+The remaining field contains the symbol.
+
+Example: `[null, false, true, private, system]`:
+
+```
+0000000000000502    # array of 5
+0000000000000007    # null
+0000000000000207    # false
+0000000000000307    # true
+0000000000000807    # private
+0000000000000907    # system
+```

dump_ast.cm

@@ -0,0 +1,16 @@
+// dump_ast.cm — pretty-print the folded AST as JSON
+//
+// Usage: ./cell --core . dump_ast.cm <file.ce|file.cm>
+
+var fd = use("fd")
+var json = use("json")
+var tokenize = use("tokenize")
+var parse = use("parse")
+var fold = use("fold")
+
+var filename = args[0]
+var src = text(fd.slurp(filename))
+var tok = tokenize(src, filename)
+var ast = parse(tok.tokens, src, filename, tokenize)
+var folded = fold(ast)
+print(json.encode(folded))

dump_mcode.cm

@@ -0,0 +1,117 @@
+// dump_mcode.cm — pretty-print mcode IR (before streamlining)
+//
+// Usage: ./cell --core . dump_mcode.cm <file.ce|file.cm>
+
+var fd = use("fd")
+var json = use("json")
+var tokenize = use("tokenize")
+var parse = use("parse")
+var fold = use("fold")
+var mcode = use("mcode")
+
+if (length(args) < 1) {
+  print("usage: cell --core . dump_mcode.cm <file>")
+  return
+}
+
+var filename = args[0]
+var src = text(fd.slurp(filename))
+var tok = tokenize(src, filename)
+var ast = parse(tok.tokens, src, filename, tokenize)
+var folded = fold(ast)
+var compiled = mcode(folded)
+
+var pad_right = function(s, w) {
+  var r = s
+  while (length(r) < w) {
+    r = r + " "
+  }
+  return r
+}
+
+var fmt_val = function(v) {
+  if (is_null(v)) {
+    return "null"
+  }
+  if (is_number(v)) {
+    return text(v)
+  }
+  if (is_text(v)) {
+    return `"${v}"`
+  }
+  if (is_object(v)) {
+    return json.encode(v)
+  }
+  if (is_logical(v)) {
+    return v ? "true" : "false"
+  }
+  return text(v)
+}
+
+var dump_function = function(func, name) {
+  var nr_args = func.nr_args != null ? func.nr_args : 0
+  var nr_slots = func.nr_slots != null ? func.nr_slots : 0
+  var nr_close = func.nr_close_slots != null ? func.nr_close_slots : 0
+  var instrs = func.instructions
+  var i = 0
+  var pc = 0
+  var instr = null
+  var op = null
+  var n = 0
+  var parts = null
+  var j = 0
+  var operands = null
+  var pc_str = null
+  var op_str = null
+  print(`\n=== ${name} (args=${text(nr_args)}, slots=${text(nr_slots)}, closures=${text(nr_close)}) ===`)
+  if (instrs == null || length(instrs) == 0) {
+    print("  (empty)")
+    return null
+  }
+  while (i < length(instrs)) {
+    instr = instrs[i]
+    if (is_text(instr)) {
+      if (!starts_with(instr, "_nop_")) {
+        print(`${instr}:`)
+      }
+    } else if (is_array(instr)) {
+      op = instr[0]
+      n = length(instr)
+      parts = []
+      j = 1
+      while (j < n - 2) {
+        push(parts, fmt_val(instr[j]))
+        j = j + 1
+      }
+      operands = text(parts, ", ")
+      pc_str = pad_right(text(pc), 5)
+      op_str = pad_right(op, 14)
+      print(`  ${pc_str} ${op_str} ${operands}`)
+      pc = pc + 1
+    }
+    i = i + 1
+  }
+  return null
+}
+
+var main_name = null
+var fi = 0
+var func = null
+var fname = null
+
+// Dump main
+if (compiled.main != null) {
+  main_name = compiled.name != null ? compiled.name : "<main>"
+  dump_function(compiled.main, main_name)
+}
+
+// Dump sub-functions
+if (compiled.functions != null) {
+  fi = 0
+  while (fi < length(compiled.functions)) {
+    func = compiled.functions[fi]
+    fname = func.name != null ? func.name : `<func_${text(fi)}>`
+    dump_function(func, `[${text(fi)}] ${fname}`)
+    fi = fi + 1
+  }
+}

dump_stream.cm

@@ -0,0 +1,166 @@
+// dump_stream.cm — show mcode IR before and after streamlining
+//
+// Usage: ./cell --core . dump_stream.cm <file.ce|file.cm>
+
+var fd = use("fd")
+var json = use("json")
+var tokenize = use("tokenize")
+var parse = use("parse")
+var fold = use("fold")
+var mcode = use("mcode")
+var streamline = use("streamline")
+
+if (length(args) < 1) {
+  print("usage: cell --core . dump_stream.cm <file>")
+  return
+}
+
+var filename = args[0]
+var src = text(fd.slurp(filename))
+var tok = tokenize(src, filename)
+var ast = parse(tok.tokens, src, filename, tokenize)
+var folded = fold(ast)
+var compiled = mcode(folded)
+
+// Deep copy IR for before snapshot
+var before = json.decode(json.encode(compiled))
+
+var optimized = streamline(compiled)
+
+var pad_right = function(s, w) {
+  var r = s
+  while (length(r) < w) {
+    r = r + " "
+  }
+  return r
+}
+
+var fmt_val = function(v) {
+  if (is_null(v)) {
+    return "null"
+  }
+  if (is_number(v)) {
+    return text(v)
+  }
+  if (is_text(v)) {
+    return `"${v}"`
+  }
+  if (is_object(v)) {
+    return json.encode(v)
+  }
+  if (is_logical(v)) {
+    return v ? "true" : "false"
+  }
+  return text(v)
+}
+
+var count_stats = function(func) {
+  var instrs = func.instructions
+  var total = 0
+  var nops = 0
+  var calls = 0
+  var i = 0
+  var instr = null
+  if (instrs == null) {
+    return {total: 0, nops: 0, real: 0, calls: 0}
+  }
+  while (i < length(instrs)) {
+    instr = instrs[i]
+    if (is_text(instr)) {
+      if (starts_with(instr, "_nop_")) {
+        nops = nops + 1
+      }
+    } else if (is_array(instr)) {
+      total = total + 1
+      if (instr[0] == "invoke") {
+        calls = calls + 1
+      }
+    }
+    i = i + 1
+  }
+  return {total: total, nops: nops, real: total - nops, calls: calls}
+}
+
+var dump_function = function(func, show_nops) {
+  var instrs = func.instructions
+  var i = 0
+  var pc = 0
+  var instr = null
+  var op = null
+  var n = 0
+  var parts = null
+  var j = 0
+  var operands = null
+  var pc_str = null
+  var op_str = null
+  if (instrs == null || length(instrs) == 0) {
+    return null
+  }
+  while (i < length(instrs)) {
+    instr = instrs[i]
+    if (is_text(instr)) {
+      if (starts_with(instr, "_nop_")) {
+        if (show_nops) {
+          print(`  ${pad_right(text(pc), 5)} --- nop ---`)
+          pc = pc + 1
+        }
+      } else {
+        print(`${instr}:`)
+      }
+    } else if (is_array(instr)) {
+      op = instr[0]
+      n = length(instr)
+      parts = []
+      j = 1
+      while (j < n - 2) {
+        push(parts, fmt_val(instr[j]))
+        j = j + 1
+      }
+      operands = text(parts, ", ")
+      pc_str = pad_right(text(pc), 5)
+      op_str = pad_right(op, 14)
+      print(`  ${pc_str} ${op_str} ${operands}`)
+      pc = pc + 1
+    }
+    i = i + 1
+  }
+  return null
+}
+
+var dump_pair = function(before_func, after_func, name) {
+  var nr_args = after_func.nr_args != null ? after_func.nr_args : 0
+  var nr_slots = after_func.nr_slots != null ? after_func.nr_slots : 0
+  var b_stats = count_stats(before_func)
+  var a_stats = count_stats(after_func)
+  var eliminated = a_stats.nops
+  print(`\n=== ${name} (args=${text(nr_args)}, slots=${text(nr_slots)}) ===`)
+  print(`  before: ${text(b_stats.total)} instructions, ${text(b_stats.calls)} invokes`)
+  print(`  after:  ${text(a_stats.real)} instructions (${text(eliminated)} eliminated), ${text(a_stats.calls)} invokes`)
+  print("\n  -- streamlined --")
+  dump_function(after_func, false)
+  return null
+}
+
+var main_name = null
+var fi = 0
+var func = null
+var bfunc = null
+var fname = null
+
+// Dump main
+if (optimized.main != null && before.main != null) {
+  main_name = optimized.name != null ? optimized.name : "<main>"
+  dump_pair(before.main, optimized.main, main_name)
+}
+
+// Dump sub-functions
+if (optimized.functions != null && before.functions != null) {
+  fi = 0
+  while (fi < length(optimized.functions)) {
+    func = optimized.functions[fi]
+    bfunc = before.functions[fi]
+    fname = func.name != null ? func.name : `<func_${text(fi)}>`
+    dump_pair(bfunc, func, `[${text(fi)}] ${fname}`)
+    fi = fi + 1
+  }
+}

dump_types.cm

@@ -0,0 +1,237 @@
+// dump_types.cm — show streamlined IR with type annotations
+//
+// Usage: ./cell --core . dump_types.cm <file.ce|file.cm>
+
+var fd = use("fd")
+var json = use("json")
+var tokenize = use("tokenize")
+var parse = use("parse")
+var fold = use("fold")
+var mcode = use("mcode")
+var streamline = use("streamline")
+
+if (length(args) < 1) {
+  print("usage: cell --core . dump_types.cm <file>")
+  return
+}
+
+var filename = args[0]
+var src = text(fd.slurp(filename))
+var tok = tokenize(src, filename)
+var ast = parse(tok.tokens, src, filename, tokenize)
+var folded = fold(ast)
+var compiled = mcode(folded)
+var optimized = streamline(compiled)
+
+// Type constants
+def T_UNKNOWN = "unknown"
+def T_INT = "int"
+def T_FLOAT = "float"
+def T_NUM = "num"
+def T_TEXT = "text"
+def T_BOOL = "bool"
+def T_NULL = "null"
+def T_ARRAY = "array"
+def T_RECORD = "record"
+def T_FUNCTION = "function"
+
+def int_result_ops = {
+  bitnot: true, bitand: true, bitor: true,
+  bitxor: true, shl: true, shr: true, ushr: true
+}
+def bool_result_ops = {
+  eq_int: true, ne_int: true, lt_int: true, gt_int: true,
+  le_int: true, ge_int: true,
+  eq_float: true, ne_float: true, lt_float: true, gt_float: true,
+  le_float: true, ge_float: true,
+  eq_text: true, ne_text: true, lt_text: true, gt_text: true,
+  le_text: true, ge_text: true,
+  eq_bool: true, ne_bool: true,
+  not: true, and: true, or: true,
+  is_int: true, is_text: true, is_num: true,
+  is_bool: true, is_null: true, is_identical: true,
+  is_array: true, is_func: true, is_record: true, is_stone: true
+}
+
+var access_value_type = function(val) {
+  if (is_number(val)) {
+    return is_integer(val) ? T_INT : T_FLOAT
+  }
+  if (is_text(val)) {
+    return T_TEXT
+  }
+  return T_UNKNOWN
+}
+
+var track_types = function(slot_types, instr) {
+  var op = instr[0]
+  var src_type = null
+  if (op == "access") {
+    slot_types[text(instr[1])] = access_value_type(instr[2])
+  } else if (op == "int") {
+    slot_types[text(instr[1])] = T_INT
+  } else if (op == "true" || op == "false") {
+    slot_types[text(instr[1])] = T_BOOL
+  } else if (op == "null") {
+    slot_types[text(instr[1])] = T_NULL
+  } else if (op == "move") {
+    src_type = slot_types[text(instr[2])]
+    slot_types[text(instr[1])] = src_type != null ? src_type : T_UNKNOWN
+  } else if (int_result_ops[op] == true) {
+    slot_types[text(instr[1])] = T_INT
+  } else if (op == "concat") {
+    slot_types[text(instr[1])] = T_TEXT
+  } else if (bool_result_ops[op] == true) {
+    slot_types[text(instr[1])] = T_BOOL
+  } else if (op == "typeof") {
+    slot_types[text(instr[1])] = T_TEXT
+  } else if (op == "array") {
+    slot_types[text(instr[1])] = T_ARRAY
+  } else if (op == "record") {
+    slot_types[text(instr[1])] = T_RECORD
+  } else if (op == "function") {
+    slot_types[text(instr[1])] = T_FUNCTION
+  } else if (op == "invoke" || op == "tail_invoke") {
+    slot_types[text(instr[2])] = T_UNKNOWN
+  } else if (op == "load_field" || op == "load_index" || op == "load_dynamic") {
+    slot_types[text(instr[1])] = T_UNKNOWN
+  } else if (op == "pop" || op == "get") {
+    slot_types[text(instr[1])] = T_UNKNOWN
+  } else if (op == "length") {
+    slot_types[text(instr[1])] = T_INT
+  } else if (op == "add" || op == "subtract" || op == "multiply" ||
+             op == "divide" || op == "modulo" || op == "pow" || op == "negate") {
+    slot_types[text(instr[1])] = T_UNKNOWN
+  }
+  return null
+}
+
+var pad_right = function(s, w) {
+  var r = s
+  while (length(r) < w) {
+    r = r + " "
+  }
+  return r
+}
+
+var fmt_val = function(v) {
+  if (is_null(v)) {
+    return "null"
+  }
+  if (is_number(v)) {
+    return text(v)
+  }
+  if (is_text(v)) {
+    return `"${v}"`
+  }
+  if (is_object(v)) {
+    return json.encode(v)
+  }
+  if (is_logical(v)) {
+    return v ? "true" : "false"
+  }
+  return text(v)
+}
+
+// Build type annotation string for an instruction
+var type_annotation = function(slot_types, instr) {
+  var n = length(instr)
+  var parts = []
+  var j = 1
+  var v = null
+  var t = null
+  while (j < n - 2) {
+    v = instr[j]
+    if (is_number(v)) {
+      t = slot_types[text(v)]
+      if (t != null && t != T_UNKNOWN) {
+        push(parts, `s${text(v)}:${t}`)
+      }
+    }
+    j = j + 1
+  }
+  if (length(parts) == 0) {
+    return ""
+  }
+  return text(parts, " ")
+}
+
+var dump_function_typed = function(func, name) {
+  var nr_args = func.nr_args != null ? func.nr_args : 0
+  var nr_slots = func.nr_slots != null ? func.nr_slots : 0
+  var instrs = func.instructions
+  var slot_types = {}
+  var i = 0
+  var pc = 0
+  var instr = null
+  var op = null
+  var n = 0
+  var annotation = null
+  var operand_parts = null
+  var j = 0
+  var operands = null
+  var pc_str = null
+  var op_str = null
+  var line = null
+  print(`\n=== ${name} (args=${text(nr_args)}, slots=${text(nr_slots)}) ===`)
+  if (instrs == null || length(instrs) == 0) {
+    print("  (empty)")
+    return null
+  }
+  while (i < length(instrs)) {
+    instr = instrs[i]
+    if (is_text(instr)) {
+      if (starts_with(instr, "_nop_")) {
+        i = i + 1
+        continue
+      }
+      slot_types = {}
+      print(`${instr}:`)
+    } else if (is_array(instr)) {
+      op = instr[0]
+      n = length(instr)
+      annotation = type_annotation(slot_types, instr)
+      operand_parts = []
+      j = 1
+      while (j < n - 2) {
+        push(operand_parts, fmt_val(instr[j]))
+        j = j + 1
+      }
+      operands = text(operand_parts, ", ")
+      pc_str = pad_right(text(pc), 5)
+      op_str = pad_right(op, 14)
+      line = pad_right(`  ${pc_str} ${op_str} ${operands}`, 50)
+      if (length(annotation) > 0) {
+        print(`${line} ; ${annotation}`)
+      } else {
+        print(line)
+      }
+      track_types(slot_types, instr)
+      pc = pc + 1
+    }
+    i = i + 1
+  }
+  return null
+}
+
+var main_name = null
+var fi = 0
+var func = null
+var fname = null
+
+// Dump main
+if (optimized.main != null) {
+  main_name = optimized.name != null ? optimized.name : "<main>"
+  dump_function_typed(optimized.main, main_name)
+}
+
+// Dump sub-functions
+if (optimized.functions != null) {
+  fi = 0
+  while (fi < length(optimized.functions)) {
+    func = optimized.functions[fi]
+    fname = func.name != null ? func.name : `<func_${text(fi)}>`
+    dump_function_typed(func, `[${text(fi)}] ${fname}`)
+    fi = fi + 1
+  }
+}

editors/ai/pit-context.md

@@ -0,0 +1,251 @@
+# ƿit Language — AI Context
+
+ƿit (pronounced "pit") is a safe, actor-based programming language. Its syntax resembles JavaScript but with significant differences. Scripts use `.ce` (actors) and `.cm` (modules) file extensions.
+
+## Key Differences from JavaScript
+
+- **`var` / `def`** — `var` is mutable, `def` is constant. No `let` or `const`.
+- **`==` is strict** — No `===` or `!==`. `==` and `!=` are always strict comparison.
+- **No `undefined`** — Only `null`. Division by zero produces `null`, not `Infinity`.
+- **No classes** — Use `meme()`, `proto()`, `isa()` for prototype chains.
+- **No `for...in`, `for...of`, spread, rest, or default params.**
+- **Variables declared at function body level only** — Not inside `if`/`while`/`for` blocks.
+- **All variables must be initialized** — `var x` alone is an error; use `var x = null`.
+- **`disrupt` / `disruption`** — No `try`/`catch`/`throw`. Error handling uses:
+  ```javascript
+  var fn = function() {
+    disrupt  // raise an error (bare keyword, no value)
+  } disruption {
+    // handle the error
+  }
+  ```
+- **No arraybuffers** — Use `blob` (works with bits; `stone(blob)` before reading).
+- **Identifiers can contain `?` and `!`** — e.g., `nil?`, `set!`, `is?valid`.
+- **4-parameter limit** — Functions take at most 4 named parameters.
+- **Everything lowercase** — Convention is all-lowercase identifiers with underscores.
+
+## Variable Declaration
+
+```javascript
+var count = 0         // mutable
+def MAX = 100         // constant (cannot be reassigned)
+var x = null          // must initialize (var x alone is an error)
+```
+
+## Functions
+
+```javascript
+var greet = function(name) {
+  print(`hello ${name}`)
+}
+
+// Arrow functions
+var double = x => x * 2
+var add = (a, b) => a + b
+```
+
+## Push / Pop Syntax
+
+```javascript
+var a = [1, 2]
+a[] = 3       // push: a is now [1, 2, 3]
+var v = a[]   // pop: v is 3, a is [1, 2]
+```
+
+## Control Flow
+
+```javascript
+if (x > 0) {
+  print("positive")
+} else {
+  print("non-positive")
+}
+
+while (i < 10) {
+  i = i + 1
+}
+
+for (var i = 0; i < 10; i = i + 1) {
+  print(i)
+}
+
+// do-while
+do {
+  i = i + 1
+} while (i < 10)
+```
+
+## Error Handling
+
+```javascript
+var safe_divide = function(a, b) {
+  if (b == 0) {
+    disrupt
+  }
+  return a / b
+} disruption {
+  return null
+}
+```
+
+## Creator Functions (Polymorphic)
+
+These examine argument types to decide behavior:
+
+### array()
+- `array(5)` — `[null, null, null, null, null]`
+- `array(3, 0)` — `[0, 0, 0]`
+- `array(5, i => i * 2)` — `[0, 2, 4, 6, 8]`
+- `array([1,2])` — copy
+- `array([1,2,3], x => x * 10)` — map: `[10, 20, 30]`
+- `array([1,2], [3,4])` — concat: `[1, 2, 3, 4]`
+- `array([1,2,3,4,5], 1, 4)` — slice: `[2, 3, 4]`
+- `array({a: 1, b: 2})` — keys: `["a", "b"]`
+- `array("hello")` — characters: `["h", "e", "l", "l", "o"]`
+- `array("a,b,c", ",")` — split: `["a", "b", "c"]`
+
+### text()
+- `text([1, 2, 3], ", ")` — join: `"1, 2, 3"`
+- `text(255, 16)` — radix: `"ff"`
+- `text("hello", 0, 3)` — substring: `"hel"`
+
+### number()
+- `number("42")` — parse: `42`
+- `number("ff", 16)` — radix: `255`
+- `number(true)` — `1`
+
+### record()
+- `record({a: 1})` — copy
+- `record({a: 1}, {b: 2})` — merge: `{a: 1, b: 2}`
+- `record(["x", "y"])` — from keys: `{x: true, y: true}`
+
+## All Intrinsic Functions
+
+**Constants:** `false`, `true`, `null`, `pi`
+
+**Type checks:** `is_array`, `is_blob`, `is_character`, `is_data`, `is_digit`, `is_false`, `is_fit`, `is_function`, `is_integer`, `is_letter`, `is_logical`, `is_lower`, `is_null`, `is_number`, `is_object`, `is_pattern`, `is_stone`, `is_text`, `is_true`, `is_upper`, `is_whitespace`
+
+**Creators:** `array`, `logical`, `number`, `record`, `text`
+
+**Math:** `abs`, `ceiling`, `floor`, `fraction`, `max`, `min`, `modulo`, `neg`, `remainder`, `round`, `sign`, `trunc`, `whole`
+
+**Text:** `character`, `codepoint`, `ends_with`, `extract`, `format`, `lower`, `normalize`, `replace`, `search`, `starts_with`, `trim`, `upper`
+
+**Array:** `every`, `filter`, `find`, `for`, `length`, `reduce`, `reverse`, `some`, `sort`
+
+**Objects:** `meme`, `proto`, `isa`, `stone`
+
+**Functions:** `apply`, `splat`
+
+**I/O:** `print`
+
+**Async:** `fallback`, `parallel`, `race`, `sequence`
+
+**Misc:** `logical`, `not`, `use`
+
+## Variable Scoping
+
+Variables are scoped to the function body in which they are declared. There is no block scoping. All declarations must be at the top level of a function body (not nested inside `if`/`while`/`for`).
+
+```javascript
+var outer = function() {
+  var x = 10
+  var inner = function() {
+    // x is visible here via closure
+    print(x)
+  }
+  inner()
+}
+```
+
+## Modules (.cm files)
+
+Modules return a value (typically a record of exports). They are loaded with `use()`, cached, and frozen.
+
+```javascript
+// math_utils.cm
+var square = x => x * x
+var cube = x => x * x * x
+return {square: square, cube: cube}
+
+// main.ce
+var utils = use('math_utils')
+print(utils.square(5))  // 25
+```
+
+## Standard Library (loaded with use())
+
+- `blob` — binary data (works with bits, not bytes)
+- `time` — time constants and conversions
+- `math` — trig, logarithms, roots (sub-modules: `math/radians`, `math/turns`)
+- `json` — JSON encoding/decoding (`json.encode`, `json.decode`)
+- `random` — random number generation
+- `fd` — file descriptor operations (`fd.read`, `fd.write`, `fd.slurp`, `fd.stat`)
+
+## Actor Model (.ce files)
+
+Actors are independent execution units that never share memory. They communicate via message passing.
+
+```javascript
+// greeter.ce
+$receiver(function(msg) {
+  $send(msg.from, {greeting: `hello ${msg.name}`})
+})
+```
+
+### Actor Intrinsics ($ prefix)
+
+- `$me` — this actor's address
+- `$send(address, message)` — send a message
+- `$start(script, env)` — start a new actor
+- `$stop()` — stop this actor
+- `$delay(ms)` — delay processing
+- `$receiver(fn)` — set message handler
+- `$clock(interval, message)` — periodic self-message
+- `$portal(name)` — create named portal
+- `$contact(name)` — connect to portal
+- `$couple(address)` — lifecycle coupling
+- `$unneeded(fn)` — cleanup callback
+- `$connection(address)` — establish connection
+- `$time_limit(ms)` — execution time limit
+
+## Common Patterns
+
+### Iteration
+```javascript
+// Preferred: use for() intrinsic
+for([1, 2, 3], function(item, index) {
+  print(`${text(index)}: ${text(item)}`)
+})
+
+// C-style for loop
+for (var i = 0; i < length(items); i = i + 1) {
+  print(items[i])
+}
+```
+
+### String Building
+```javascript
+// Use backtick interpolation
+var msg = `hello ${name}, you are ${text(age)} years old`
+
+// Join array
+var csv = text(values, ",")
+```
+
+### Record Manipulation
+```javascript
+var obj = {name: "alice", age: 30}
+var keys = array(obj)           // ["name", "age"]
+var copy = record(obj)          // mutable copy
+var merged = record(obj, {role: "admin"})
+```
+
+### Error-Safe Operations
+```javascript
+var safe_parse = function(input) {
+  return number(input)
+} disruption {
+  return null
+}
+```

editors/vscode/language-configuration.json

@@ -0,0 +1,30 @@
+{
+  "comments": {
+    "lineComment": "//",
+    "blockComment": ["/*", "*/"]
+  },
+  "brackets": [
+    ["{", "}"],
+    ["[", "]"],
+    ["(", ")"]
+  ],
+  "autoClosingPairs": [
+    { "open": "{", "close": "}" },
+    { "open": "[", "close": "]" },
+    { "open": "(", "close": ")" },
+    { "open": "\"", "close": "\"", "notIn": ["string"] },
+    { "open": "`", "close": "`", "notIn": ["string"] }
+  ],
+  "surroundingPairs": [
+    ["{", "}"],
+    ["[", "]"],
+    ["(", ")"],
+    ["\"", "\""],
+    ["`", "`"]
+  ],
+  "indentationRules": {
+    "increaseIndentPattern": "^.*\\{[^}\"'`]*$",
+    "decreaseIndentPattern": "^\\s*\\}"
+  },
+  "wordPattern": "[a-zA-Z_$][a-zA-Z0-9_$?!]*"
+}

editors/vscode/lsp/analysis.cm

@@ -0,0 +1,113 @@
+// Document analysis module.
+// Call make(tokenize_mod, parse_mod) to get an analysis object.
+
+var json = use('json')
+
+// Create an analysis module bound to the tokenize and parse functions.
+var make = function(tokenize_mod, parse_mod) {
+
+  // Tokenize and parse a document, storing the results.
+  var update = function(docs, uri, params) {
+    var src = params.src
+    var version = params.version
+    var tok_result = null
+    var ast = null
+    var errors = []
+    var doc = null
+
+    var do_tokenize = function() {
+      tok_result = tokenize_mod(src, uri)
+    } disruption {
+      errors = [{message: "Tokenize failed", line: 1, column: 1}]
+    }
+    var do_parse = function() {
+      ast = parse_mod(tok_result.tokens, src, uri, tokenize_mod)
+    } disruption {
+      // parse_mod may set errors on ast even on partial failure
+    }
+
+    do_tokenize()
+
+    if (tok_result != null) {
+      do_parse()
+
+      if (ast != null && ast.errors != null) {
+        errors = ast.errors
+      }
+    }
+
+    doc = {
+      uri: uri,
+      text: src,
+      version: version,
+      tokens: (tok_result != null) ? tok_result.tokens : [],
+      ast: ast,
+      errors: errors
+    }
+    docs[uri] = doc
+    return doc
+  }
+
+  // Remove a document from the store.
+  var remove = function(docs, uri) {
+    delete docs[uri]
+  }
+
+  // Convert parse errors to LSP diagnostics.
+  var diagnostics = function(doc) {
+    var result = []
+    var _i = 0
+    var e = null
+    var line = null
+    var col = null
+    while (_i < length(doc.errors)) {
+      e = doc.errors[_i]
+      line = (e.line != null) ? e.line - 1 : 0
+      col = (e.column != null) ? e.column - 1 : 0
+      result[] = {
+        range: {
+          start: {line: line, character: col},
+          end: {line: line, character: col + 1}
+        },
+        severity: 1,
+        source: "pit",
+        message: e.message
+      }
+      _i = _i + 1
+    }
+    return result
+  }
+
+  // Find the token at a given line/column (0-based).
+  var token_at = function(doc, line, col) {
+    var tokens = doc.tokens
+    var _i = 0
+    var tok = null
+    while (_i < length(tokens)) {
+      tok = tokens[_i]
+      if (tok.from_row == line && tok.from_column <= col && tok.to_column >= col) {
+        return tok
+      }
+      if (tok.from_row < line && tok.to_row > line) {
+        return tok
+      }
+      if (tok.from_row < line && tok.to_row == line && tok.to_column >= col) {
+        return tok
+      }
+      if (tok.from_row == line && tok.to_row > line && tok.from_column <= col) {
+        return tok
+      }
+      _i = _i + 1
+    }
+    return null
+  }
+
+  return {
+    update: update,
+    remove: remove,
+    diagnostics: diagnostics,
+    token_at: token_at
+  }
+}
+
+return make

editors/vscode/lsp/completions.cm

@@ -0,0 +1,133 @@
+// Completion provider for the ƿit LSP.
+
+// CompletionItemKind constants (LSP spec)
+def KIND_FUNCTION = 3
+def KIND_VARIABLE = 6
+def KIND_KEYWORD = 14
+def KIND_CONSTANT = 21
+
+// All intrinsic function names
+def intrinsic_functions = [
+  "abs", "apply", "array", "ceiling", "character", "codepoint",
+  "ends_with", "every", "extract", "fallback", "filter", "find",
+  "floor", "format", "fraction",
+  "is_array", "is_blob", "is_character", "is_data", "is_digit",
+  "is_false", "is_fit", "is_function", "is_integer", "is_letter",
+  "is_logical", "is_lower", "is_null", "is_number", "is_object",
+  "is_pattern", "is_stone", "is_text", "is_true", "is_upper",
+  "is_whitespace",
+  "length", "logical", "lower", "max", "min", "modulo",
+  "neg", "normalize", "not", "number",
+  "parallel", "print", "race", "record", "reduce", "remainder",
+  "replace", "reverse", "round",
+  "search", "sequence", "sign", "some", "sort", "starts_with",
+  "stone", "text", "trim", "trunc", "upper", "whole",
+  "meme", "proto", "isa", "splat", "use"
+]
+
+// Keywords that can be completed
+def keywords = [
+  "var", "def", "if", "else", "for", "while", "do",
+  "function", "return", "go", "break", "continue",
+  "disrupt", "disruption", "delete", "in", "this",
+  "null", "true", "false"
+]
+
+// Actor intrinsics (only in .ce files)
+def actor_intrinsics = [
+  "$me", "$send", "$start", "$stop", "$delay",
+  "$receiver", "$clock", "$portal", "$contact",
+  "$couple", "$unneeded", "$connection", "$time_limit"
+]
+
+// Walk AST scopes to find variables visible at a position.
+var collect_scope_vars = function(doc, line, col) {
+  var vars = []
+  var ast = doc.ast
+  var _i = 0
+  var _j = 0
+  var scope = null
+  var v = null
+
+  if (ast == null || ast.scopes == null) {
+    return vars
+  }
+
+  // Collect variables from all scopes (simplified: return all declared vars)
+  while (_i < length(ast.scopes)) {
+    scope = ast.scopes[_i]
+    if (scope.vars != null) {
+      _j = 0
+      while (_j < length(scope.vars)) {
+        v = scope.vars[_j]
+        if (v.name != null) {
+          vars[] = {
+            label: v.name,
+            kind: (v.is_const == true) ? KIND_CONSTANT : KIND_VARIABLE,
+            detail: (v.is_const == true) ? "def" : "var"
+          }
+        }
+        _j = _j + 1
+      }
+    }
+    _i = _i + 1
+  }
+
+  return vars
+}
+
+// Provide completions for a document at a position.
+var complete = function(doc, line, col) {
+  var items = []
+  var _i = 0
+  var is_actor = ends_with(doc.uri, ".ce")
+
+  // Intrinsic functions
+  _i = 0
+  while (_i < length(intrinsic_functions)) {
+    items[] = {
+      label: intrinsic_functions[_i],
+      kind: KIND_FUNCTION,
+      detail: "intrinsic"
+    }
+    _i = _i + 1
+  }
+
+  // Keywords
+  _i = 0
+  while (_i < length(keywords)) {
+    items[] = {
+      label: keywords[_i],
+      kind: KIND_KEYWORD,
+      detail: "keyword"
+    }
+    _i = _i + 1
+  }
+
+  // Actor intrinsics (only for .ce files)
+  if (is_actor) {
+    _i = 0
+    while (_i < length(actor_intrinsics)) {
+      items[] = {
+        label: actor_intrinsics[_i],
+        kind: KIND_FUNCTION,
+        detail: "actor intrinsic"
+      }
+      _i = _i + 1
+    }
+  }
+
+  // Variables from scope analysis
+  var scope_vars = collect_scope_vars(doc, line, col)
+  _i = 0
+  while (_i < length(scope_vars)) {
+    items[] = scope_vars[_i]
+    _i = _i + 1
+  }
+
+  return items
+}
+
+return {
+  complete: complete
+}

editors/vscode/lsp/hover.cm

@@ -0,0 +1,461 @@
+// Hover provider for the ƿit LSP.
+// Shows documentation for intrinsic functions and variable info.
+
+// Intrinsic function documentation database.
+// Each entry: {signature, description}
+def intrinsic_docs = {
+  abs: {
+    signature: "abs(number)",
+    description: "Absolute value. Returns null for non-numbers."
+  },
+  apply: {
+    signature: "apply(function, array)",
+    description: "Execute the function, passing array elements as input values."
+  },
+  array: {
+    signature: "array(value, ...)",
+    description: "Create arrays. Polymorphic: array(number) creates sized array, array(array) copies, array(array, fn) maps, array(text) splits into characters, array(text, sep) splits by separator."
+  },
+  ceiling: {
+    signature: "ceiling(number, place)",
+    description: "Round up. If place is 0 or null, round to smallest integer >= number."
+  },
+  character: {
+    signature: "character(value)",
+    description: "If text, returns the first character. If a non-negative integer, returns the character from that codepoint."
+  },
+  codepoint: {
+    signature: "codepoint(text)",
+    description: "Returns the codepoint number of the first character."
+  },
+  ends_with: {
+    signature: "ends_with(text, suffix)",
+    description: "Returns true if the text ends with the given suffix."
+  },
+  every: {
+    signature: "every(array, function)",
+    description: "Returns true if every element satisfies the predicate."
+  },
+  extract: {
+    signature: "extract(text, pattern, from, to)",
+    description: "Match text to pattern. Returns a record of saved fields, or null if no match."
+  },
+  fallback: {
+    signature: "fallback(requestor_array)",
+    description: "Returns a requestor that tries each requestor in order until one succeeds."
+  },
+  filter: {
+    signature: "filter(array, function)",
+    description: "Returns a new array containing elements for which function returns true."
+  },
+  find: {
+    signature: "find(array, function, reverse, from)",
+    description: "Returns the element number where function returns true, or null if not found. If second arg is not a function, compares directly."
+  },
+  floor: {
+    signature: "floor(number, place)",
+    description: "Round down. If place is 0 or null, round to greatest integer <= number."
+  },
+  format: {
+    signature: "format(text, collection, transformer)",
+    description: "Substitute {key} placeholders in text with values from a collection (array or record)."
+  },
+  fraction: {
+    signature: "fraction(number)",
+    description: "Returns the fractional part of a number."
+  },
+  is_array: {
+    signature: "is_array(value)",
+    description: "Returns true if the value is an array."
+  },
+  is_blob: {
+    signature: "is_blob(value)",
+    description: "Returns true if the value is a blob."
+  },
+  is_character: {
+    signature: "is_character(value)",
+    description: "Returns true if the value is a single character."
+  },
+  is_data: {
+    signature: "is_data(value)",
+    description: "Returns true if the value is data (not a function)."
+  },
+  is_digit: {
+    signature: "is_digit(value)",
+    description: "Returns true if the value is a digit character."
+  },
+  is_false: {
+    signature: "is_false(value)",
+    description: "Returns true if the value is false."
+  },
+  is_fit: {
+    signature: "is_fit(value)",
+    description: "Returns true if the value is a fit integer."
+  },
+  is_function: {
+    signature: "is_function(value)",
+    description: "Returns true if the value is a function."
+  },
+  is_integer: {
+    signature: "is_integer(value)",
+    description: "Returns true if the value is an integer."
+  },
+  is_letter: {
+    signature: "is_letter(value)",
+    description: "Returns true if the value is a letter character."
+  },
+  is_logical: {
+    signature: "is_logical(value)",
+    description: "Returns true if the value is a logical (boolean)."
+  },
+  is_lower: {
+    signature: "is_lower(value)",
+    description: "Returns true if the value is a lowercase character."
+  },
+  is_null: {
+    signature: "is_null(value)",
+    description: "Returns true if the value is null."
+  },
+  is_number: {
+    signature: "is_number(value)",
+    description: "Returns true if the value is a number."
+  },
+  is_object: {
+    signature: "is_object(value)",
+    description: "Returns true if the value is an object (record)."
+  },
+  is_pattern: {
+    signature: "is_pattern(value)",
+    description: "Returns true if the value is a pattern (regex)."
+  },
+  is_stone: {
+    signature: "is_stone(value)",
+    description: "Returns true if the value is frozen (stoned)."
+  },
+  is_text: {
+    signature: "is_text(value)",
+    description: "Returns true if the value is text."
+  },
+  is_true: {
+    signature: "is_true(value)",
+    description: "Returns true if the value is true."
+  },
+  is_upper: {
+    signature: "is_upper(value)",
+    description: "Returns true if the value is an uppercase character."
+  },
+  is_whitespace: {
+    signature: "is_whitespace(value)",
+    description: "Returns true if the value is a whitespace character."
+  },
+  length: {
+    signature: "length(value)",
+    description: "Array: number of elements. Text: number of codepoints. Function: arity. Blob: number of bits. Record: record.length()."
+  },
+  logical: {
+    signature: "logical(value)",
+    description: "Convert to logical. 0/false/null/\"false\" produce false; 1/true/\"true\" produce true."
+  },
+  lower: {
+    signature: "lower(text)",
+    description: "Returns text with all uppercase characters converted to lowercase."
+  },
+  max: {
+    signature: "max(number, number)",
+    description: "Returns the larger of two numbers."
+  },
+  min: {
+    signature: "min(number, number)",
+    description: "Returns the smaller of two numbers."
+  },
+  modulo: {
+    signature: "modulo(dividend, divisor)",
+    description: "Result has the sign of the divisor."
+  },
+  neg: {
+    signature: "neg(number)",
+    description: "Negate. Reverse the sign of a number."
+  },
+  normalize: {
+    signature: "normalize(text)",
+    description: "Unicode normalize."
+  },
+  not: {
+    signature: "not(logical)",
+    description: "Returns the opposite logical. Returns null for non-logicals."
+  },
+  number: {
+    signature: "number(value, radix_or_format)",
+    description: "Convert to number. Polymorphic: number(logical), number(text), number(text, radix), number(text, format)."
+  },
+  parallel: {
+    signature: "parallel(requestor_array, throttle, need)",
+    description: "Start all requestors concurrently. Optional throttle limits concurrency; optional need specifies minimum successes."
+  },
+  print: {
+    signature: "print(value)",
+    description: "Print a value to standard output."
+  },
+  race: {
+    signature: "race(requestor_array, throttle, need)",
+    description: "Like parallel but returns as soon as needed results are obtained. Default need is 1."
+  },
+  record: {
+    signature: "record(value, ...)",
+    description: "Create records. Polymorphic: record(record) copies, record(record, record) merges, record(array) creates from keys."
+  },
+  reduce: {
+    signature: "reduce(array, function, initial, reverse)",
+    description: "Reduce an array to a single value by applying a function to pairs of elements."
+  },
+  remainder: {
+    signature: "remainder(dividend, divisor)",
+    description: "For fit integers: dividend - ((dividend // divisor) * divisor)."
+  },
+  replace: {
+    signature: "replace(text, target, replacement, limit)",
+    description: "Return text with target replaced. Target can be text or pattern. Replacement can be text or function."
+  },
+  reverse: {
+    signature: "reverse(array)",
+    description: "Returns a new array with elements in the opposite order."
+  },
+  round: {
+    signature: "round(number, place)",
+    description: "Round to nearest."
+  },
+  search: {
+    signature: "search(text, target, from)",
+    description: "Search text for target. Returns character position or null."
+  },
+  sequence: {
+    signature: "sequence(requestor_array)",
+    description: "Process requestors in order. Each result becomes input to the next."
+  },
+  sign: {
+    signature: "sign(number)",
+    description: "Returns -1, 0, or 1."
+  },
+  some: {
+    signature: "some(array, function)",
+    description: "Returns true if any element satisfies the predicate."
+  },
+  sort: {
+    signature: "sort(array, select)",
+    description: "Returns a new sorted array. Sort keys must be all numbers or all texts. Ascending and stable."
+  },
+  starts_with: {
+    signature: "starts_with(text, prefix)",
+    description: "Returns true if the text starts with the given prefix."
+  },
+  stone: {
+    signature: "stone(value)",
+    description: "Petrify the value, making it permanently immutable. Deep freeze."
+  },
+  text: {
+    signature: "text(value, ...)",
+    description: "Convert to text. Polymorphic: text(array, sep) joins, text(number, radix/format) formats, text(text, from, to) substrings."
+  },
+  trim: {
+    signature: "trim(text, reject)",
+    description: "Remove characters from both ends. Default removes whitespace."
+  },
+  trunc: {
+    signature: "trunc(number, place)",
+    description: "Truncate toward zero."
+  },
+  upper: {
+    signature: "upper(text)",
+    description: "Returns text with all lowercase characters converted to uppercase."
+  },
+  whole: {
+    signature: "whole(number)",
+    description: "Returns the whole part of a number."
+  },
+  meme: {
+    signature: "meme()",
+    description: "Create a new meme (prototype chain marker)."
+  },
+  proto: {
+    signature: "proto(object, meme)",
+    description: "Set the prototype meme of an object."
+  },
+  isa: {
+    signature: "isa(object, meme)",
+    description: "Returns true if the object has the given meme in its prototype chain."
+  },
+  splat: {
+    signature: "splat(function, array)",
+    description: "Call function with array elements as separate arguments."
+  },
+  use: {
+    signature: "use(path)",
+    description: "Load a module. Returns the module's exported value. Modules are cached and frozen."
+  },
+  pi: {
+    signature: "pi",
+    description: "An approximation of circumference / diameter: 3.1415926535897932."
+  }
+}
+
+// Actor intrinsic documentation
+def actor_docs = {
+  "$me": {
+    signature: "$me",
+    description: "The address of this actor."
+  },
+  "$send": {
+    signature: "$send(address, message)",
+    description: "Send a message to another actor."
+  },
+  "$start": {
+    signature: "$start(script, env)",
+    description: "Start a new actor from a script path."
+  },
+  "$stop": {
+    signature: "$stop()",
+    description: "Stop this actor."
+  },
+  "$delay": {
+    signature: "$delay(milliseconds)",
+    description: "Delay processing for a number of milliseconds."
+  },
+  "$receiver": {
+    signature: "$receiver(function)",
+    description: "Set the message receiver function for this actor."
+  },
+  "$clock": {
+    signature: "$clock(interval, message)",
+    description: "Send a message to self at regular intervals."
+  },
+  "$portal": {
+    signature: "$portal(name)",
+    description: "Create a named portal for inter-actor communication."
+  },
+  "$contact": {
+    signature: "$contact(portal_name)",
+    description: "Connect to a named portal."
+  },
+  "$couple": {
+    signature: "$couple(address)",
+    description: "Couple with another actor for lifecycle management."
+  },
+  "$unneeded": {
+    signature: "$unneeded(function)",
+    description: "Set a function to be called when this actor is no longer needed."
+  },
+  "$connection": {
+    signature: "$connection(address)",
+    description: "Establish a connection with another actor."
+  },
+  "$time_limit": {
+    signature: "$time_limit(milliseconds)",
+    description: "Set a time limit for this actor's execution."
+  }
+}
+
+// Provide hover info for a token.
+var hover = function(doc, line, col, token_at) {
+  var tok = token_at(doc, line, col)
+  var info = null
+  var name = null
+  var _i = 0
+  var _j = 0
+  var scope = null
+  var v = null
+
+  if (tok == null) {
+    return null
+  }
+
+  // Check intrinsic functions
+  if (tok.kind == "name" && tok.value != null) {
+    name = tok.value
+    info = intrinsic_docs[name]
+    if (info != null) {
+      return {
+        contents: {
+          kind: "markdown",
+          value: `**${info.signature}**\n\n${info.description}`
+        }
+      }
+    }
+  }
+
+  // Check actor intrinsics ($name)
+  if (tok.value != null && starts_with(tok.value, "$")) {
+    info = actor_docs[tok.value]
+    if (info != null) {
+      return {
+        contents: {
+          kind: "markdown",
+          value: `**${info.signature}**\n\n${info.description}`
+        }
+      }
+    }
+  }
+
+  // Check keywords
+  if (tok.kind == "var" || tok.kind == "def") {
+    return {
+      contents: {
+        kind: "markdown",
+        value: (tok.kind == "var")
+          ? "**var** — Declare a mutable variable."
+          : "**def** — Declare a constant."
+      }
+    }
+  }
+
+  if (tok.kind == "disrupt") {
+    return {
+      contents: {
+        kind: "markdown",
+        value: "**disrupt** — Raise an error. Use with **disruption** block to handle errors."
+      }
+    }
+  }
+
+  if (tok.kind == "disruption") {
+    return {
+      contents: {
+        kind: "markdown",
+        value: "**disruption** — Error handling block. Catches errors raised by **disrupt**."
+      }
+    }
+  }
+
+  // User variable: show declaration info from scope
+  if (tok.kind == "name" && tok.value != null && doc.ast != null && doc.ast.scopes != null) {
+    _i = 0
+    while (_i < length(doc.ast.scopes)) {
+      scope = doc.ast.scopes[_i]
+      if (scope.vars != null) {
+        _j = 0
+        while (_j < length(scope.vars)) {
+          v = scope.vars[_j]
+          if (v.name == tok.value) {
+            return {
+              contents: {
+                kind: "markdown",
+                value: (v.is_const == true)
+                  ? `**def** ${v.name}`
+                  : `**var** ${v.name}`
+              }
+            }
+          }
+          _j = _j + 1
+        }
+      }
+      _i = _i + 1
+    }
+  }
+
+  return null
+}
+
+return {
+  hover: hover,
+  intrinsic_docs: intrinsic_docs,
+  actor_docs: actor_docs
+}

editors/vscode/lsp/lsp.ce

@@ -0,0 +1,209 @@
+// ƿit Language Server Protocol (LSP) main loop.
+// Communicates via JSON-RPC over stdin/stdout.
+
+var fd = use('fd')
+var json_mod = use('json')
+var protocol = use('protocol')
+var analysis_make = use('analysis')
+var completions = use('completions')
+var hover_mod = use('hover')
+var symbols = use('symbols')
+
+// Get tokenize_mod and parse_mod from the environment.
+// These are the same functions the compiler uses internally.
+var tokenize_mod = use('tokenize')
+var parse_mod = use('parse')
+
+// Create analysis module bound to tokenize/parse
+var analysis = analysis_make(tokenize_mod, parse_mod)
+
+// Document store: URI -> {text, version, ast, tokens, errors}
+var docs = {}
+
+// Log to stderr for debugging (does not interfere with protocol).
+var log = function(msg) {
+  fd.write(2, `[pit-lsp] ${msg}\n`)
+}
+
+// Publish diagnostics for a document.
+var publish_diagnostics = function(uri, doc) {
+  var diags = analysis.diagnostics(doc)
+  protocol.notify("textDocument/publishDiagnostics", {
+    uri: uri,
+    diagnostics: diags
+  })
+}
+
+// Parse a document and publish diagnostics.
+var parse_and_notify = function(uri, src, version) {
+  var doc = analysis.update(docs, uri, {src: src, version: version})
+  publish_diagnostics(uri, doc)
+}
+
+// Handle initialize request.
+var handle_initialize = function(id, params) {
+  protocol.respond(id, {
+    capabilities: {
+      textDocumentSync: {
+        openClose: true,
+        change: 1,
+        save: {includeText: true}
+      },
+      completionProvider: {
+        triggerCharacters: [".", "$"]
+      },
+      hoverProvider: true,
+      definitionProvider: true,
+      documentSymbolProvider: true
+    },
+    serverInfo: {
+      name: "pit-lsp",
+      version: "0.1.0"
+    }
+  })
+}
+
+// Handle textDocument/didOpen notification.
+var handle_did_open = function(params) {
+  var td = params.textDocument
+  parse_and_notify(td.uri, td.text, td.version)
+}
+
+// Handle textDocument/didChange notification (full text sync).
+var handle_did_change = function(params) {
+  var td = params.textDocument
+  var changes = params.contentChanges
+  if (length(changes) > 0) {
+    parse_and_notify(td.uri, changes[0].text, td.version)
+  }
+}
+
+// Handle textDocument/didClose notification.
+var handle_did_close = function(params) {
+  var uri = params.textDocument.uri
+  analysis.remove(docs, uri)
+  // Clear diagnostics
+  protocol.notify("textDocument/publishDiagnostics", {
+    uri: uri,
+    diagnostics: []
+  })
+}
+
+// Handle textDocument/didSave notification.
+var handle_did_save = function(params) {
+  var td = params.textDocument
+  if (params.text != null) {
+    parse_and_notify(td.uri, params.text, td.version)
+  }
+}
+
+// Handle textDocument/completion request.
+var handle_completion = function(id, params) {
+  var uri = params.textDocument.uri
+  var pos = params.position
+  var doc = docs[uri]
+  var items = []
+  if (doc != null) {
+    items = completions.complete(doc, pos.line, pos.character)
+  }
+  protocol.respond(id, items)
+}
+
+// Handle textDocument/hover request.
+var handle_hover = function(id, params) {
+  var uri = params.textDocument.uri
+  var pos = params.position
+  var doc = docs[uri]
+  var result = null
+  if (doc != null) {
+    result = hover_mod.hover(doc, pos.line, pos.character, analysis.token_at)
+  }
+  protocol.respond(id, result)
+}
+
+// Handle textDocument/definition request.
+var handle_definition = function(id, params) {
+  var uri = params.textDocument.uri
+  var pos = params.position
+  var doc = docs[uri]
+  var result = null
+  if (doc != null) {
+    result = symbols.definition(doc, pos.line, pos.character, analysis.token_at)
+  }
+  protocol.respond(id, result)
+}
+
+// Handle textDocument/documentSymbol request.
+var handle_document_symbol = function(id, params) {
+  var uri = params.textDocument.uri
+  var doc = docs[uri]
+  var result = []
+  if (doc != null) {
+    result = symbols.document_symbols(doc)
+  }
+  protocol.respond(id, result)
+}
+
+// Dispatch a single message. Wrapped in a function for disruption handling.
+var dispatch_message = function(msg) {
+  var method = msg.method
+  if (method == "initialize") {
+    handle_initialize(msg.id, msg.params)
+  } else if (method == "initialized") {
+    // no-op
+  } else if (method == "textDocument/didOpen") {
+    handle_did_open(msg.params)
+  } else if (method == "textDocument/didChange") {
+    handle_did_change(msg.params)
+  } else if (method == "textDocument/didClose") {
+    handle_did_close(msg.params)
+  } else if (method == "textDocument/didSave") {
+    handle_did_save(msg.params)
+  } else if (method == "textDocument/completion") {
+    handle_completion(msg.id, msg.params)
+  } else if (method == "textDocument/hover") {
+    handle_hover(msg.id, msg.params)
+  } else if (method == "textDocument/definition") {
+    handle_definition(msg.id, msg.params)
+  } else if (method == "textDocument/documentSymbol") {
+    handle_document_symbol(msg.id, msg.params)
+  } else if (method == "shutdown") {
+    protocol.respond(msg.id, null)
+    return "shutdown"
+  } else if (method == "exit") {
+    return "exit"
+  } else {
+    if (msg.id != null) {
+      protocol.respond_error(msg.id, -32601, `Method not found: ${method}`)
+    }
+  }
+  return null
+} disruption {
+  log(`error handling ${msg.method}`)
+  if (msg.id != null) {
+    protocol.respond_error(msg.id, -32603, `Internal error handling ${msg.method}`)
+  }
+  return null
+}
+
+// Main loop.
+log("starting")
+
+var running = true
+var msg = null
+var result = null
+
+while (running) {
+  msg = protocol.read_message()
+  if (msg == null) {
+    running = false
+    break
+  }
+
+  result = dispatch_message(msg)
+  if (result == "exit") {
+    running = false
+  }
+}
+
+log("stopped")

editors/vscode/lsp/protocol.cm

@@ -0,0 +1,102 @@
+// JSON-RPC protocol helpers for LSP communication over stdin/stdout.
+// Reads Content-Length framed messages from stdin, writes to stdout.
+
+var fd = use('fd')
+var json = use('json')
+
+// Read a single JSON-RPC message from stdin.
+// Protocol: "Content-Length: N\r\n\r\n" followed by N bytes of JSON.
+var read_message = function() {
+  var header = ""
+  var ch = null
+  var content_length = null
+  var body = null
+  var total = 0
+  var chunk = null
+
+  // Read header byte by byte until we hit \r\n\r\n
+  while (true) {
+    ch = fd.read(0, 1)
+    if (ch == null) {
+      return null
+    }
+    header = header + text(ch)
+    if (ends_with(header, "\r\n\r\n")) {
+      break
+    }
+  }
+
+  // Parse Content-Length from header
+  var lines = array(header, "\r\n")
+  var _i = 0
+  while (_i < length(lines)) {
+    if (starts_with(lines[_i], "Content-Length:")) {
+      content_length = number(trim(text(lines[_i], 16)))
+    }
+    _i = _i + 1
+  }
+
+  if (content_length == null) {
+    return null
+  }
+
+  // Read exactly content_length bytes
+  body = ""
+  total = 0
+  while (total < content_length) {
+    chunk = fd.read(0, content_length - total)
+    if (chunk == null) {
+      return null
+    }
+    chunk = text(chunk)
+    body = body + chunk
+    total = total + length(chunk)
+  }
+
+  return json.decode(body)
+}
+
+// Send a JSON-RPC message to stdout.
+var send_message = function(msg) {
+  var body = json.encode(msg)
+  var header = `Content-Length: ${text(length(body))}\r\n\r\n`
+  fd.write(1, header + body)
+}
+
+// Send a JSON-RPC response for a request.
+var respond = function(id, result) {
+  send_message({
+    jsonrpc: "2.0",
+    id: id,
+    result: result
+  })
+}
+
+// Send a JSON-RPC error response.
+var respond_error = function(id, code, message) {
+  send_message({
+    jsonrpc: "2.0",
+    id: id,
+    error: {
+      code: code,
+      message: message
+    }
+  })
+}
+
+// Send a JSON-RPC notification (no id).
+var notify = function(method, params) {
+  send_message({
+    jsonrpc: "2.0",
+    method: method,
+    params: params
+  })
+}
+
+return {
+  read_message: read_message,
+  send_message: send_message,
+  respond: respond,
+  respond_error: respond_error,
+  notify: notify
+}

editors/vscode/lsp/symbols.cm

@@ -0,0 +1,238 @@
+// Document symbols and go-to-definition provider for the ƿit LSP.
+
+// SymbolKind constants (LSP spec)
+def KIND_FUNCTION = 12
+def KIND_VARIABLE = 13
+def KIND_CONSTANT = 14
+
+// Walk AST to extract document symbols (top-level vars/defs and functions).
+var document_symbols = function(doc) {
+  var symbols = []
+  var ast = doc.ast
+  var _i = 0
+  var _j = 0
+  var stmt = null
+  var decl = null
+  var name = null
+  var kind = null
+  var range = null
+
+  if (ast == null || ast.statements == null) {
+    return symbols
+  }
+
+  while (_i < length(ast.statements)) {
+    stmt = ast.statements[_i]
+
+    if (stmt.kind == "var" || stmt.kind == "def") {
+      name = null
+      kind = KIND_VARIABLE
+
+      if (stmt.left != null && stmt.left.name != null) {
+        name = stmt.left.name
+      }
+
+      if (stmt.kind == "def") {
+        kind = KIND_CONSTANT
+      }
+
+      if (stmt.right != null && (stmt.right.kind == "function" || stmt.right.kind == "arrow function")) {
+        kind = KIND_FUNCTION
+      }
+
+      if (name != null) {
+        range = {
+          start: {line: stmt.from_row, character: stmt.from_column},
+          end: {line: stmt.to_row, character: stmt.to_column}
+        }
+        symbols[] = {
+          name: name,
+          kind: kind,
+          range: range,
+          selectionRange: {
+            start: {line: stmt.left.from_row, character: stmt.left.from_column},
+            end: {line: stmt.left.to_row, character: stmt.left.to_column}
+          }
+        }
+      }
+    }
+
+    if (stmt.kind == "var_list" && stmt.list != null) {
+      _j = 0
+      while (_j < length(stmt.list)) {
+        decl = stmt.list[_j]
+        if (decl.left != null && decl.left.name != null) {
+          kind = (decl.kind == "def") ? KIND_CONSTANT : KIND_VARIABLE
+          if (decl.right != null && (decl.right.kind == "function" || decl.right.kind == "arrow function")) {
+            kind = KIND_FUNCTION
+          }
+          range = {
+            start: {line: decl.from_row, character: decl.from_column},
+            end: {line: decl.to_row, character: decl.to_column}
+          }
+          symbols[] = {
+            name: decl.left.name,
+            kind: kind,
+            range: range,
+            selectionRange: {
+              start: {line: decl.left.from_row, character: decl.left.from_column},
+              end: {line: decl.left.to_row, character: decl.left.to_column}
+            }
+          }
+        }
+        _j = _j + 1
+      }
+    }
+
+    _i = _i + 1
+  }
+
+  return symbols
+}
+
+// Find the declaration location of a name at a given position.
+var definition = function(doc, line, col, token_at) {
+  var tok = token_at(doc, line, col)
+  var ast = doc.ast
+  var name = null
+  var _i = 0
+  var _j = 0
+  var scope = null
+  var v = null
+  var decl = null
+
+  if (tok == null || tok.kind != "name" || tok.value == null) {
+    return null
+  }
+
+  name = tok.value
+
+  if (ast == null) {
+    return null
+  }
+
+  // Search through scopes for the variable declaration
+  if (ast.scopes != null) {
+    _i = 0
+    while (_i < length(ast.scopes)) {
+      scope = ast.scopes[_i]
+      if (scope.vars != null) {
+        _j = 0
+        while (_j < length(scope.vars)) {
+          v = scope.vars[_j]
+          if (v.name == name) {
+            decl = find_declaration(ast.statements, name)
+            if (decl != null) {
+              return {
+                uri: doc.uri,
+                range: {
+                  start: {line: decl.from_row, character: decl.from_column},
+                  end: {line: decl.to_row, character: decl.to_column}
+                }
+              }
+            }
+          }
+          _j = _j + 1
+        }
+      }
+      _i = _i + 1
+    }
+  }
+
+  // Fallback: walk statements for var/def with this name
+  decl = find_declaration(ast.statements, name)
+  if (decl != null) {
+    return {
+      uri: doc.uri,
+      range: {
+        start: {line: decl.from_row, character: decl.from_column},
+        end: {line: decl.to_row, character: decl.to_column}
+      }
+    }
+  }
+
+  return null
+}
+
+// Recursively search statements for a var/def declaration of a given name.
+var find_declaration = function(statements, name) {
+  var _i = 0
+  var _j = 0
+  var stmt = null
+  var result = null
+
+  if (statements == null) {
+    return null
+  }
+
+  while (_i < length(statements)) {
+    stmt = statements[_i]
+
+    // Direct var/def
+    if ((stmt.kind == "var" || stmt.kind == "def")
+        && stmt.left != null && stmt.left.name == name) {
+      return stmt
+    }
+
+    // var_list
+    if (stmt.kind == "var_list" && stmt.list != null) {
+      _j = 0
+      while (_j < length(stmt.list)) {
+        if (stmt.list[_j].left != null && stmt.list[_j].left.name == name) {
+          return stmt.list[_j]
+        }
+        _j = _j + 1
+      }
+    }
+
+    // Recurse into blocks
+    if (stmt.statements != null) {
+      result = find_declaration(stmt.statements, name)
+      if (result != null) {
+        return result
+      }
+    }
+
+    // if/else
+    if (stmt.kind == "if") {
+      if (stmt.then != null && stmt.then.statements != null) {
+        result = find_declaration(stmt.then.statements, name)
+        if (result != null) {
+          return result
+        }
+      }
+      if (stmt.else != null && stmt.else.statements != null) {
+        result = find_declaration(stmt.else.statements, name)
+        if (result != null) {
+          return result
+        }
+      }
+    }
+
+    // Function body
+    if ((stmt.kind == "function" || stmt.kind == "arrow function") && stmt.statements != null) {
+      result = find_declaration(stmt.statements, name)
+      if (result != null) {
+        return result
+      }
+    }
+
+    // var/def with function right side
+    if ((stmt.kind == "var" || stmt.kind == "def") && stmt.right != null) {
+      if ((stmt.right.kind == "function" || stmt.right.kind == "arrow function") && stmt.right.statements != null) {
+        result = find_declaration(stmt.right.statements, name)
+        if (result != null) {
+          return result
+        }
+      }
+    }
+
+    _i = _i + 1
+  }
+  return null
+}
+
+return {
+  document_symbols: document_symbols,
+  definition: definition
+}

editors/vscode/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "pit-language",
+  "displayName": "ƿit Language",
+  "description": "Language support for ƿit (.ce/.cm) — syntax highlighting, diagnostics, completions, hover, and go-to-definition",
+  "version": "0.1.0",
+  "publisher": "pit-lang",
+  "engines": {
+    "vscode": "^1.75.0"
+  },
+  "categories": [
+    "Programming Languages"
+  ],
+  "activationEvents": [
+    "onLanguage:pit"
+  ],
+  "main": "./out/extension.js",
+  "contributes": {
+    "languages": [
+      {
+        "id": "pit",
+        "aliases": [
+          "ƿit",
+          "pit"
+        ],
+        "extensions": [
+          ".ce",
+          ".cm"
+        ],
+        "configuration": "./language-configuration.json"
+      }
+    ],
+    "grammars": [
+      {
+        "language": "pit",
+        "scopeName": "source.pit",
+        "path": "./syntaxes/pit.tmLanguage.json"
+      }
+    ],
+    "configuration": {
+      "title": "ƿit",
+      "properties": {
+        "pit.cellPath": {
+          "type": "string",
+          "default": "cell",
+          "description": "Path to the cell executable"
+        }
+      }
+    }
+  },
+  "scripts": {
+    "compile": "tsc -p ./",
+    "watch": "tsc -watch -p ./"
+  },
+  "dependencies": {
+    "vscode-languageclient": "^9.0.0",
+    "vscode-languageserver-protocol": "^3.17.0"
+  },
+  "devDependencies": {
+    "@types/vscode": "^1.75.0",
+    "typescript": "^5.0.0"
+  }
+}

editors/vscode/src/extension.ts

@@ -0,0 +1,44 @@
+import * as path from "path";
+import { workspace, ExtensionContext } from "vscode";
+import {
+  LanguageClient,
+  LanguageClientOptions,
+  ServerOptions,
+} from "vscode-languageclient/node";
+
+let client: LanguageClient;
+
+export function activate(context: ExtensionContext) {
+  const config = workspace.getConfiguration("pit");
+  const cellPath = config.get<string>("cellPath", "cell");
+  const lspDir = path.join(context.extensionPath, "lsp");
+
+  const serverOptions: ServerOptions = {
+    command: cellPath,
+    args: ["lsp/lsp"],
+    options: { cwd: lspDir },
+  };
+
+  const clientOptions: LanguageClientOptions = {
+    documentSelector: [{ scheme: "file", language: "pit" }],
+    synchronize: {
+      fileEvents: workspace.createFileSystemWatcher("**/*.{ce,cm}"),
+    },
+  };
+
+  client = new LanguageClient(
+    "pitLanguageServer",
+    "ƿit Language Server",
+    serverOptions,
+    clientOptions
+  );
+
+  client.start();
+}
+
+export function deactivate(): Thenable<void> | undefined {
+  if (!client) {
+    return undefined;
+  }
+  return client.stop();
+}

editors/vscode/syntaxes/pit.tmLanguage.json

@@ -0,0 +1,160 @@
+{
+  "$schema": "https://raw.githubusercontent.com/martinring/tmlanguage/master/tmlanguage.json",
+  "name": "pit",
+  "scopeName": "source.pit",
+  "patterns": [
+    { "include": "#comment-line" },
+    { "include": "#comment-block" },
+    { "include": "#string-template" },
+    { "include": "#string-double" },
+    { "include": "#regexp" },
+    { "include": "#keyword-control" },
+    { "include": "#keyword-error" },
+    { "include": "#storage-type" },
+    { "include": "#constant-language" },
+    { "include": "#variable-language" },
+    { "include": "#actor-intrinsic" },
+    { "include": "#keyword-operator" },
+    { "include": "#arrow-function" },
+    { "include": "#support-function" },
+    { "include": "#constant-numeric-hex" },
+    { "include": "#constant-numeric-binary" },
+    { "include": "#constant-numeric-octal" },
+    { "include": "#constant-numeric" },
+    { "include": "#punctuation" }
+  ],
+  "repository": {
+    "comment-line": {
+      "name": "comment.line.double-slash.pit",
+      "match": "//.*$"
+    },
+    "comment-block": {
+      "name": "comment.block.pit",
+      "begin": "/\\*",
+      "end": "\\*/",
+      "beginCaptures": { "0": { "name": "punctuation.definition.comment.begin.pit" } },
+      "endCaptures": { "0": { "name": "punctuation.definition.comment.end.pit" } }
+    },
+    "string-double": {
+      "name": "string.quoted.double.pit",
+      "begin": "\"",
+      "end": "\"",
+      "beginCaptures": { "0": { "name": "punctuation.definition.string.begin.pit" } },
+      "endCaptures": { "0": { "name": "punctuation.definition.string.end.pit" } },
+      "patterns": [
+        {
+          "name": "constant.character.escape.pit",
+          "match": "\\\\(?:[\"\\\\bfnrt/]|u[0-9a-fA-F]{4})"
+        }
+      ]
+    },
+    "string-template": {
+      "name": "string.template.pit",
+      "begin": "`",
+      "end": "`",
+      "beginCaptures": { "0": { "name": "punctuation.definition.string.template.begin.pit" } },
+      "endCaptures": { "0": { "name": "punctuation.definition.string.template.end.pit" } },
+      "patterns": [
+        {
+          "name": "constant.character.escape.pit",
+          "match": "\\\\(?:[`\\\\bfnrt/$]|u[0-9a-fA-F]{4})"
+        },
+        {
+          "name": "meta.template.expression.pit",
+          "begin": "\\$\\{",
+          "end": "\\}",
+          "beginCaptures": { "0": { "name": "punctuation.definition.template-expression.begin.pit" } },
+          "endCaptures": { "0": { "name": "punctuation.definition.template-expression.end.pit" } },
+          "patterns": [
+            { "include": "source.pit" }
+          ]
+        }
+      ]
+    },
+    "regexp": {
+      "name": "string.regexp.pit",
+      "begin": "(?<=[=(:,;!&|?~^>]|^|return|disrupt)\\s*(/(?![/*]))",
+      "end": "/([gimsuvy]*)",
+      "beginCaptures": { "1": { "name": "punctuation.definition.string.begin.pit" } },
+      "endCaptures": { "1": { "name": "keyword.other.pit" } },
+      "patterns": [
+        {
+          "name": "constant.character.escape.pit",
+          "match": "\\\\."
+        }
+      ]
+    },
+    "keyword-control": {
+      "name": "keyword.control.pit",
+      "match": "\\b(if|else|for|while|do|break|continue|return|go)\\b"
+    },
+    "keyword-error": {
+      "name": "keyword.control.error.pit",
+      "match": "\\b(disrupt|disruption)\\b"
+    },
+    "storage-type": {
+      "patterns": [
+        {
+          "name": "storage.type.pit",
+          "match": "\\b(var|def)\\b"
+        },
+        {
+          "name": "storage.type.function.pit",
+          "match": "\\bfunction\\b"
+        }
+      ]
+    },
+    "constant-language": {
+      "name": "constant.language.pit",
+      "match": "\\b(null|true|false)\\b"
+    },
+    "variable-language": {
+      "name": "variable.language.this.pit",
+      "match": "\\bthis\\b"
+    },
+    "actor-intrinsic": {
+      "name": "variable.language.actor.pit",
+      "match": "\\$[a-zA-Z_][a-zA-Z0-9_]*"
+    },
+    "keyword-operator": {
+      "name": "keyword.operator.pit",
+      "match": "\\b(delete|in|typeof)\\b"
+    },
+    "arrow-function": {
+      "name": "storage.type.function.arrow.pit",
+      "match": "=>"
+    },
+    "support-function": {
+      "name": "support.function.pit",
+      "match": "\\b(abs|apply|array|ceiling|character|codepoint|ends_with|every|extract|fallback|filter|find|floor|for|format|fraction|is_array|is_blob|is_character|is_data|is_digit|is_false|is_fit|is_function|is_integer|is_letter|is_logical|is_lower|is_null|is_number|is_object|is_pattern|is_stone|is_text|is_true|is_upper|is_whitespace|length|logical|lower|max|min|modulo|neg|normalize|not|number|parallel|print|race|record|reduce|remainder|replace|reverse|round|search|sequence|sign|some|sort|starts_with|stone|text|trim|trunc|upper|whole|meme|proto|isa|splat|use)(?=\\s*\\()"
+    },
+    "constant-numeric-hex": {
+      "name": "constant.numeric.hex.pit",
+      "match": "\\b0[xX][0-9a-fA-F]+\\b"
+    },
+    "constant-numeric-binary": {
+      "name": "constant.numeric.binary.pit",
+      "match": "\\b0[bB][01]+\\b"
+    },
+    "constant-numeric-octal": {
+      "name": "constant.numeric.octal.pit",
+      "match": "\\b0[oO][0-7]+\\b"
+    },
+    "constant-numeric": {
+      "name": "constant.numeric.pit",
+      "match": "\\b[0-9]+(\\.[0-9]+)?([eE][+-]?[0-9]+)?\\b"
+    },
+    "punctuation": {
+      "patterns": [
+        {
+          "name": "punctuation.separator.comma.pit",
+          "match": ","
+        },
+        {
+          "name": "punctuation.terminator.statement.pit",
+          "match": ";"
+        }
+      ]
+    }
+  }
+}

editors/vscode/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "target": "ES2020",
+    "outDir": "out",
+    "lib": ["ES2020"],
+    "sourceMap": true,
+    "rootDir": "src",
+    "strict": true
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "out"]
+}

fd.c

@@ -504,7 +504,7 @@ JSC_SCALL(fd_readdir,
        ret = JS_NewArray(js);
        do {
           if (strcmp(ffd.cFileName, ".") == 0 || strcmp(ffd.cFileName, "..") == 0) continue;
-          JS_ArrayPush(js, ret,JS_NewString(js, ffd.cFileName));
+          JS_ArrayPush(js, &ret, JS_NewString(js, ffd.cFileName));
        } while (FindNextFile(hFind, &ffd) != 0);
        FindClose(hFind);
     }
@@ -516,7 +516,7 @@ JSC_SCALL(fd_readdir,
         ret = JS_NewArray(js);
         while ((dir = readdir(d)) != NULL) {
             if (strcmp(dir->d_name, ".") == 0 || strcmp(dir->d_name, "..") == 0) continue;
-            JS_ArrayPush(js, ret, JS_NewString(js, dir->d_name));
+            JS_ArrayPush(js, &ret, JS_NewString(js, dir->d_name));
         }
         closedir(d);
     } else {
@@ -565,18 +565,22 @@ JSC_CCALL(fd_slurpwrite,
     if (!str) return JS_EXCEPTION;
     int fd = open(str, O_WRONLY | O_CREAT | O_TRUNC, 0644);
     if (fd < 0)  {
+      ret = JS_ThrowInternalError(js, "open failed for %s: %s", str, strerror(errno));
       JS_FreeCString(js, str);
-      return JS_ThrowInternalError(js, "open failed for %s: %s", str, strerror(errno));
+      return ret;
     }
-    
+
     ssize_t written = write(fd, data, len);
     close(fd);
 
+    if (written != (ssize_t)len) {
+      ret = JS_ThrowInternalError(js, "write failed for %s: %s", str, strerror(errno));
+      JS_FreeCString(js, str);
+      return ret;
+    }
+
     JS_FreeCString(js, str);
     
-    if (written != (ssize_t)len) 
-      return JS_ThrowInternalError(js, "write failed for %s: %s", str, strerror(errno));
-    
     return JS_NULL;
 )
 
@@ -598,7 +602,7 @@ static void visit_directory(JSContext *js, JSValue results, int *result_count, c
             } else {
                 strcpy(item_rel, ffd.cFileName);
             }
-            JS_SetPropertyUint32(js, results, (*result_count)++, JS_NewString(js, item_rel));
+            JS_SetPropertyNumber(js, results, (*result_count)++, JS_NewString(js, item_rel));
 
             if (recurse) {
                 struct stat st;
@@ -623,7 +627,7 @@ static void visit_directory(JSContext *js, JSValue results, int *result_count, c
             } else {
                 strcpy(item_rel, dir->d_name);
             }
-            JS_SetPropertyUint32(js, results, (*result_count)++, JS_NewString(js, item_rel));
+            JS_SetPropertyNumber(js, results, (*result_count)++, JS_NewString(js, item_rel));
 
             if (recurse) {
                 struct stat st;
@@ -664,17 +668,21 @@ JSC_CCALL(fd_realpath,
 #ifdef _WIN32
     char resolved[PATH_MAX];
     DWORD len = GetFullPathNameA(path, PATH_MAX, resolved, NULL);
-    JS_FreeCString(js, path);
     if (len == 0 || len >= PATH_MAX) {
-        return JS_ThrowInternalError(js, "realpath failed for %s: %s", path, strerror(errno));
+        JSValue err = JS_ThrowInternalError(js, "realpath failed for %s: %s", path, strerror(errno));
+        JS_FreeCString(js, path);
+        return err;
     }
+    JS_FreeCString(js, path);
     return JS_NewString(js, resolved);
 #else
     char *resolved = realpath(path, NULL);
-    JS_FreeCString(js, path);
     if (!resolved) {
-        return JS_ThrowInternalError(js, "realpath failed for %s: %s", path, strerror(errno));
+        JSValue err = JS_ThrowInternalError(js, "realpath failed for %s: %s", path, strerror(errno));
+        JS_FreeCString(js, path);
+        return err;
     }
+    JS_FreeCString(js, path);
     JSValue result = JS_NewString(js, resolved);
     free(resolved);
     return result;

fd.cm

@@ -1,4 +1,4 @@
-var fd = this
+var fd = native
 var wildstar = use('wildstar')
 
 function last_pos(str, sep) {
@@ -12,11 +12,11 @@ function last_pos(str, sep) {
 
 // Helper to join paths
 function join_paths(base, rel) {
-  base = replace(base, /\/+$/, "")
-  rel = replace(rel, /^\/+/, "")
-  if (!base) return rel
-  if (!rel) return base
-  return base + "/" + rel
+  var b = replace(base, /\/+$/, "")
+  var r = replace(rel, /^\/+/, "")
+  if (!b) return r
+  if (!r) return b
+  return b + "/" + r
 }
 
 fd.join_paths = join_paths
@@ -39,7 +39,8 @@ fd.stem = function stem(path) {
 }
 
 fd.globfs = function(globs, dir) {
-  if (dir == null) dir = "."
+  var _dir = dir
+  if (_dir == null) _dir = "."
   var results = []
   
   function check_neg(path) {
@@ -88,9 +89,9 @@ fd.globfs = function(globs, dir) {
     });
   }
   
-  var st = fd.stat(dir)
+  var st = fd.stat(_dir)
   if (st && st.isDirectory) {
-    visit(dir, "")
+    visit(_dir, "")
   }
   
   return results

fd_playdate.c

@@ -324,7 +324,7 @@ static void listfiles_cb(const char *path, void *userdata) {
     // Playdate listfiles returns just the name, but sometimes with slash for dir?
     // Docs say "names of files".
     
-    JS_SetPropertyUint32(ctx->js, ctx->array, ctx->index++, JS_NewString(ctx->js, path));
+    JS_SetPropertyNumber(ctx->js, ctx->array, ctx->index++, JS_NewString(ctx->js, path));
 }
 
 JSC_SCALL(fd_readdir,
@@ -427,7 +427,7 @@ static void enum_cb(const char *name, void *userdata) {
         strcpy(item_rel, name);
     }
     
-    JS_SetPropertyUint32(ctx->js, ctx->results, (*ctx->count)++, JS_NewString(ctx->js, item_rel));
+    JS_SetPropertyNumber(ctx->js, ctx->results, (*ctx->count)++, JS_NewString(ctx->js, item_rel));
     
     if (ctx->recurse) {
         // Check if directory

fold.ce

@@ -0,0 +1,13 @@
+var fd = use("fd")
+var json = use("json")
+
+var filename = args[0]
+var src = text(fd.slurp(filename))
+var tokenize = use("tokenize")
+var parse = use("parse")
+var fold = use("fold")
+
+var tok_result = tokenize(src, filename)
+var ast = parse(tok_result.tokens, src, filename, tokenize)
+var folded = fold(ast)
+print(json.encode(folded))

fuzz.ce

@@ -0,0 +1,278 @@
+// fuzz.ce — fuzzer driver: generates random programs, runs differential, saves failures
+//
+// Usage:
+//   cell fuzz                - run 100 iterations with a random seed
+//   cell fuzz 500            - run 500 iterations with a random seed
+//   cell fuzz --seed 42      - run 100 iterations starting at seed 42
+//   cell fuzz 500 --seed 42  - run 500 iterations starting at seed 42
+//
+// Each iteration generates a random self-checking program, compiles it,
+// runs it through both optimized and unoptimized paths, and compares results.
+// Failures are saved to tests/fuzz_failures/ for reproduction.
+var fd = use('fd')
+var time = use('time')
+var json = use('json')
+
+var os_ref = use('os')
+var analyze = os_ref.analyze
+var run_ast_fn = os_ref.run_ast_fn
+var run_ast_noopt_fn = os_ref.run_ast_noopt_fn
+
+var fuzzgen = use('fuzzgen')
+
+var _args = args == null ? [] : args
+
+// Parse arguments: fuzz [iterations] [--seed N]
+var iterations = 100
+var start_seed = null
+var i = 0
+var n = null
+var run_err = null
+var _run_one = null
+
+while (i < length(_args)) {
+  if (_args[i] == '--seed' && i + 1 < length(_args)) {
+    start_seed = number(_args[i + 1])
+    i = i + 2
+  } else {
+    n = number(_args[i])
+    if (n != null && n > 0) iterations = n
+    i = i + 1
+  }
+}
+
+if (start_seed == null) {
+  start_seed = floor(time.number() * 1000) % 1000000
+}
+
+if (!run_ast_noopt_fn) {
+  log.console("error: run_ast_noopt_fn not available (rebuild bootstrap)")
+  $stop()
+  return
+}
+
+// Ensure failures directory exists
+var failures_dir = "tests/fuzz_failures"
+
+function ensure_dir(path) {
+  if (fd.is_dir(path)) return
+  var parts = array(path, '/')
+  var current = ''
+  var j = 0
+  while (j < length(parts)) {
+    if (parts[j] != '') {
+      current = current + parts[j] + '/'
+      if (!fd.is_dir(current)) {
+        fd.mkdir(current)
+      }
+    }
+    j = j + 1
+  }
+}
+
+// Deep comparison
+function values_equal(a, b) {
+  var j = 0
+  if (a == b) return true
+  if (is_null(a) && is_null(b)) return true
+  if (is_null(a) || is_null(b)) return false
+  if (is_array(a) && is_array(b)) {
+    if (length(a) != length(b)) return false
+    j = 0
+    while (j < length(a)) {
+      if (!values_equal(a[j], b[j])) return false
+      j = j + 1
+    }
+    return true
+  }
+  return false
+}
+
+function describe(val) {
+  if (is_null(val)) return "null"
+  if (is_text(val)) return `"${val}"`
+  if (is_number(val)) return text(val)
+  if (is_logical(val)) return text(val)
+  if (is_function(val)) return "<function>"
+  return "<other>"
+}
+
+// Run a single fuzz iteration
+function run_fuzz(seed_val) {
+  var src = fuzzgen.generate(seed_val)
+  var name = "fuzz_" + text(seed_val)
+  var ast = null
+  var mod_opt = null
+  var mod_noopt = null
+  var opt_err = null
+  var noopt_err = null
+  var errors = []
+  var keys = null
+  var k = 0
+  var key = null
+  var ret = null
+  var _run = null
+  var run_err = null
+  var keys2 = null
+  var k2 = 0
+  var key2 = null
+  var opt_result = null
+  var noopt_result = null
+  var opt_fn_err = null
+  var noopt_fn_err = null
+  var _run_opt = null
+  var _run_noopt = null
+
+  // Parse
+  var _parse = function() {
+    ast = analyze(src, name + ".cm")
+  } disruption {
+    push(errors, "parse error")
+  }
+  _parse()
+  if (length(errors) > 0) return {seed: seed_val, errors: errors, src: src}
+
+  // Run optimized
+  var _opt = function() {
+    mod_opt = run_ast_fn(name, ast, {use: function(p) { return use(p) }})
+  } disruption {
+    opt_err = "disrupted"
+  }
+  _opt()
+
+  // Run unoptimized
+  var _noopt = function() {
+    mod_noopt = run_ast_noopt_fn(name + "_noopt", ast, {use: function(p) { return use(p) }})
+  } disruption {
+    noopt_err = "disrupted"
+  }
+  _noopt()
+
+  // Check module-level behavior
+  if (opt_err != noopt_err) {
+    push(errors, `module load: opt=${opt_err != null ? opt_err : "ok"} noopt=${noopt_err != null ? noopt_err : "ok"}`)
+    return {seed: seed_val, errors: errors, src: src}
+  }
+  if (opt_err != null) {
+    // Both failed to load — consistent
+    return {seed: seed_val, errors: errors, src: src}
+  }
+
+  // Run self-checks (optimized module)
+  if (is_object(mod_opt)) {
+    keys = array(mod_opt)
+    k = 0
+    while (k < length(keys)) {
+      key = keys[k]
+      if (is_function(mod_opt[key])) {
+        ret = null
+        run_err = null
+        _run = function() {
+          ret = mod_opt[key]()
+        } disruption {
+          run_err = "disrupted"
+        }
+        _run()
+
+        if (is_text(ret)) {
+          push(errors, `self-check ${key}: ${ret}`)
+        }
+        if (run_err != null) {
+          push(errors, `self-check ${key}: unexpected disruption`)
+        }
+      }
+      k = k + 1
+    }
+  }
+
+  // Differential check on each function
+  if (is_object(mod_opt) && is_object(mod_noopt)) {
+    keys2 = array(mod_opt)
+    k2 = 0
+    while (k2 < length(keys2)) {
+      key2 = keys2[k2]
+      if (is_function(mod_opt[key2]) && is_function(mod_noopt[key2])) {
+        opt_result = null
+        noopt_result = null
+        opt_fn_err = null
+        noopt_fn_err = null
+
+        _run_opt = function() {
+          opt_result = mod_opt[key2]()
+        } disruption {
+          opt_fn_err = "disrupted"
+        }
+        _run_opt()
+
+        _run_noopt = function() {
+          noopt_result = mod_noopt[key2]()
+        } disruption {
+          noopt_fn_err = "disrupted"
+        }
+        _run_noopt()
+
+        if (opt_fn_err != noopt_fn_err) {
+          push(errors, `diff ${key2}: opt=${opt_fn_err != null ? opt_fn_err : "ok"} noopt=${noopt_fn_err != null ? noopt_fn_err : "ok"}`)
+        } else if (!values_equal(opt_result, noopt_result)) {
+          push(errors, `diff ${key2}: opt=${describe(opt_result)} noopt=${describe(noopt_result)}`)
+        }
+      }
+      k2 = k2 + 1
+    }
+  }
+
+  return {seed: seed_val, errors: errors, src: src}
+}
+
+// Main loop
+log.console(`Fuzzing: ${text(iterations)} iterations, starting seed=${text(start_seed)}`)
+var total_pass = 0
+var total_fail = 0
+var result = null
+var j = 0
+var current_seed = 0
+var fail_path = null
+
+i = 0
+while (i < iterations) {
+  current_seed = start_seed + i
+  run_err = null
+  _run_one = function() {
+    result = run_fuzz(current_seed)
+  } disruption {
+    run_err = "generator crashed"
+  }
+  _run_one()
+
+  if (run_err != null) {
+    result = {seed: current_seed, errors: [run_err], src: "// generator crashed"}
+  }
+
+  if (length(result.errors) > 0) {
+    total_fail = total_fail + 1
+    log.console(`  FAIL seed=${text(current_seed)}: ${result.errors[0]}`)
+
+    // Save failure source for reproduction
+    ensure_dir(failures_dir)
+    fail_path = failures_dir + "/seed_" + text(current_seed) + ".cm"
+    fd.slurpwrite(fail_path, stone(blob(result.src)))
+    log.console(`    saved to ${fail_path}`)
+  } else {
+    total_pass = total_pass + 1
+  }
+
+  // Progress report every 100 iterations
+  if ((i + 1) % 100 == 0) {
+    log.console(`  progress: ${text(i + 1)}/${text(iterations)} (${text(total_pass)} passed, ${text(total_fail)} failed)`)
+  }
+
+  i = i + 1
+}
+
+log.console(`----------------------------------------`)
+log.console(`Fuzz: ${text(total_pass)} passed, ${text(total_fail)} failed, ${text(iterations)} total`)
+if (total_fail > 0) {
+  log.console(`Failures saved to ${failures_dir}/`)
+}
+
+$stop()

fuzzgen.cm

@@ -0,0 +1,348 @@
+// fuzzgen.cm — generates self-checking .cm programs for fuzz testing
+// Each generated program returns a record of test functions that
+// validate their own expected results.
+
+// Newline constant — backtick strings don't interpret \n as escape
+var NL = "\n"
+
+// Simple seeded PRNG (xorshift32)
+var _seed = 1
+function seed(s) {
+  _seed = s != 0 ? s : 1
+}
+
+function rand() {
+  _seed = _seed ^ (_seed << 13)
+  _seed = _seed ^ (_seed >> 17)
+  _seed = _seed ^ (_seed << 5)
+  if (_seed < 0) _seed = -_seed
+  return _seed
+}
+
+function rand_int(lo, hi) {
+  return lo + (rand() % (hi - lo + 1))
+}
+
+function rand_float() {
+  return rand_int(-10000, 10000) / 100
+}
+
+function rand_bool() {
+  return rand() % 2 == 0
+}
+
+function pick(arr) {
+  return arr[rand() % length(arr)]
+}
+
+// Expression generators — each returns {src: "code", val: expected_value}
+// depth is decremented to prevent infinite recursion
+
+function gen_int_literal() {
+  var v = rand_int(-10000, 10000)
+  return {src: text(v), val: v}
+}
+
+function gen_float_literal() {
+  var v = rand_float()
+  return {src: text(v), val: v}
+}
+
+function gen_bool_literal() {
+  var v = rand_bool()
+  var s = "false"
+  if (v) s = "true"
+  return {src: s, val: v}
+}
+
+function gen_text_literal() {
+  var words = ["alpha", "beta", "gamma", "delta", "epsilon"]
+  var w = pick(words)
+  return {src: `"${w}"`, val: w}
+}
+
+function gen_null_literal() {
+  return {src: "null", val: null}
+}
+
+function gen_int_expr(depth) {
+  var a = null
+  var b = null
+  var op = null
+  var result = null
+
+  if (depth <= 0) return gen_int_literal()
+
+  a = gen_int_expr(depth - 1)
+  b = gen_int_expr(depth - 1)
+
+  // Avoid division by zero
+  if (b.val == 0) b = {src: "1", val: 1}
+
+  op = pick(["+", "-", "*"])
+  if (op == "+") {
+    result = a.val + b.val
+  } else if (op == "-") {
+    result = a.val - b.val
+  } else {
+    result = a.val * b.val
+  }
+
+  // Guard against overflow beyond safe integer range
+  if (result > 9007199254740991 || result < -9007199254740991) {
+    return gen_int_literal()
+  }
+
+  return {src: `(${a.src} ${op} ${b.src})`, val: result}
+}
+
+function gen_float_expr(depth) {
+  var a = null
+  var b = null
+  var op = null
+  var result = null
+
+  if (depth <= 0) return gen_float_literal()
+
+  a = gen_float_expr(depth - 1)
+  b = gen_float_expr(depth - 1)
+
+  if (b.val == 0) b = {src: "1.0", val: 1.0}
+
+  op = pick(["+", "-", "*"])
+  if (op == "+") {
+    result = a.val + b.val
+  } else if (op == "-") {
+    result = a.val - b.val
+  } else {
+    result = a.val * b.val
+  }
+
+  return {src: `(${a.src} ${op} ${b.src})`, val: result}
+}
+
+function gen_text_expr(depth) {
+  var a = null
+  var b = null
+
+  if (depth <= 0) return gen_text_literal()
+
+  a = gen_text_literal()
+  b = gen_text_literal()
+
+  return {src: `(${a.src} + ${b.src})`, val: a.val + b.val}
+}
+
+function gen_comparison_expr(depth) {
+  var a = null
+  var b = null
+  var op = null
+  var result = null
+
+  a = gen_int_expr(depth > 0 ? depth - 1 : 0)
+  b = gen_int_expr(depth > 0 ? depth - 1 : 0)
+
+  op = pick(["==", "!=", "<", ">", "<=", ">="])
+  if (op == "==") {
+    result = a.val == b.val
+  } else if (op == "!=") {
+    result = a.val != b.val
+  } else if (op == "<") {
+    result = a.val < b.val
+  } else if (op == ">") {
+    result = a.val > b.val
+  } else if (op == "<=") {
+    result = a.val <= b.val
+  } else {
+    result = a.val >= b.val
+  }
+
+  return {src: `(${a.src} ${op} ${b.src})`, val: result}
+}
+
+// Generate an if-else expression test
+function gen_if_else_test() {
+  var cond = gen_comparison_expr(1)
+  var then_val = gen_int_literal()
+  var else_val = gen_int_literal()
+  var expected = cond.val ? then_val.val : else_val.val
+
+  var body = "var result = null" + NL
+  body = body + "    if (" + cond.src + ") {" + NL
+  body = body + "      result = " + then_val.src + NL
+  body = body + "    } else {" + NL
+  body = body + "      result = " + else_val.src + NL
+  body = body + "    }" + NL
+  body = body + "    if (result != " + text(expected) + ") return \"if_else: expected " + text(expected) + " got \" + text(result)"
+
+  return body
+}
+
+// Generate a loop accumulator test
+function gen_loop_test() {
+  var count = rand_int(1, 50)
+  var step = rand_int(1, 10)
+  var expected = 0
+  var i = 0
+  while (i < count) {
+    expected = expected + step
+    i = i + 1
+  }
+
+  var body = "var acc = 0" + NL
+  body = body + "    var i = 0" + NL
+  body = body + "    while (i < " + text(count) + ") {" + NL
+  body = body + "      acc = acc + " + text(step) + NL
+  body = body + "      i = i + 1" + NL
+  body = body + "    }" + NL
+  body = body + "    if (acc != " + text(expected) + ") return \"loop: expected " + text(expected) + " got \" + text(acc)"
+
+  return body
+}
+
+// Generate a closure test
+function gen_closure_test() {
+  var init_val = rand_int(1, 100)
+  var inc = rand_int(1, 10)
+  var calls = rand_int(1, 10)
+  var expected = init_val + (inc * calls)
+
+  var body = "var counter = " + text(init_val) + NL
+  body = body + "    var inc = function() { counter = counter + " + text(inc) + " }" + NL
+  body = body + "    var i = 0" + NL
+  body = body + "    while (i < " + text(calls) + ") {" + NL
+  body = body + "      inc()" + NL
+  body = body + "      i = i + 1" + NL
+  body = body + "    }" + NL
+  body = body + "    if (counter != " + text(expected) + ") return \"closure: expected " + text(expected) + " got \" + text(counter)"
+
+  return body
+}
+
+// Generate a record property test
+function gen_record_test() {
+  var a = gen_int_literal()
+  var b = gen_int_literal()
+  var sum = a.val + b.val
+
+  var body = "var r = {a: " + a.src + ", b: " + b.src + "}" + NL
+  body = body + "    var result = r.a + r.b" + NL
+  body = body + "    if (result != " + text(sum) + ") return \"record: expected " + text(sum) + " got \" + text(result)"
+
+  return body
+}
+
+// Generate an array test
+function gen_array_test() {
+  var n = rand_int(2, 10)
+  var vals = []
+  var i = 0
+  var sum = 0
+  var v = 0
+  while (i < n) {
+    v = rand_int(-100, 100)
+    push(vals, v)
+    sum = sum + v
+    i = i + 1
+  }
+
+  var val_strs = []
+  i = 0
+  while (i < n) {
+    push(val_strs, text(vals[i]))
+    i = i + 1
+  }
+
+  var body = "var a = [" + text(val_strs, ", ") + "]" + NL
+  body = body + "    var _sum = 0" + NL
+  body = body + "    var i = 0" + NL
+  body = body + "    while (i < length(a)) {" + NL
+  body = body + "      _sum = _sum + a[i]" + NL
+  body = body + "      i = i + 1" + NL
+  body = body + "    }" + NL
+  body = body + "    if (_sum != " + text(sum) + ") return \"array_sum: expected " + text(sum) + " got \" + text(_sum)"
+
+  return body
+}
+
+// Generate a nested function / higher-order test
+function gen_higher_order_test() {
+  var mul = rand_int(2, 10)
+  var input = rand_int(1, 100)
+  var expected = input * mul
+
+  var body = "var make_mul = function(m) {" + NL
+  body = body + "      return function(x) { return x * m }" + NL
+  body = body + "    }" + NL
+  body = body + "    var fn = make_mul(" + text(mul) + ")" + NL
+  body = body + "    var result = fn(" + text(input) + ")" + NL
+  body = body + "    if (result != " + text(expected) + ") return \"higher_order: expected " + text(expected) + " got \" + text(result)"
+
+  return body
+}
+
+// Generate a disruption handling test
+function gen_disrupt_test() {
+  var body = "var caught = false" + NL
+  body = body + "    var _fn = function() { disrupt } disruption { caught = true }" + NL
+  body = body + "    _fn()" + NL
+  body = body + "    if (!caught) return \"disrupt: expected to catch disruption\""
+
+  return body
+}
+
+// Generate a text operation test
+function gen_text_op_test() {
+  var words = ["hello", "world", "foo", "bar", "baz"]
+  var w1 = pick(words)
+  var w2 = pick(words)
+  var expected = w1 + w2
+
+  var body = "var a = \"" + w1 + "\"" + NL
+  body = body + "    var b = \"" + w2 + "\"" + NL
+  body = body + "    var c = a + b" + NL
+  body = body + "    if (c != \"" + expected + "\") return \"text_op: expected " + expected + " got \" + c"
+
+  return body
+}
+
+// All generators
+var generators = [
+  gen_if_else_test,
+  gen_loop_test,
+  gen_closure_test,
+  gen_record_test,
+  gen_array_test,
+  gen_higher_order_test,
+  gen_disrupt_test,
+  gen_text_op_test
+]
+
+// Generate a complete self-checking .cm program
+function generate(s) {
+  seed(s)
+
+  var num_tests = rand_int(5, 15)
+  var src = "// Auto-generated fuzz test (seed=" + text(s) + ")\nreturn {\n"
+  var i = 0
+  var gen = null
+  var body = null
+
+  while (i < num_tests) {
+    gen = pick(generators)
+    body = gen()
+    if (i > 0) src = src + ",\n"
+    src = src + "  fuzz_" + text(i) + ": function() {\n"
+    src = src + "    " + body + "\n"
+    src = src + "  }"
+    i = i + 1
+  }
+
+  src = src + "\n}\n"
+  return src
+}
+
+return {
+  generate: generate,
+  seed: seed
+}

internal/bootstrap.cm

@@ -0,0 +1,310 @@
+// Hidden vars come from env:
+//   CLI mode (cell_init):       os, args, core_path, shop_path
+//   Actor spawn (script_startup): os, json, nota, wota, actorsym, init, core_path, shop_path
+// args[0] = script name, args[1..] = user args
+var load_internal = os.load_internal
+function use_embed(name) {
+  return load_internal("js_" + name + "_use")
+}
+
+var fd = use_embed('fd')
+var json = use_embed('json')
+
+var use_cache = {}
+use_cache['fd'] = fd
+use_cache['os'] = os
+use_cache['json'] = json
+
+// Bootstrap: load tokenize.cm, parse.cm, fold.cm from pre-compiled mach bytecode
+function use_basic(path) {
+  if (use_cache[path])
+    return use_cache[path]
+  var result = use_embed(replace(path, '/', '_'))
+  use_cache[path] = result
+  return result
+}
+
+// Load a module from .mach/.mcode bytecode (bootstrap modules have no source fallback)
+function boot_load(name, env) {
+  var mach_path = core_path + '/' + name + ".cm.mach"
+  var mcode_path = core_path + '/' + name + ".cm.mcode"
+  var data = null
+  var mcode_json = null
+  if (fd.is_file(mach_path)) {
+    data = fd.slurp(mach_path)
+    return mach_load(data, env)
+  }
+  if (fd.is_file(mcode_path)) {
+    mcode_json = text(fd.slurp(mcode_path))
+    return mach_eval_mcode(name, mcode_json, env)
+  }
+  print("error: missing bootstrap bytecode: " + name + "\n")
+  disrupt
+}
+
+var boot_env = {use: use_basic}
+var tokenize_mod = boot_load("tokenize", boot_env)
+var parse_mod = boot_load("parse", boot_env)
+var fold_mod = boot_load("fold", boot_env)
+use_cache['tokenize'] = tokenize_mod
+use_cache['parse'] = parse_mod
+use_cache['fold'] = fold_mod
+
+// Always load mcode compiler module
+var mcode_mod = boot_load("mcode", boot_env)
+use_cache['mcode'] = mcode_mod
+var streamline_mod = null
+
+// Warn if any .cm source is newer than its compiled bytecode
+function check_mach_stale() {
+  var sources = [
+    "tokenize.cm",
+    "parse.cm",
+    "fold.cm",
+    "mcode.cm",
+    "streamline.cm",
+    "qbe.cm",
+    "qbe_emit.cm",
+    "internal/bootstrap.cm",
+    "internal/engine.cm"
+  ]
+  var stale = []
+  var _i = 0
+  var cm_path = null
+  var mach_path = null
+  var mcode_path = null
+  var cm_stat = null
+  var compiled_stat = null
+  var best_mtime = null
+  while (_i < length(sources)) {
+    cm_path = core_path + '/' + sources[_i]
+    mach_path = cm_path + '.mach'
+    mcode_path = cm_path + '.mcode'
+    best_mtime = null
+    if (fd.is_file(mach_path)) {
+      best_mtime = fd.stat(mach_path).mtime
+    }
+    if (fd.is_file(mcode_path)) {
+      compiled_stat = fd.stat(mcode_path)
+      if (best_mtime == null || compiled_stat.mtime > best_mtime) {
+        best_mtime = compiled_stat.mtime
+      }
+    }
+    if (best_mtime != null && fd.is_file(cm_path)) {
+      cm_stat = fd.stat(cm_path)
+      if (cm_stat.mtime > best_mtime) {
+        push(stale, sources[_i])
+      }
+    }
+    _i = _i + 1
+  }
+  if (length(stale) > 0) {
+    print("warning: bytecode is stale for: " + text(stale, ", ") + "\n")
+    print("run 'make regen' to update\n")
+  }
+}
+check_mach_stale()
+
+// analyze: tokenize + parse, check for errors
+function analyze(src, filename) {
+  var tok_result = tokenize_mod(src, filename)
+  var ast = parse_mod(tok_result.tokens, src, filename, tokenize_mod)
+  var _i = 0
+  var prev_line = -1
+  var prev_msg = null
+  var e = null
+  var msg = null
+  var line = null
+  var col = null
+  var has_errors = ast.errors != null && length(ast.errors) > 0
+  if (has_errors) {
+    while (_i < length(ast.errors)) {
+      e = ast.errors[_i]
+      msg = e.message
+      line = e.line
+      col = e.column
+      if (msg != prev_msg || line != prev_line) {
+        if (line != null && col != null) {
+          print(`${filename}:${text(line)}:${text(col)}: error: ${msg}`)
+        } else {
+          print(`${filename}: error: ${msg}`)
+        }
+      }
+      prev_line = line
+      prev_msg = msg
+      _i = _i + 1
+    }
+    disrupt
+  }
+  ast = fold_mod(ast)
+  return ast
+}
+
+// Load a module from .mach/.mcode bytecode, falling back to source compilation
+function load_module(name, env) {
+  var mach_path = core_path + '/' + name + ".cm.mach"
+  var mcode_path = core_path + '/' + name + ".cm.mcode"
+  var data = null
+  var mcode_json = null
+  var src_path = null
+  var src = null
+  var ast = null
+  var compiled = null
+  var optimized = null
+  if (fd.is_file(mach_path)) {
+    data = fd.slurp(mach_path)
+    return mach_load(data, env)
+  }
+  if (fd.is_file(mcode_path)) {
+    mcode_json = text(fd.slurp(mcode_path))
+    return mach_eval_mcode(name, mcode_json, env)
+  }
+  src_path = core_path + '/' + name + ".cm"
+  src = text(fd.slurp(src_path))
+  ast = analyze(src, src_path)
+  compiled = mcode_mod(ast)
+  optimized = streamline_mod(compiled)
+  return mach_eval_mcode(name, json.encode(optimized), env)
+}
+
+// Load optimization pipeline modules (needs analyze to be defined)
+streamline_mod = load_module("streamline", boot_env)
+use_cache['streamline'] = streamline_mod
+
+// Lazy-loaded verify_ir module (loaded on first use via use_fn)
+var _verify_ir_mod = null
+
+// Run AST through mcode pipeline → register VM
+function run_ast(name, ast, env) {
+  var compiled = mcode_mod(ast)
+  if (os._verify_ir) {
+    if (_verify_ir_mod == null) {
+      _verify_ir_mod = use_fn('verify_ir')
+    }
+    compiled._verify = true
+    compiled._verify_mod = _verify_ir_mod
+  }
+  var optimized = streamline_mod(compiled)
+  // Clean up verify properties before JSON encoding
+  if (optimized._verify) {
+    delete optimized._verify
+    delete optimized._verify_mod
+  }
+  return mach_eval_mcode(name, json.encode(optimized), env)
+}
+
+// Run AST through mcode pipeline WITHOUT optimization → register VM
+function run_ast_noopt(name, ast, env) {
+  var compiled = mcode_mod(ast)
+  return mach_eval_mcode(name, json.encode(compiled), env)
+}
+
+// use() with ƿit pipeline for .cm modules
+function use_fn(path) {
+  var file_path = null
+  var mach_path = null
+  var mcode_path = null
+  var mcode_json = null
+  var data = null
+  var script = null
+  var ast = null
+  var result = null
+  if (use_cache[path])
+    return use_cache[path]
+
+  // Try .cm.mach bytecode first (CWD then core_path)
+  mach_path = path + '.cm.mach'
+  if (!fd.is_file(mach_path))
+    mach_path = core_path + '/' + path + '.cm.mach'
+  if (fd.is_file(mach_path)) {
+    data = fd.slurp(mach_path)
+    result = mach_load(data, {use: use_fn})
+    use_cache[path] = result
+    return result
+  }
+
+  // Try .cm.mcode JSON IR (CWD then core_path)
+  mcode_path = path + '.cm.mcode'
+  if (!fd.is_file(mcode_path))
+    mcode_path = core_path + '/' + path + '.cm.mcode'
+  if (fd.is_file(mcode_path)) {
+    mcode_json = text(fd.slurp(mcode_path))
+    result = mach_eval_mcode(path, mcode_json, {use: use_fn})
+    use_cache[path] = result
+    return result
+  }
+
+  // Try .cm source (CWD then core_path)
+  file_path = path + '.cm'
+  if (!fd.is_file(file_path))
+    file_path = core_path + '/' + path + '.cm'
+
+  if (fd.is_file(file_path)) {
+    script = text(fd.slurp(file_path))
+    ast = analyze(script, file_path)
+    result = run_ast(path, ast, {use: use_fn})
+    use_cache[path] = result
+    return result
+  }
+
+  // Fallback to embedded C module
+  result = use_embed(replace(path, '/', '_'))
+  use_cache[path] = result
+  return result
+}
+
+// Helper to load engine.cm and run it with given env
+function load_engine(env) {
+  var engine_path = core_path + '/internal/engine.cm.mach'
+  var mcode_path = core_path + '/internal/engine.cm.mcode'
+  var data = null
+  var mcode_json = null
+  var engine_src = null
+  var engine_ast = null
+  if (fd.is_file(engine_path)) {
+    data = fd.slurp(engine_path)
+    return mach_load(data, env)
+  }
+  if (fd.is_file(mcode_path)) {
+    mcode_json = text(fd.slurp(mcode_path))
+    return mach_eval_mcode('engine', mcode_json, env)
+  }
+  engine_path = core_path + '/internal/engine.cm'
+  engine_src = text(fd.slurp(engine_path))
+  engine_ast = analyze(engine_src, engine_path)
+  return run_ast('engine', engine_ast, env)
+}
+
+// Detect mode and route
+// CLI mode has 'args'; actor spawn mode has 'init'
+var program = null
+var user_args = []
+var _j = 0
+
+if (args != null) {
+  // CLI mode — always run as actor program (.ce)
+  program = args[0]
+  if (!program) {
+    print("error: no program specified\n")
+    disrupt
+  }
+  _j = 1
+  while (_j < length(args)) {
+    push(user_args, args[_j])
+    _j = _j + 1
+  }
+
+  load_engine({
+    os: os, actorsym: actorsym,
+    init: {program: program, arg: user_args},
+    core_path: core_path, shop_path: shop_path, json: json,
+    analyze: analyze, run_ast_fn: run_ast, run_ast_noopt_fn: run_ast_noopt
+  })
+} else {
+  // Actor spawn mode — load engine.cm with full actor env
+  load_engine({
+    os: os, actorsym: actorsym, init: init,
+    core_path: core_path, shop_path: shop_path, json: json, nota: nota, wota: wota,
+    analyze: analyze, run_ast_fn: run_ast, run_ast_noopt_fn: run_ast_noopt
+  })
+}

internal/engine.cm

@@ -1,17 +1,18 @@
-(function engine() {
-// Hidden vars (os, actorsym, init, core_path) come from env
+// Hidden vars (os, actorsym, init, core_path, shop_path, analyze, run_ast_fn, run_ast_noopt_fn, json) come from env
+// In actor spawn mode, also: nota, wota
 var ACTORDATA = actorsym
 var SYSYM = '__SYSTEM__'
 
 var _cell = {}
+var need_stop = false
 
-var dylib_ext
+var cases = {
+  Windows: '.dll',
+  macOS: '.dylib',
+  Linux: '.so'
+}
 
-switch(os.platform()) {
-  case 'Windows': dylib_ext = '.dll'; break;
-  case 'macOS': dylib_ext = '.dylib'; break;
-  case 'Linux': dylib_ext = '.so'; break;
-} 
+var dylib_ext = cases[os.platform()]
 
 var MOD_EXT = '.cm'
 var ACTOR_EXT = '.ce'  
@@ -45,50 +46,70 @@ function ends_with(str, suffix) {
   return search(str, suffix, -length(suffix)) != null
 }
 
-var js = use_embed('js')
 var fd = use_embed('fd')
+var js = use_embed('js')
 
-// Get the shop path from HOME environment
-var home = os.getenv('HOME') || os.getenv('USERPROFILE')
-if (!home) {
-  throw Error('Could not determine home directory')
-}
-var shop_path = home + '/.cell'
-var packages_path = shop_path + '/packages'
-var core_path = packages_path + '/core'
-
-if (!fd.is_dir(core_path)) {
-  throw Error('Cell shop not found at ' + shop_path + '. Run "cell install" to set up.')
-}
+// core_path and shop_path come from env (bootstrap.cm passes them through)
+// shop_path may be null if --core was used without --shop
+var packages_path = shop_path ? shop_path + '/packages' : null
 
 var use_cache = {}
 use_cache['core/os'] = os
 
+// Extra env properties added as engine initializes (log, runtime fns, etc.)
+var core_extras = {}
+
 // Load a core module from the file system
 function use_core(path) {
   var cache_key = 'core/' + path
+  var env = null
   if (use_cache[cache_key])
-    return use_cache[cache_key];
+    return use_cache[cache_key]
 
   var sym = use_embed(replace(path, '/', '_'))
+  var result = null
+  var script = null
+  var ast = null
 
-  // Core scripts are in packages/core/
-  var file_path = core_path + '/' + path + MOD_EXT
+  // Build env: merge core_extras, include C embed as 'native' if available
+  env = {use: use_core}
+  arrfor(array(core_extras), function(k) { env[k] = core_extras[k] })
+  if (sym) env.native = sym
 
-  if (fd.is_file(file_path)) {
-    var script_blob = fd.slurp(file_path)
-    var script = text(script_blob)
-    var mod = `(function setup_module(use){${script}})`
-    var fn = js.eval('core:' + path, mod)
-    var result = call(fn,sym, [use_core])
-    use_cache[cache_key] = result;
-    return result;
+  // Check for pre-compiled .cm.mach file first
+  var mach_path = core_path + '/' + path + '.cm.mach'
+  if (fd.is_file(mach_path)) {
+    result = mach_load(fd.slurp(mach_path), env)
+    use_cache[cache_key] = result
+    return result
   }
 
-  use_cache[cache_key] = sym;
-  return sym;
+  // Check for .cm.mcode JSON IR
+  var mcode_path = core_path + '/' + path + '.cm.mcode'
+  if (fd.is_file(mcode_path)) {
+    result = mach_eval_mcode('core:' + path, text(fd.slurp(mcode_path)), env)
+    use_cache[cache_key] = result
+    return result
+  }
+
+  // Fall back to source .cm file — compile at runtime
+  var file_path = core_path + '/' + path + MOD_EXT
+  if (fd.is_file(file_path)) {
+    script = text(fd.slurp(file_path))
+    ast = analyze(script, file_path)
+    result = run_ast_fn('core:' + path, ast, env)
+    use_cache[cache_key] = result
+    return result
+  }
+
+  // Embedded C module only
+  use_cache[cache_key] = sym
+  return sym
 }
 
+// Load full modules via use_core (extends C embeds with .cm additions, and caches)
+fd = use_core('fd')
+use_core('js')
 var blob = use_core('blob')
 
 function actor() {
@@ -106,22 +127,9 @@ function is_actor(value) {
 var ENETSERVICE = 0.1
 var REPLYTIMEOUT = 60 // seconds before replies are ignored
 
-function caller_data(depth = 0)
+function caller_data(depth)
 {
-  var file = "nofile"
-  var line = 0
-  
-  var caller = array(Error().stack, "\n")[1+depth]
-  if (caller) {
-    var md = extract(caller, /\((.*)\:/)
-    var m = md ? md[1] : "SCRIPT"
-    if (m) file = m
-    md = extract(caller, /\:(\d*)\)/)
-    m = md ? md[1] : 0
-    if (m) line = m
-  }
-  
-  return {file,line}
+  return {file: "nofile", line: 0}
 }
 
 function console_rec(line, file, msg) {
@@ -133,45 +141,41 @@ function log(name, args) {
   var caller = caller_data(1)
   var msg = args[0]
 
-  switch(name) {
-    case 'console':
-      os.print(console_rec(caller.line, caller.file, msg))
-      break
-    case 'error':
-      msg = msg ?? Error()
-      if (is_proto(msg, Error))
-        msg = msg.name + ": " + msg.message + "\n" + msg.stack
-      os.print(console_rec(caller.line, caller.file, msg))
-      break
-    case 'system':
-      msg = "[SYSTEM] " + msg
-      os.print(console_rec(caller.line, caller.file, msg))
-      break
-    default:
-      log.console(`unknown log type: ${name}`)
-      break
+  if (name == 'console') {
+    os.print(console_rec(caller.line, caller.file, msg))
+  } else if (name == 'error') {
+    if (msg == null) msg = "error"
+    os.print(console_rec(caller.line, caller.file, msg))
+  } else if (name == 'system') {
+    msg = "[SYSTEM] " + msg
+    os.print(console_rec(caller.line, caller.file, msg))
+  } else {
+    log.console(`unknown log type: ${name}`)
   }
 }
 
-function disrupt(err)
+function actor_die(err)
 {
-  if (is_function(err.toString)) {
-  os.print(err.toString())
-  os.print("\n")
-  os.print(err.stack)
+  var reason = null
+  var unders = null
+
+  if (err && is_function(err.toString)) {
+    os.print(err.toString())
+    os.print("\n")
+    if (err.stack) os.print(err.stack)
   }
 
   if (overling) {
     if (err) {
       // with an err, this is a forceful disrupt
-      var reason = (is_proto(err, Error)) ? err.stack : err
+      reason = err
       report_to_overling({type:'disrupt', reason})
     } else
       report_to_overling({type:'stop'})
   }
 
   if (underlings) {
-    var unders = array(underlings)
+    unders = array(underlings)
     arrfor(unders, function(id, index) {
       log.console(`calling on ${id} to disrupt too`)
       $_.stop(create_actor({id}))
@@ -185,19 +189,20 @@ function disrupt(err)
       log.console(err.stack)
   }
 
-  actor_mod.disrupt()
+  actor_mod["disrupt"]()
 }
 
 
 
-actor_mod.on_exception(disrupt)
+//actor_mod.on_exception(actor_die)
 
-_cell.args = init ?? {}
+_cell.args = init != null ? init : {}
 _cell.id = "newguy"
 
-function create_actor(desc = {id:guid()}) {
+function create_actor(desc) {
+  var _desc = desc == null ? {id:guid()} : desc
   var actor = {}
-  actor[ACTORDATA] = desc
+  actor[ACTORDATA] = _desc
   return actor
 }
 
@@ -207,10 +212,13 @@ $_.self = create_actor()
 os.use_cache = use_cache
 os.global_shop_path = shop_path
 os.$_ = $_
+os.analyze = analyze
+os.run_ast_fn = run_ast_fn
+os.run_ast_noopt_fn = run_ast_noopt_fn
+os.json = json
+use_cache['core/json'] = json
 
 var shop = use_core('internal/shop')
-
-var json = use_core('json')
 var time = use_core('time')
 
 var pronto = use_core('pronto')
@@ -236,16 +244,23 @@ var runtime_env = {
   sequence: sequence
 }
 
+// Make runtime functions available to modules loaded via use_core
+arrfor(array(runtime_env), function(k) { core_extras[k] = runtime_env[k] })
+
 // Pass to os for shop to access
 os.runtime_env = runtime_env
 
 $_.time_limit = function(requestor, seconds)
 {
-  if (!pronto.is_requestor(requestor))
-    throw Error('time_limit: first argument must be a requestor');
-  if (!is_number(seconds) || seconds <= 0)
-    throw Error('time_limit: seconds must be a positive number');
-    
+  if (!pronto.is_requestor(requestor)) {
+    log.error('time_limit: first argument must be a requestor')
+    disrupt
+  }
+  if (!is_number(seconds) || seconds <= 0) {
+    log.error('time_limit: seconds must be a positive number')
+    disrupt
+  }
+
   return function time_limit_requestor(callback, value) {
     pronto.check_callback(callback, 'time_limit')
     var finished = false
@@ -260,7 +275,14 @@ $_.time_limit = function(requestor, seconds)
         timer_cancel = null
       }
       if (requestor_cancel) {
-        try { pronto.requestor_cancel(reason) } catch (_) {}
+        requestor_cancel(reason)
+        requestor_cancel = null
+      }
+    }
+
+    function safe_cancel_requestor(reason) {
+      if (requestor_cancel) {
+        requestor_cancel(reason)
         requestor_cancel = null
       }
     }
@@ -268,15 +290,12 @@ $_.time_limit = function(requestor, seconds)
     timer_cancel = $_.delay(function() {
       if (finished) return
       def reason = make_reason(factory, 'Timeout.', seconds)
-      if (requestor_cancel) {
-        try { requestor_cancel(reason) } catch (_) {}
-        requestor_cancel = null
-      }
+      safe_cancel_requestor(reason)
       finished = true
       callback(null, reason)
     }, seconds)
 
-        try {
+    function do_request() {
       requestor_cancel = requestor(function(val, reason) {
         if (finished) return
         finished = true
@@ -286,16 +305,14 @@ $_.time_limit = function(requestor, seconds)
         }
         callback(val, reason)
       }, value)
-    } catch (ex) {
-      cancel(ex)
-      callback(null, ex)
+    } disruption {
+      cancel('requestor failed')
+      callback(null, 'requestor failed')
     }
+    do_request()
 
     return function(reason) {
-      if (requestor_cancel) {
-        try { requestor_cancel(reason) } catch (_) {}
-        requestor_cancel = null
-      }
+      safe_cancel_requestor(reason)
     }
   }
 }
@@ -338,9 +355,10 @@ REPLYTIMEOUT = config.reply_timeout
   }
 */
 
-function guid(bits = 256)
+function guid(bits)
 {
-  var guid = blob(bits, os.random)
+  var _bits = bits == null ? 256 : bits
+  var guid = blob(_bits, os.random)
   stone(guid)
   return text(guid,'h')
 }
@@ -408,55 +426,61 @@ var portal_fn = null
 
 // takes a function input value that will eventually be called with the current time in number form.
 $_.portal = function(fn, port) {
-  if (portal) throw Error(`Already started a portal listening on ${portal.port}`)
-  if (!port) throw Error("Requires a valid port.")
+  if (portal) {
+    log.error(`Already started a portal listening on ${portal.port}`)
+    disrupt
+  }
+  if (!port) {
+    log.error("Requires a valid port.")
+    disrupt
+  }
   log.system(`starting a portal on port ${port}`)
   portal = enet.create_host({address: "any", port})
   portal_fn = fn
 }
 
 function handle_host(e) {
-  switch (e.type) {
-    case "connect":
-      log.system(`connected a new peer: ${e.peer.address}:${e.peer.port}`)
-      peers[`${e.peer.address}:${e.peer.port}`] = e.peer
-      var queue = peer_queue.get(e.peer)
-      if (queue) {
-        arrfor(queue, (msg, index) => e.peer.send(nota.encode(msg)))
-        log.system(`sent ${msg} out of queue`)
-        peer_queue.delete(e.peer)
-      }
-      break
-    case "disconnect":
+  var queue = null
+  var data = null
+
+  if (e.type == "connect") {
+    log.system(`connected a new peer: ${e.peer.address}:${e.peer.port}`)
+    peers[`${e.peer.address}:${e.peer.port}`] = e.peer
+    queue = peer_queue.get(e.peer)
+    if (queue) {
+      arrfor(queue, (msg, index) => e.peer.send(nota.encode(msg)))
+      log.system(`sent queue out of queue`)
       peer_queue.delete(e.peer)
-      arrfor(array(peers), function(id, index) {
-        if (peers[id] == e.peer) delete peers[id]
-      })
-      log.system('portal got disconnect from ' + e.peer.address + ":" + e.peer.port)
-      break
-    case "receive":
-      var data = nota.decode(e.data)
-      if (data.replycc && !data.replycc.address) {
-        data.replycc[ACTORDATA].address = e.peer.address
-        data.replycc[ACTORDATA].port = e.peer.port
-      }
-      function populate_actor_addresses(obj) {
-        if (!is_object(obj)) return
-        if (obj[ACTORDATA] && !obj[ACTORDATA].address) {
-          obj[ACTORDATA].address = e.peer.address
-          obj[ACTORDATA].port = e.peer.port
-        }
-        arrfor(array(obj), function(key, index) {
-          if (key in obj)
-            populate_actor_addresses(obj[key])
-        })
-      }
-      if (data.data) populate_actor_addresses(data.data)
-      turn(data)
-      break
+    }
+  } else if (e.type == "disconnect") {
+    peer_queue.delete(e.peer)
+    arrfor(array(peers), function(id, index) {
+      if (peers[id] == e.peer) delete peers[id]
+    })
+    log.system('portal got disconnect from ' + e.peer.address + ":" + e.peer.port)
+  } else if (e.type == "receive") {
+    data = nota.decode(e.data)
+    if (data.replycc && !data.replycc.address) {
+      data.replycc[ACTORDATA].address = e.peer.address
+      data.replycc[ACTORDATA].port = e.peer.port
+    }
+    if (data.data) populate_actor_addresses(data.data, e)
+    turn(data)
   }
 }
 
+function populate_actor_addresses(obj, e) {
+  if (!is_object(obj)) return
+  if (obj[ACTORDATA] && !obj[ACTORDATA].address) {
+    obj[ACTORDATA].address = e.peer.address
+    obj[ACTORDATA].port = e.peer.port
+  }
+  arrfor(array(obj), function(key, index) {
+    if (key in obj)
+      populate_actor_addresses(obj[key], e)
+  })
+}
+
 // takes a callback function, an actor object, and a configuration record for getting information about the status of a connection to the actor. The configuration record is used to request the sort of information that needs to be communicated. This can include latency, bandwidth, activity, congestion, cost, partitions. The callback is given a record containing the requested information.
 $_.contact = function(callback, record) {
   send(create_actor(record), record, callback)
@@ -487,10 +511,14 @@ $_.stop = function stop(actor) {
     need_stop = true
     return
   }
-  if (!is_actor(actor))
-    throw Error('Can only call stop on an actor.')
-  if (is_null(underlings[actor[ACTORDATA].id]))
-    throw Error('Can only call stop on an underling or self.')
+  if (!is_actor(actor)) {
+    log.error('Can only call stop on an actor.')
+    disrupt
+  }
+  if (is_null(underlings[actor[ACTORDATA].id])) {
+    log.error('Can only call stop on an underling or self.')
+    disrupt
+  }
 
   sys_msg(actor, {kind:"stop"})
 }
@@ -501,12 +529,13 @@ $_.unneeded = function unneeded(fn, seconds) {
 }
 
 // schedules the invocation of a function after a specified amount of time.
-$_.delay = function delay(fn, seconds = 0) {
+$_.delay = function delay(fn, seconds) {
+  var _seconds = seconds == null ? 0 : seconds
   function delay_turn() {
     fn()
     send_messages()
   }
-  var id = actor_mod.delay(delay_turn, seconds)
+  var id = actor_mod.delay(delay_turn, _seconds)
   return function() { actor_mod.removetimer(id) }
 }
 
@@ -527,42 +556,46 @@ function actor_prep(actor, send) {
 
 // Send a message immediately without queuing
 function actor_send_immediate(actor, send) {
-  try {
-    actor_send(actor, send);
-  } catch (err) {
-    log.error("Failed to send immediate message:", err);
-  }
+  actor_send(actor, send)
 }
 
 function actor_send(actor, message) {
+  var wota_blob = null
+  var peer = null
+
   if (actor[HEADER] && !actor[HEADER].replycc) // attempting to respond to a message but sender is not expecting; silently drop
     return
 
-  if (!is_actor(actor) && !is_actor(actor.replycc)) throw Error(`Must send to an actor object. Attempted send to ${actor}`)
-  
-  if (!is_object(message)) throw Error('Must send an object record.')
+  if (!is_actor(actor) && !is_actor(actor.replycc)) {
+    log.error(`Must send to an actor object. Attempted send to ${actor}`)
+    disrupt
+  }
+
+  if (!is_object(message)) {
+    log.error('Must send an object record.')
+    disrupt
+  }
 
   // message to self
   if (actor[ACTORDATA].id == _cell.id) {
     if (receive_fn) receive_fn(message.data)
     return
   }
-  
+
   // message to actor in same flock
   if (actor[ACTORDATA].id && actor_mod.mailbox_exist(actor[ACTORDATA].id)) {
-    var wota_blob = wota.encode(message)
-//    log.console(`sending wota blob of ${length(wota_blob)/8} bytes`)
+    wota_blob = wota.encode(message)
     actor_mod.mailbox_push(actor[ACTORDATA].id, wota_blob)
     return
   }
-  
+
   if (actor[ACTORDATA].address) {
     if (actor[ACTORDATA].id)
       message.target = actor[ACTORDATA].id
     else
       message.type = "contact"
-      
-    var peer = peers[actor[ACTORDATA].address + ":" + actor[ACTORDATA].port]
+
+    peer = peers[actor[ACTORDATA].address + ":" + actor[ACTORDATA].port]
     if (!peer) {
       if (!portal) {
         log.system(`creating a contactor ...`)
@@ -583,12 +616,10 @@ function actor_send(actor, message) {
 // Holds all messages queued during the current turn.
 var message_queue = []
 
-var need_stop = false
-
- function send_messages() {
+function send_messages() {
    // if we've been flagged to stop, bail out before doing anything
    if (need_stop) {
-     disrupt()
+     actor_die()
      message_queue = []
      return
    }
@@ -608,24 +639,36 @@ var need_stop = false
 var replies = {}
 
 function send(actor, message, reply) {
-  if (!is_object(actor))
-    throw Error(`Must send to an actor object. Provided: ${actor}`);
+  var send_msg = null
+  var target = null
+  var header = null
+  var id = null
 
-  if (!is_object(message))
-    throw Error('Message must be an object')
-  var send_msg = {type:"user", data: message}
+  if (!is_object(actor)) {
+    log.error(`Must send to an actor object. Provided: ${actor}`)
+    disrupt
+  }
+
+  if (!is_object(message)) {
+    log.error('Message must be an object')
+    disrupt
+  }
+  send_msg = {type:"user", data: message}
+  target = actor
 
   if (actor[HEADER] && actor[HEADER].replycc) {
-    var header = actor[HEADER]
-    if (!header.replycc || !is_actor(header.replycc))
-      throw Error(`Supplied actor had a return, but it's not a valid actor! ${actor[HEADER]}`)
+    header = actor[HEADER]
+    if (!header.replycc || !is_actor(header.replycc)) {
+      log.error(`Supplied actor had a return, but it's not a valid actor! ${actor[HEADER]}`)
+      disrupt
+    }
 
-    actor = header.replycc
+    target = header.replycc
     send_msg.return = header.reply
   }
 
   if (reply) {
-    var id = guid()
+    id = guid()
     replies[id] = reply
     $_.delay(_ => {
       if (replies[id]) {
@@ -638,7 +681,7 @@ function send(actor, message, reply) {
   }
 
   // Instead of sending immediately, queue it
-  actor_prep(actor, send_msg);
+  actor_prep(target, send_msg);
 }
 
 stone(send)
@@ -669,7 +712,7 @@ overling = _cell.args.overling
 $_.overling = overling
 
 root = _cell.args.root
-root ??= $_.self
+if (root == null) root = $_.self
 
 if (overling) {
   $_.couple(overling) // auto couple to overling
@@ -694,7 +737,7 @@ function report_to_overling(msg)
 var program = _cell.args.program
 
 if (!program) {
-  log.error('No program specified. Usage: cell <program.ce> [args...]')
+  log.error('No program specified. Usage: cell <program> [args...]')
   os.exit(1)
 }
 
@@ -705,69 +748,71 @@ function handle_actor_disconnect(id) {
     delete greeters[id]
   }
   log.system(`actor ${id} disconnected`)
-  if (!is_null(couplings[id])) disrupt("coupled actor died") // couplings now disrupts instead of stop
+  if (!is_null(couplings[id])) actor_die("coupled actor died") // couplings now disrupts instead of stop
 }
 
 function handle_sysym(msg)
 {
-  var from
-  switch(msg.kind) {
-    case 'stop':
-      disrupt("got stop message")
-      break
-    case 'underling':
-      from = msg.from
-      var greeter = greeters[from[ACTORDATA].id]
-      if (greeter) greeter(msg.message)
-      if (msg.message.type == 'disrupt')
-        delete underlings[from[ACTORDATA].id]
-      break
-    case 'contact':
-      if (portal_fn) {
-        var letter2 = msg.data
-        letter2[HEADER] = msg
-        delete msg.data
-        portal_fn(letter2)
-      } else throw Error('Got a contact message, but no portal is established.')
-      break
-    case 'couple': // from must be notified when we die
-      from = msg.from
-      underlings[from[ACTORDATA].id] = true
-      log.system(`actor ${from} is coupled to me`)
-      break
+  var from = null
+  var greeter = null
+  var letter2 = null
+
+  if (msg.kind == 'stop') {
+    actor_die("got stop message")
+  } else if (msg.kind == 'underling') {
+    from = msg.from
+    greeter = greeters[from[ACTORDATA].id]
+    if (greeter) greeter(msg.message)
+    if (msg.message.type == 'disrupt')
+      delete underlings[from[ACTORDATA].id]
+  } else if (msg.kind == 'contact') {
+    if (portal_fn) {
+      letter2 = msg.data
+      letter2[HEADER] = msg
+      delete msg.data
+      portal_fn(letter2)
+    } else {
+      log.error('Got a contact message, but no portal is established.')
+      disrupt
+    }
+  } else if (msg.kind == 'couple') {
+    // from must be notified when we die
+    from = msg.from
+    underlings[from[ACTORDATA].id] = true
+    log.system(`actor ${from} is coupled to me`)
   }
 }
 
 function handle_message(msg) {
+  var letter = null
+  var fn = null
+
   if (msg[SYSYM]) {
     handle_sysym(msg[SYSYM], msg.from)
     return
   }
 
-  switch (msg.type) {
-    case "user":
-      var letter = msg.data // what the sender really sent
-      _ObjectDefineProperty(letter, HEADER, {
-        value: msg, enumerable: false
-      })
-      _ObjectDefineProperty(letter, ACTORDATA, { // this is so is_actor == true
-        value: { reply: msg.reply }, enumerable: false
-      })
-      
-      if (msg.return) {
-        var fn = replies[msg.return]
-        if (fn) fn(letter)
-        delete replies[msg.return]
-        return
-      }
-      
-      if (receive_fn) receive_fn(letter)
+  if (msg.type == "user") {
+    letter = msg.data // what the sender really sent
+    _ObjectDefineProperty(letter, HEADER, {
+      value: msg, enumerable: false
+    })
+    _ObjectDefineProperty(letter, ACTORDATA, { // this is so is_actor == true
+      value: { reply: msg.reply }, enumerable: false
+    })
+
+    if (msg.return) {
+      fn = replies[msg.return]
+      if (fn) fn(letter)
+      delete replies[msg.return]
       return
-    case "stopped":
-      handle_actor_disconnect(msg.id)
-      break
+    }
+
+    if (receive_fn) receive_fn(letter)
+  } else if (msg.type == "stopped") {
+    handle_actor_disconnect(msg.id)
   }
-};
+}
 
 function enet_check()
 {
@@ -782,43 +827,68 @@ function enet_check()
 actor_mod.setname(_cell.args.program)
 
 var prog = _cell.args.program
+if (ends_with(prog, '.cm')) {
+  os.print(`error: ${prog} is a module (.cm), not a program (.ce)\n`)
+  os.exit(1)
+}
+if (ends_with(prog, '.ce')) prog = text(prog, 0, -3)
 
 var package = use_core('package')
 
-var locator = shop.resolve_locator(_cell.args.program + ".ce", null)
-
-if (!locator) {
-  var pkg = package.find_package_dir(_cell.args.program + ".ce")
-  locator = shop.resolve_locator(_cell.args.program + ".ce", pkg)
+// Find the .ce file
+var prog_path = prog + ".ce"
+var pkg_dir = null
+var core_dir = null
+if (!fd.is_file(prog_path)) {
+  pkg_dir = package.find_package_dir(prog_path)
+  if (pkg_dir)
+    prog_path = pkg_dir + '/' + prog + '.ce'
+}
+if (!fd.is_file(prog_path)) {
+  // Check core packages
+  core_dir = core_path
+  prog_path = core_dir + '/' + prog + '.ce'
+}
+if (!fd.is_file(prog_path)) {
+  os.print(`Main program ${prog} could not be found\n`)
+  os.exit(1)
 }
 
-if (!locator)
-  throw Error(`Main program ${_cell.args.program} could not be found`)
-
 $_.clock(_ => {
-  // Get capabilities for the main program
-  var file_info = shop.file_info ? shop.file_info(locator.path) : null
+  var file_info = shop.file_info ? shop.file_info(prog_path) : null
   var inject = shop.script_inject_for ? shop.script_inject_for(file_info) : []
 
-  // Build env object for injection
+  // Build env with runtime functions + capability injections
   var env = {}
-  for (var i = 0; i < length(inject); i++) {
-    var key = inject[i]
+  arrfor(array(runtime_env), function(k) { env[k] = runtime_env[k] })
+  var _ki = 0
+  var inj = null
+  var key = null
+  while (_ki < length(inject)) {
+    inj = inject[_ki]
+    key = inj
     if (key && key[0] == '$') key = text(key, 1)
-    if (key == 'fd') env[key] = fd
-    else env[key] = $_[key]
+    if (key == 'fd') env['$fd'] = fd
+    else env['$' + key] = $_[key]
+    _ki = _ki + 1
   }
 
-  // Create use function bound to the program's package
   var pkg = file_info ? file_info.package : null
-  var use_fn = function(path) { return shop.use(path, pkg) }
+  env.use = function(path) {
+    var ck = 'core/' + path
+    if (use_cache[ck]) return use_cache[ck]
+    var core_mod = use_core(path)
+    if (core_mod) return core_mod
+    return shop.use(path, pkg)
+  }
+  env.args = _cell.args.arg
+  env.log  = log
 
-  // Call with signature: setup_module(args, use, env)
-  // The script wrapper binds $delay, $start, etc. from env
-  var val = call(locator.symbol, null, [_cell.args.arg, use_fn, env])
-
-  if (val)
-    throw Error('Program must not return anything');
+  var script = text(fd.slurp(prog_path))
+  var ast = analyze(script, prog_path)
+  var val = run_ast_fn(prog, ast, env)
+  if (val) {
+    log.error('Program must not return anything')
+    disrupt
+  }
 })
-
-})()

internal/os.c

@@ -577,8 +577,8 @@ static const JSCFunctionListEntry js_os_funcs[] = {
 
 JSValue js_os_use(JSContext *js) {
   JS_NewClassID(&js_dylib_class_id);
-  JS_NewClass(JS_GetRuntime(js), js_dylib_class_id, &js_dylib_class);
-  
+  JS_NewClass(js, js_dylib_class_id, &js_dylib_class);
+
   JSValue mod = JS_NewObject(js);
   JS_SetPropertyFunctionList(js,mod,js_os_funcs,countof(js_os_funcs));
   return mod;

internal/shop.cm

@@ -5,7 +5,6 @@ var fd = use('fd')
 var http = use('http')
 var miniz = use('miniz')
 var time = use('time')
-var js = use('js')
 var crypto = use('crypto')
 var blob = use('blob')
 
@@ -13,6 +12,10 @@ var pkg_tools = use('package')
 var os = use('os')
 var link = use('link')
 
+var analyze = os.analyze
+var run_ast_fn = os.run_ast_fn
+var shop_json = os.json
+
 var core = "core"
 
 function pull_from_cache(content)
@@ -32,9 +35,10 @@ function ensure_dir(path) {
   if (fd.stat(path).isDirectory) return
   var parts = array(path, '/')
   var current = starts_with(path, '/') ? '/' : ''
-  for (var i = 0; i < length(parts); i++) {
+  var i = 0
+  for (i = 0; i < length(parts); i++) {
     if (parts[i] == '') continue
-    current += parts[i] + '/'
+    current = current + parts[i] + '/'
     if (!fd.stat(current).isDirectory) {
       fd.mkdir(current)
     }
@@ -76,12 +80,12 @@ function get_packages_dir() {
 }
 
 // Get the core directory (in the global shop)
+var core_package = 'core'
+
 Shop.get_core_dir = function() {
   return get_packages_dir() + '/' + core_package
 }
 
-var core_package = 'core'
-
 // Get the links file path (in the global shop)
 function get_links_path() {
   return global_shop_path + '/link.toml'
@@ -116,12 +120,16 @@ function split_explicit_package_import(path)
   if (!looks_explicit) return null
 
   // Find the longest prefix that is an installed package
-  for (var i = length(parts) - 1; i >= 1; i--) {
-    var pkg_candidate = text(array(parts, 0, i), '/')
-    var mod_path = text(array(parts, i), '/')
+  var i = 0
+  var pkg_candidate = null
+  var mod_path = null
+  var candidate_dir = null
+  for (i = length(parts) - 1; i >= 1; i--) {
+    pkg_candidate = text(array(parts, 0, i), '/')
+    mod_path = text(array(parts, i), '/')
     if (!mod_path || length(mod_path) == 0) continue
 
-    var candidate_dir = get_packages_dir() + '/' + safe_package_path(pkg_candidate)
+    candidate_dir = get_packages_dir() + '/' + safe_package_path(pkg_candidate)
     if (fd.is_file(candidate_dir + '/cell.toml'))
       return {package: pkg_candidate, path: mod_path}
 
@@ -142,8 +150,10 @@ function package_in_shop(package) {
 
 function abs_path_to_package(package_dir)
 {
-  if (!fd.is_file(package_dir + '/cell.toml'))
-    throw Error('Not a valid package directory (no cell.toml): ' + package_dir)
+  if (!fd.is_file(package_dir + '/cell.toml')) {
+    print('Not a valid package directory (no cell.toml): ' + package_dir)
+    disrupt
+  }
 
   var packages_prefix = get_packages_dir() + '/'
   var core_dir = packages_prefix + core_package
@@ -153,8 +163,9 @@ function abs_path_to_package(package_dir)
     return 'core'
   }
   // Also check if core_dir is a symlink pointing to package_dir
+  var core_target = null
   if (fd.is_link(core_dir)) {
-    var core_target = fd.readlink(core_dir)
+    core_target = fd.readlink(core_dir)
     if (core_target == package_dir || fd.realpath(core_dir) == package_dir) {
       return 'core'
     }
@@ -175,13 +186,14 @@ function abs_path_to_package(package_dir)
     return package_dir
 
   // For local directories (e.g., linked targets), read the package name from cell.toml
-  try {
-    var content = text(fd.slurp(package_dir + '/cell.toml'))
-    var cfg = toml.decode(content)
+  var _toml_path = package_dir + '/cell.toml'
+  var content = null
+  var cfg = null
+  if (fd.is_file(_toml_path)) {
+    content = text(fd.slurp(_toml_path))
+    cfg = toml.decode(content)
     if (cfg.package)
       return cfg.package
-  } catch (e) {
-    // Fall through
   }
 
   return null
@@ -299,23 +311,29 @@ Shop.resolve_package_info = function(pkg) {
 
 // Verify if a package name is valid and return status
 Shop.verify_package_name = function(pkg) {
-  if (!pkg) throw Error("Empty package name")
-  if (pkg == 'local') throw Error("local is not a valid package name")
-  if (pkg == 'core') throw Error("core is not a valid package name")
-  
-  if (search(pkg, '://') != null)
-    throw Error(`Invalid package name: ${pkg}; did you mean ${array(pkg, '://')[1]}?`)
+  if (!pkg) { print("Empty package name"); disrupt }
+  if (pkg == 'local') { print("local is not a valid package name"); disrupt }
+  if (pkg == 'core') { print("core is not a valid package name"); disrupt }
+
+  if (search(pkg, '://') != null) {
+    print(`Invalid package name: ${pkg}; did you mean ${array(pkg, '://')[1]}?`)
+    disrupt
+  }
 }
 
 // Convert module package to download URL
 Shop.get_download_url = function(pkg, commit_hash) {
   var info = Shop.resolve_package_info(pkg)
+  var parts = null
+  var host = null
+  var user = null
+  var repo = null
 
   if (info == 'gitea') {
-    var parts = array(pkg, '/')
-    var host = parts[0]
-    var user = parts[1]
-    var repo = parts[2]
+    parts = array(pkg, '/')
+    host = parts[0]
+    user = parts[1]
+    repo = parts[2]
     
     return 'https://' + host + '/' + user + '/' + repo + '/archive/' + commit_hash + '.zip'
   }
@@ -326,12 +344,16 @@ Shop.get_download_url = function(pkg, commit_hash) {
 // Get the API URL for checking remote git commits
 Shop.get_api_url = function(pkg) {
   var info = Shop.resolve_package_info(pkg)
+  var parts = null
+  var host = null
+  var user = null
+  var repo = null
 
   if (info == 'gitea') {
-    var parts = array(pkg, '/')
-    var host = parts[0]
-    var user = parts[1]
-    var repo = parts[2]
+    parts = array(pkg, '/')
+    host = parts[0]
+    user = parts[1]
+    repo = parts[2]
     return 'https://' + host + '/api/v1/repos/' + user + '/' + repo + '/branches/'
   }
 
@@ -378,116 +400,112 @@ Shop.get_script_capabilities = function(path) {
   return Shop.script_inject_for(file_info)
 }
 
+// Build the env object for a module, with runtime fns and $-prefixed capabilities.
+// Matches engine.cm's approach: env properties become free variables in the module.
 function inject_env(inject) {
-  // Start with runtime functions from engine
   var env = {}
   var rt = my$_.os ? my$_.os.runtime_env : null
   if (rt) {
-    for (var k in rt) {
-      env[k] = rt[k]
-    }
+    arrfor(array(rt), function(k) { env[k] = rt[k] })
   }
 
-  // Add capability injections
-  for (var i = 0; i < length(inject); i++) {
-    var inj = inject[i]
-    var key = trim(inj, '$')
-    if (key == 'fd') env[key] = fd
-    else env[key] = my$_[key]
+  // Add capability injections with $ prefix
+  var i = 0
+  var inj = null
+  var key = null
+  for (i = 0; i < length(inject); i++) {
+    inj = inject[i]
+    key = inj
+    if (key && key[0] == '$') key = text(key, 1)
+    if (key == 'fd') env['$fd'] = fd
+    else env['$' + key] = my$_[key]
   }
   return env
 }
 
-function inject_bindings_code(inject) {
-  var lines = []
+// Lazy-loaded compiler modules for on-the-fly compilation
+var _mcode_mod = null
+var _streamline_mod = null
 
-  // Runtime function bindings
-  var runtime_fns = ['logical', 'some', 'every', 'starts_with', 'ends_with',
-                     'actor', 'is_actor', 'log', 'send',
-                     'fallback', 'parallel', 'race', 'sequence']
-  for (var i = 0; i < length(runtime_fns); i++) {
-    var fn = runtime_fns[i]
-    push(lines, `var ${fn} = env["${fn}"];`)
-  }
-
-  // Capability bindings ($delay, $start, etc.)
-  for (var i = 0; i < length(inject); i++) {
-    var inj = inject[i]
-    var key = trim(inj, '$')
-    push(lines, `var $${key} = env["${key}"];`)
-  }
-  return text(lines, '\n')
-}
-
-// Build the use function for a specific package context
-function make_use_fn_code(pkg_arg) {
-  return `function(path) { return globalThis.use(path, ${pkg_arg}); }`
-}
-
-// for script forms, path is the canonical path of the module
-var script_form = function(path, script, pkg, inject) {
-  var pkg_arg = pkg ? `'${pkg}'` : 'null'
-  var binds = inject_bindings_code(inject)
-
-  var fn = `(function setup_module(args, use, env){
-def arg = args;
-def PACKAGE = ${pkg_arg};
-${binds}
-${script}
-})`
-  return fn
-}
-
-// Resolve module function, hashing it in the process
-// path is the exact path to the script file
+// Compile a module and return its bytecode blob.
+// The bytecode is cached on disk by content hash.
 function resolve_mod_fn(path, pkg) {
-  if (!fd.is_file(path)) throw Error(`path ${path} is not a file`)
+  if (!fd.is_file(path)) { print(`path ${path} is not a file`); disrupt }
 
-  var file_info = Shop.file_info(path)
-  var file_pkg = file_info.package
-  var inject = Shop.script_inject_for(file_info)
   var content = text(fd.slurp(path))
-  var script = script_form(path, content, file_pkg, inject);
+  var cached = pull_from_cache(stone(blob(content)))
+  var ast = null
+  var compiled = null
+  var mach_path = null
+  var mach_blob = null
+  var mcode_path = null
+  var ir = null
+  var optimized = null
 
-  var obj = pull_from_cache(stone(blob(script)))
-  if (obj) {
-    var fn = js.compile_unblob(obj)
-    return js.integrate(fn, null)
+  // Check cache for pre-compiled .mach blob
+  if (cached) {
+    return cached
   }
 
-  // Compile name is just for debug/stack traces
-  var compile_name = path
+  // Check for pre-compiled .mach or .mcode file alongside .cm source
+  if (ends_with(path, '.cm')) {
+    mach_path = text(path, 0, length(path) - 3) + '.mach'
+    if (fd.is_file(mach_path)) {
+      mach_blob = fd.slurp(mach_path)
+      put_into_cache(stone(blob(content)), mach_blob)
+      return mach_blob
+    }
+    mcode_path = path + '.mcode'
+    if (fd.is_file(mcode_path)) {
+      compiled = mach_compile_mcode_bin(path, text(fd.slurp(mcode_path)))
+      put_into_cache(stone(blob(content)), compiled)
+      return compiled
+    }
+  }
 
-  var fn = js.compile(compile_name, script)
+  // Compile via full pipeline: analyze → mcode → streamline → serialize
+  if (!_mcode_mod) _mcode_mod = Shop.use("mcode", null)
+  if (!_streamline_mod) _streamline_mod = Shop.use("streamline", null)
+  ast = analyze(content, path)
+  ir = _mcode_mod(ast)
+  optimized = _streamline_mod(ir)
+  compiled = mach_compile_mcode_bin(path, shop_json.encode(optimized))
+  put_into_cache(stone(blob(content)), compiled)
 
-  put_into_cache(stone(blob(script)), js.compile_blob(fn))
-
-  return js.integrate(fn, null)
+  return compiled
 }
 
 // given a path and a package context
 // return module info about where it was found
 function resolve_locator(path, ctx)
-{  
+{
   var explicit = split_explicit_package_import(path)
+  var explicit_path = null
+  var fn = null
+  var core_dir = null
+  var core_file_path = null
+  var is_core = null
+  var scope = null
+  var alias_path = null
+
   if (explicit) {
     if (is_internal_path(explicit.path) && ctx && explicit.package != ctx)
       explicit = null
   }
   if (explicit) {
-    var explicit_path = get_packages_dir() + '/' + safe_package_path(explicit.package) + '/' + explicit.path
+    explicit_path = get_packages_dir() + '/' + safe_package_path(explicit.package) + '/' + explicit.path
     if (fd.is_file(explicit_path)) {
-      var fn = resolve_mod_fn(explicit_path, explicit.package)
+      fn = resolve_mod_fn(explicit_path, explicit.package)
       return {path: explicit_path, scope: SCOPE_PACKAGE, symbol: fn}
     }
   }
 
   // 1. If no context, resolve from core only
   if (!ctx) {
-    var core_dir = Shop.get_core_dir()
-    var core_file_path = core_dir + '/' + path
+    core_dir = Shop.get_core_dir()
+    core_file_path = core_dir + '/' + path
     if (fd.is_file(core_file_path)) {
-      var fn = resolve_mod_fn(core_file_path, 'core')
+      fn = resolve_mod_fn(core_file_path, 'core')
       return {path: core_file_path, scope: SCOPE_CORE, symbol: fn}
     }
     return null
@@ -496,7 +514,7 @@ function resolve_locator(path, ctx)
   // check in ctx package
   // If ctx is an absolute path (starts with /), use it directly
   // Otherwise, look it up in the packages directory
-  var ctx_dir
+  var ctx_dir = null
   if (starts_with(ctx, '/')) {
     ctx_dir = ctx
   } else {
@@ -505,10 +523,10 @@ function resolve_locator(path, ctx)
   var ctx_path = ctx_dir + '/' + path
 
   if (fd.is_file(ctx_path)) {
-    var fn = resolve_mod_fn(ctx_path, ctx)
+    fn = resolve_mod_fn(ctx_path, ctx)
     // Check if ctx is the core package (either by name or by path)
-    var is_core = (ctx == 'core') || (ctx_dir == Shop.get_core_dir())
-    var scope = is_core ? SCOPE_CORE : SCOPE_LOCAL
+    is_core = (ctx == 'core') || (ctx_dir == Shop.get_core_dir())
+    scope = is_core ? SCOPE_CORE : SCOPE_LOCAL
     return {path: ctx_path, scope: scope, symbol: fn}
   }
 
@@ -518,24 +536,24 @@ function resolve_locator(path, ctx)
   // check for aliased dependency
   var alias = pkg_tools.split_alias(ctx, path)
   if (alias) {
-    var alias_path = get_packages_dir() + '/' + safe_package_path(alias.package) + '/' + alias.path
+    alias_path = get_packages_dir() + '/' + safe_package_path(alias.package) + '/' + alias.path
     if (fd.is_file(alias_path)) {
-      var fn = resolve_mod_fn(alias_path, ctx)
+      fn = resolve_mod_fn(alias_path, ctx)
       return {path: alias_path, scope:SCOPE_PACKAGE, symbol:fn}
     }
   }
 
-  var package_path  = get_packages_dir() + '/' + safe_package_path(path)
+  var package_path = get_packages_dir() + '/' + safe_package_path(path)
   if (fd.is_file(package_path)) {
-    var fn = resolve_mod_fn(package_path, ctx)
+    fn = resolve_mod_fn(package_path, ctx)
     return {path: package_path, scope: SCOPE_PACKAGE, symbol: fn}
   }
 
   // 4. Check core as fallback
-  var core_dir = Shop.get_core_dir()
-  var core_file_path = core_dir + '/' + path
+  core_dir = Shop.get_core_dir()
+  core_file_path = core_dir + '/' + path
   if (fd.is_file(core_file_path)) {
-    var fn = resolve_mod_fn(core_file_path, 'core')
+    fn = resolve_mod_fn(core_file_path, 'core')
     return {path: core_file_path, scope: SCOPE_CORE, symbol: fn}
   }
 
@@ -567,7 +585,7 @@ Shop.open_package_dylib = function(pkg) {
   var link_target = link.get_target(pkg)
   var resolved_pkg = link_target ? link_target : pkg
 
-  var pkg_dir;
+  var pkg_dir = null
   if (starts_with(resolved_pkg, '/')) {
     pkg_dir = resolved_pkg
   } else {
@@ -575,34 +593,23 @@ Shop.open_package_dylib = function(pkg) {
   }
 
   var toml_path = pkg_dir + '/cell.toml'
+  var content = null
+  var cfg = null
   if (fd.is_file(toml_path)) {
-    try {
-      var content = text(fd.slurp(toml_path))
-      var cfg = toml.decode(content)
-      if (cfg.dependencies) {
-        arrfor(array(cfg.dependencies), function(alias, i) {
-          var dep_pkg = cfg.dependencies[alias]
-          try {
-            Shop.open_package_dylib(dep_pkg)
-          } catch (dep_e) {
-            // Dependency dylib load failed, continue with others
-          }
-        })
-      }
-    } catch (e) {
-      // Error reading toml, continue
+    content = text(fd.slurp(toml_path))
+    cfg = toml.decode(content)
+    if (cfg.dependencies) {
+      arrfor(array(cfg.dependencies), function(alias, i) {
+        var dep_pkg = cfg.dependencies[alias]
+        Shop.open_package_dylib(dep_pkg)
+      })
     }
   }
 
   var dl_path = get_lib_path(pkg)
   if (fd.is_file(dl_path)) {
     if (!open_dls[dl_path]) {
-      try {
-        open_dls[dl_path] = os.dylib_open(dl_path)
-      } catch (e) {
-        dylib_visited[pkg] = false
-        throw e
-      }
+      open_dls[dl_path] = os.dylib_open(dl_path)
     }
   }
 }
@@ -613,12 +620,19 @@ Shop.open_package_dylib = function(pkg) {
 // Core is never loaded as a dynamic library via dlopen
 function resolve_c_symbol(path, package_context) {
   var explicit = split_explicit_package_import(path)
+  var sym = null
+  var dl_path = null
+  var _path = null
+  var core_sym = null
+  var canon_pkg = null
+  var mod_name = null
+
   if (explicit) {
     if (is_internal_path(explicit.path) && package_context && explicit.package != package_context)
       explicit = null
   }
   if (explicit) {
-    var sym = make_c_symbol(explicit.package, explicit.path)
+    sym = make_c_symbol(explicit.package, explicit.path)
     if (os.internal_exists(sym)) {
       return {
         symbol: function() { return os.load_internal(sym) },
@@ -629,7 +643,7 @@ function resolve_c_symbol(path, package_context) {
     }
 
     Shop.open_package_dylib(explicit.package)
-    var dl_path = get_lib_path(explicit.package)
+    dl_path = get_lib_path(explicit.package)
     if (open_dls[dl_path] && os.dylib_has_symbol(open_dls[dl_path], sym)) {
       return {
         symbol: function() { return os.dylib_symbol(open_dls[dl_path], sym) },
@@ -642,8 +656,8 @@ function resolve_c_symbol(path, package_context) {
 
   // If no package context, only check core internal symbols
   if (!package_context || package_context == 'core') {
-    path = replace(path, '/', '_')
-    var core_sym = `js_${path}_use`
+    _path = replace(path, '/', '_')
+    core_sym = `js_${_path}_use`
     if (os.internal_exists(core_sym)) {
       return {
         symbol: function() { return os.load_internal(core_sym) },
@@ -655,7 +669,7 @@ function resolve_c_symbol(path, package_context) {
   }
 
   // 1. Check own package first (internal, then dylib)
-  var sym = make_c_symbol(package_context, path)
+  sym = make_c_symbol(package_context, path)
   if (os.internal_exists(sym)) {
     return {
       symbol: function() { return os.load_internal(sym) },
@@ -665,7 +679,7 @@ function resolve_c_symbol(path, package_context) {
   }
 
   Shop.open_package_dylib(package_context)
-  var dl_path = get_lib_path(package_context)
+  dl_path = get_lib_path(package_context)
 
   if (open_dls[dl_path] && os.dylib_has_symbol(open_dls[dl_path], sym)) {
     return {
@@ -681,10 +695,10 @@ function resolve_c_symbol(path, package_context) {
   // 2. Check aliased package imports (e.g. 'prosperon/sprite')
   var pkg_alias = get_import_package(path)
   if (pkg_alias) {
-    var canon_pkg = get_aliased_package(path, package_context)
+    canon_pkg = get_aliased_package(path, package_context)
     if (canon_pkg) {
-      var mod_name = get_import_name(path)
-      var sym = make_c_symbol(canon_pkg, mod_name)
+      mod_name = get_import_name(path)
+      sym = make_c_symbol(canon_pkg, mod_name)
 
       // Check internal first
       if (os.internal_exists(sym)) {
@@ -698,7 +712,7 @@ function resolve_c_symbol(path, package_context) {
 
       // Then check dylib
       Shop.open_package_dylib(canon_pkg)
-      var dl_path = get_lib_path(canon_pkg)
+      dl_path = get_lib_path(canon_pkg)
       if (open_dls[dl_path] && os.dylib_has_symbol(open_dls[dl_path], sym)) {
         return {
           symbol: function() { return os.dylib_symbol(open_dls[dl_path], sym) },
@@ -711,7 +725,7 @@ function resolve_c_symbol(path, package_context) {
   }
 
   // 3. Check core internal symbols (core is never a dynamic library)
-  var core_sym = `js_${replace(path, '/', '_')}_use`
+  core_sym = `js_${replace(path, '/', '_')}_use`
   if (os.internal_exists(core_sym)) {
     return {
       symbol: function() { return os.load_internal(core_sym) },
@@ -739,31 +753,37 @@ function resolve_module_info(path, package_context) {
   if (min_scope == 999)
     return null
 
-  var cache_key
+  var cache_key = null
+  var real_path = null
+  var real_info = null
+  var pkg_alias = null
+  var canon_pkg = null
+  var mod_name = null
+
   if (mod_resolve.scope == SCOPE_CORE) {
     cache_key = 'core/' + path
   } else if (mod_resolve.scope < 900 && mod_resolve.path) {
-    var real_path = fd.realpath(mod_resolve.path)
+    real_path = fd.realpath(mod_resolve.path)
     if (real_path) {
-      var real_info = Shop.file_info(real_path)
+      real_info = Shop.file_info(real_path)
       if (real_info.package && real_info.name)
         cache_key = real_info.package + '/' + real_info.name
       else
         cache_key = real_path
     }
   }
-  
+
   if (!cache_key) {
     if (min_scope == SCOPE_CORE)
       cache_key = 'core/' + path
     else if (min_scope == SCOPE_LOCAL && package_context)
       cache_key = package_context + '/' + path
     else if (min_scope == SCOPE_PACKAGE) {
-      var pkg_alias = get_import_package(path)
+      pkg_alias = get_import_package(path)
       if (pkg_alias) {
-        var canon_pkg = get_canonical_package(pkg_alias, package_context)
+        canon_pkg = get_canonical_package(pkg_alias, package_context)
         if (canon_pkg) {
-          var mod_name = get_import_name(path)
+          mod_name = get_import_name(path)
           cache_key = canon_pkg + '/' + mod_name
         } else
           cache_key = path
@@ -814,54 +834,50 @@ function execute_module(info)
   var c_resolve = info.c_resolve
   var mod_resolve = info.mod_resolve
 
-  var used
+  var used = null
+  var file_info = null
+  var inject = null
+  var env = null
+  var pkg = null
 
   if (mod_resolve.scope < 900) {
-      var context = null
+      // Build env with runtime fns, capabilities, and use function
+      file_info = Shop.file_info(mod_resolve.path)
+      inject = Shop.script_inject_for(file_info)
+      env = inject_env(inject)
+      pkg = file_info.package
+      env.use = make_use_fn(pkg)
+
+      // Add C module as native context if available
       if (c_resolve.scope < 900) {
-          context = call_c_module(c_resolve)
+          env.native = call_c_module(c_resolve)
       }
 
-      // Get file info to determine inject list
-      var file_info = Shop.file_info(mod_resolve.path)
-      var inject = Shop.script_inject_for(file_info)
-      var env = inject_env(inject)
-      var pkg = file_info.package
-      var use_fn = make_use_fn(pkg)
-
-      // Call with signature: setup_module(args, use, env)
-      // args is null for module loading
-      used = call(mod_resolve.symbol, context, [null, use_fn, env])
+      // Load compiled bytecode with env
+      used = mach_load(mod_resolve.symbol, env)
   } else if (c_resolve.scope < 900) {
       // C only
       used = call_c_module(c_resolve)
   } else {
-      throw Error(`Module ${info.path} could not be found`)
+      print(`Module ${info.path} could not be found`); disrupt
   }
 
-//  if (is_function(used))
-//    throw Error('C module loader returned a function; did you forget to call it?')
+  if (!used) { print(`Module ${info} returned null`); disrupt }
 
-  if (!used)
-    throw Error(`Module ${info} returned null`)
-
-//  stone(used)
   return used
 }
 
 function get_module(path, package_context) {
   var info = resolve_module_info(path, package_context)
 
-  if (!info)
-    throw Error(`Module ${path} could not be found in ${package_context}`)
+  if (!info) { print(`Module ${path} could not be found in ${package_context}`); disrupt }
 
   return execute_module(info)
 }
 
 Shop.use = function use(path, package_context) {
   var info = resolve_module_info(path, package_context)
-  if (!info)
-    throw Error(`Module ${path} could not be found in ${package_context}`)
+  if (!info) { print(`Module ${path} could not be found in ${package_context}`); disrupt }
 
   if (use_cache[info.cache_key])
     return use_cache[info.cache_key]
@@ -889,13 +905,13 @@ function fetch_remote_hash(pkg) {
   if (!api_url) return null
 
   
-  try {
+  var _fetch_hash = function() {
     var resp = http.fetch(api_url)
     return Shop.extract_commit_hash(pkg, text(resp))
-  } catch (e) {
-    log.console("Warning: Could not check for updates for " + pkg)
+  } disruption {
     return null
   }
+  return _fetch_hash()
 }
 
 // Download a zip for a package at a specific commit and cache it
@@ -909,14 +925,14 @@ function download_zip(pkg, commit_hash) {
     return null
   }
 
-  try {
+  var _download = function() {
     var zip_blob = http.fetch(download_url)
     fd.slurpwrite(cache_path, zip_blob)
     return zip_blob
-  } catch (e) {
-    log.error("Download failed for " + pkg + ": " + e)
+  } disruption {
     return null
   }
+  return _download()
 }
 
 // Get zip from cache, returns null if not cached
@@ -952,17 +968,18 @@ Shop.fetch = function(pkg) {
   // Check if we have the zip cached
   var zip_blob = get_cached_zip(pkg, commit)
 
+  var actual_hash = null
   if (zip_blob) {
     // If we have a hash on record, verify it
     if (expected_hash) {
-      var actual_hash = text(crypto.blake2(zip_blob), 'h')
+      actual_hash = text(crypto.blake2(zip_blob), 'h')
       if (actual_hash == expected_hash) {
         return { status: 'cached' }
       }
       log.console("Zip hash mismatch for " + pkg + ", re-fetching...")
     } else {
       // No hash stored yet - compute and store it
-      var actual_hash = text(crypto.blake2(zip_blob), 'h')
+      actual_hash = text(crypto.blake2(zip_blob), 'h')
       lock_entry.zip_hash = actual_hash
       Shop.save_lock(lock)
       return { status: 'cached' }
@@ -1014,10 +1031,12 @@ Shop.extract = function(pkg) {
   // Check if already extracted at correct commit
   var lock = Shop.load_lock()
   var lock_entry = lock[pkg]
+  var extracted_commit_file = null
+  var extracted_commit = null
   if (lock_entry && lock_entry.commit) {
-    var extracted_commit_file = target_dir + '/.cell_commit'
+    extracted_commit_file = target_dir + '/.cell_commit'
     if (fd.is_file(extracted_commit_file)) {
-      var extracted_commit = trim(text(fd.slurp(extracted_commit_file)))
+      extracted_commit = trim(text(fd.slurp(extracted_commit_file)))
       if (extracted_commit == lock_entry.commit) {
         // Already extracted at this commit, skip
         return true
@@ -1028,7 +1047,7 @@ Shop.extract = function(pkg) {
   var zip_blob = get_package_zip(pkg)
 
   if (!zip_blob)
-    throw Error("No zip blob available for " + pkg)
+    print("No zip blob available for " + pkg); disrupt
 
   // Extract zip for remote package
   install_zip(zip_blob, target_dir)
@@ -1069,6 +1088,7 @@ Shop.update = function(pkg) {
 
   log.console(`checking ${pkg}`)
 
+  var new_entry = null
   if (info == 'local') {
     // Check if local path exists
     if (!fd.is_dir(pkg)) {
@@ -1076,7 +1096,7 @@ Shop.update = function(pkg) {
       return null
     }
     // Local packages always get a lock entry
-    var new_entry = {
+    new_entry = {
       type: 'local',
       updated: time.number()
     }
@@ -1099,7 +1119,7 @@ Shop.update = function(pkg) {
   if (local_commit == remote_commit)
     return null
 
-  var new_entry = {
+  new_entry = {
     type: info,
     commit: remote_commit,
     updated: time.number()
@@ -1113,7 +1133,7 @@ Shop.update = function(pkg) {
 
 function install_zip(zip_blob, target_dir) {
   var zip = miniz.read(zip_blob)
-  if (!zip) throw Error("Failed to read zip archive")
+  if (!zip) { print("Failed to read zip archive"); disrupt }
 
   if (fd.is_link(target_dir)) fd.unlink(target_dir)
   if (fd.is_dir(target_dir)) fd.rmdir(target_dir, 1)
@@ -1124,21 +1144,28 @@ function install_zip(zip_blob, target_dir) {
   var count = zip.count()
   var created_dirs = {}
 
-  for (var i = 0; i < count; i++) {
+  var i = 0
+  var filename = null
+  var slash_pos = null
+  var rel_path = null
+  var full_path = null
+  var dir_path = null
+  var file_data = null
+  for (i = 0; i < count; i++) {
     if (zip.is_directory(i)) continue
-    var filename = zip.get_filename(i)
-    var slash_pos = search(filename, '/')
+    filename = zip.get_filename(i)
+    slash_pos = search(filename, '/')
     if (slash_pos == null) continue
     if (slash_pos + 1 >= length(filename)) continue
-    var rel_path = text(filename, slash_pos + 1)
-    var full_path = target_dir + '/' + rel_path
-    var dir_path = fd.dirname(full_path)
+    rel_path = text(filename, slash_pos + 1)
+    full_path = target_dir + '/' + rel_path
+    dir_path = fd.dirname(full_path)
 
     if (!created_dirs[dir_path]) {
       ensure_dir(dir_path)
       created_dirs[dir_path] = true
     }
-    var file_data = zip.slurp(filename)
+    file_data = zip.slurp(filename)
 
     stone(file_data)
 
@@ -1161,18 +1188,20 @@ Shop.remove = function(pkg) {
 
 Shop.get = function(pkg) {
   var lock = Shop.load_lock()
-  
+  var info = null
+  var commit = null
+
   if (!lock[pkg]) {
-    var info = Shop.resolve_package_info(pkg)
+    info = Shop.resolve_package_info(pkg)
     if (!info) {
-      throw Error("Invalid package: " + pkg)
+      print("Invalid package: " + pkg); disrupt
     }
-    
-    var commit = null
+
+    commit = null
     if (info != 'local') {
       commit = fetch_remote_hash(pkg)
       if (!commit) {
-        throw Error("Could not resolve commit for " + pkg)
+        print("Could not resolve commit for " + pkg); disrupt
       }
     }
     
@@ -1188,8 +1217,6 @@ Shop.get = function(pkg) {
 // Compile a module
 // List all files in a package
 
-var debug = use('debug')
-
 Shop.file_reload = function(file)
 {
   var info = Shop.file_info(file)
@@ -1228,9 +1255,11 @@ function get_package_scripts(package)
 {
   var files = pkg_tools.list_files(package)
   var scripts = []
-  
-  for (var i = 0; i < length(files); i++) {
-    var file = files[i]
+
+  var i = 0
+  var file = null
+  for (i = 0; i < length(files); i++) {
+    file = files[i]
     if (ends_with(file, '.cm') || ends_with(file, '.ce')) {
       push(scripts, file)
     }

internal/testlib.cm

@@ -4,19 +4,21 @@ var pkg = use('package')
 
 // Check if current directory is a valid cell package
 function is_valid_package(dir) {
-  if (!dir) dir = '.'
-  return fd.is_file(dir + '/cell.toml')
+  var _dir = dir == null ? '.' : dir
+  if (!_dir) _dir = '.'
+  return fd.is_file(_dir + '/cell.toml')
 }
 
 // Get current package name from cell.toml or null
 function get_current_package_name() {
   if (!is_valid_package('.')) return null
-  try {
+  var _load = function() {
     var config = pkg.load_config(null)
     return config.package || 'local'
-  } catch (e) {
+  } disruption {
     return 'local'
   }
+  return _load()
 }
 
 // Get the directory for a package
@@ -37,9 +39,10 @@ function ensure_dir(path) {
 
   var parts = array(path, '/')
   var current = starts_with(path, '/') ? '/' : ''
-  for (var i = 0; i < length(parts); i++) {
+  var i = 0
+  for (i = 0; i < length(parts); i++) {
     if (parts[i] == '') continue
-    current += parts[i] + '/'
+    current = current + parts[i] + '/'
     if (!fd.is_dir(current)) {
       fd.mkdir(current)
     }

ir_report.ce

@@ -0,0 +1,200 @@
+// ir_report.ce — optimizer flight recorder CLI
+//
+// Usage: ./cell --core . ir_report.ce [options] <file.cm|file.ce>
+//
+// Options:
+//   --summary       Per-pass JSON summaries (default)
+//   --events        Include rewrite events
+//   --types         Include type deltas
+//   --ir-before=PASS  Print canonical IR before PASS
+//   --ir-after=PASS   Print canonical IR after PASS
+//   --ir-all        Print canonical IR before/after every pass
+//   --full          Everything (summary + events + types + ir-all)
+
+var fd = use("fd")
+var json = use("json")
+var tokenize = use("tokenize")
+var parse = use("parse")
+var fold = use("fold")
+var mcode = use("mcode")
+var streamline = use("streamline")
+var ir_stats = use("ir_stats")
+
+// --- Parse arguments ---
+
+var filename = null
+var opt_events = false
+var opt_types = false
+var opt_ir_before = null
+var opt_ir_after = null
+var opt_ir_all = false
+var i = 0
+var arg = null
+var p = null
+var e = null
+var td = null
+
+while (i < length(args)) {
+  arg = args[i]
+  if (arg == "--events") {
+    opt_events = true
+  } else if (arg == "--types") {
+    opt_types = true
+  } else if (arg == "--ir-all") {
+    opt_ir_all = true
+  } else if (arg == "--full") {
+    opt_events = true
+    opt_types = true
+    opt_ir_all = true
+  } else if (arg == "--summary") {
+    // default, no-op
+  } else if (starts_with(arg, "--ir-before=")) {
+    opt_ir_before = text(arg, 12)
+  } else if (starts_with(arg, "--ir-after=")) {
+    opt_ir_after = text(arg, 11)
+  } else if (!starts_with(arg, "--")) {
+    filename = arg
+  } else {
+    print(`unknown option: ${arg}\n`)
+    print("usage: cell --core . ir_report.ce [options] <file>\n")
+    $stop()
+  }
+  i = i + 1
+}
+
+if (filename == null) {
+  print("usage: cell --core . ir_report.ce [options] <file.cm|file.ce>\n")
+  print("  --summary        per-pass JSON summaries (default)\n")
+  print("  --events         include rewrite events\n")
+  print("  --types          include type deltas\n")
+  print("  --ir-before=PASS print canonical IR before PASS\n")
+  print("  --ir-after=PASS  print canonical IR after PASS\n")
+  print("  --ir-all         print canonical IR before/after every pass\n")
+  print("  --full           everything\n")
+  $stop()
+}
+
+// --- Compile ---
+
+var src = text(fd.slurp(filename))
+var tok = tokenize(src, filename)
+var ast = parse(tok.tokens, src, filename, tokenize)
+var folded = fold(ast)
+var compiled = mcode(folded)
+
+// --- Determine which passes need IR snapshots ---
+
+var need_snapshots = opt_ir_all || opt_ir_before != null || opt_ir_after != null
+
+// Deep copy for before snapshot if we need IR printing
+var before_ir = null
+if (need_snapshots) {
+  before_ir = json.decode(json.encode(compiled))
+}
+
+// --- Set up log ---
+
+var log = {
+  passes: [],
+  events: null,
+  type_deltas: null
+}
+
+if (opt_events) {
+  log.events = []
+}
+if (opt_types) {
+  log.type_deltas = []
+}
+
+// --- Run optimizer ---
+
+var optimized = streamline(compiled, log)
+
+// --- Output ---
+
+var emit = function(obj) {
+  print(json.encode(obj))
+  print("\n")
+}
+
+// Pass summaries (always)
+i = 0
+while (i < length(log.passes)) {
+  p = log.passes[i]
+  p.type = "pass"
+  emit(p)
+  i = i + 1
+}
+
+// Rewrite events
+if (opt_events && log.events != null) {
+  i = 0
+  while (i < length(log.events)) {
+    e = log.events[i]
+    e.type = "event"
+    emit(e)
+    i = i + 1
+  }
+}
+
+// Type deltas
+if (opt_types && log.type_deltas != null) {
+  i = 0
+  while (i < length(log.type_deltas)) {
+    td = log.type_deltas[i]
+    td.type = "types"
+    emit(td)
+    i = i + 1
+  }
+}
+
+// --- Canonical IR printing ---
+
+var print_ir = function(ir_obj, when_label, pass_name) {
+  var fname = null
+  var fi = 0
+  var func = null
+  if (ir_obj.main != null) {
+    fname = ir_obj.name != null ? ir_obj.name : "<main>"
+    emit({
+      type: "ir",
+      when: when_label,
+      pass: pass_name,
+      fn: fname,
+      text: ir_stats.canonical_ir(ir_obj.main, fname, {show_nops: true})
+    })
+  }
+  if (ir_obj.functions != null) {
+    fi = 0
+    while (fi < length(ir_obj.functions)) {
+      func = ir_obj.functions[fi]
+      fname = func.name != null ? func.name : `<func_${text(fi)}>`
+      emit({
+        type: "ir",
+        when: when_label,
+        pass: pass_name,
+        fn: fname,
+        text: ir_stats.canonical_ir(func, fname, {show_nops: true})
+      })
+      fi = fi + 1
+    }
+  }
+  return null
+}
+
+if (need_snapshots) {
+  if (opt_ir_all) {
+    print_ir(before_ir, "before", "all")
+    print_ir(optimized, "after", "all")
+  } else {
+    if (opt_ir_before != null) {
+      print_ir(before_ir, "before", opt_ir_before)
+    }
+    if (opt_ir_after != null) {
+      print_ir(optimized, "after", opt_ir_after)
+    }
+  }
+}
+
+$stop()

ir_stats.cm

@@ -0,0 +1,357 @@
+// ir_stats.cm — IR statistics, fingerprinting, and canonical printing
+//
+// Usage: var ir_stats = use("ir_stats")
+//   ir_stats.detailed_stats(func)
+//   ir_stats.ir_fingerprint(func)
+//   ir_stats.canonical_ir(func, name, opts)
+//   ir_stats.type_snapshot(slot_types)
+//   ir_stats.type_delta(before_types, after_types)
+
+var json = use("json")
+
+// --- Category maps ---
+
+var load_ops = {
+  load_field: true, load_index: true, load_dynamic: true,
+  get: true
+}
+var store_ops = {
+  store_field: true, store_index: true, store_dynamic: true,
+  set_var: true, put: true, push: true
+}
+var branch_ops = {
+  jump: true, jump_true: true, jump_false: true, jump_not_null: true
+}
+var call_ops = {
+  invoke: true, goinvoke: true
+}
+var guard_ops = {
+  is_int: true, is_text: true, is_num: true, is_bool: true,
+  is_null: true, is_array: true, is_func: true, is_record: true,
+  is_stone: true
+}
+var arith_ops = {
+  add_int: true, sub_int: true, mul_int: true, div_int: true, mod_int: true,
+  add_float: true, sub_float: true, mul_float: true, div_float: true, mod_float: true,
+  concat: true, neg_int: true, neg_float: true,
+  bitnot: true, bitand: true, bitor: true, bitxor: true,
+  shl: true, shr: true, ushr: true
+}
+var move_ops = {
+  move: true
+}
+var const_ops = {
+  int: true, true: true, false: true, null: true
+}
+
+var nop_reasons = {
+  tc: "tc",
+  bl: "bl",
+  mv: "mv",
+  dj: "dj",
+  ur: "ur"
+}
+
+var category_tag = function(op) {
+  if (guard_ops[op] == true) { return "guard" }
+  if (branch_ops[op] == true) { return "branch" }
+  if (load_ops[op] == true) { return "load" }
+  if (store_ops[op] == true) { return "store" }
+  if (call_ops[op] == true) { return "call" }
+  if (arith_ops[op] == true) { return "arith" }
+  if (move_ops[op] == true) { return "move" }
+  if (const_ops[op] == true) { return "const" }
+  return null
+}
+
+// --- detailed_stats ---
+
+var detailed_stats = function(func) {
+  var instructions = func.instructions
+  var stats = {
+    instr: 0, nop: 0,
+    load: 0, store: 0, branch: 0, call: 0,
+    guard: 0, arith: 0, move: 0, const: 0,
+    label: 0, other: 0
+  }
+  var i = 0
+  var instr = null
+  var op = null
+  var num = 0
+
+  if (instructions == null) {
+    return stats
+  }
+
+  num = length(instructions)
+  while (i < num) {
+    instr = instructions[i]
+    if (is_text(instr)) {
+      if (starts_with(instr, "_nop_")) {
+        stats.nop = stats.nop + 1
+        stats.instr = stats.instr + 1
+      } else {
+        stats.label = stats.label + 1
+      }
+    } else if (is_array(instr)) {
+      stats.instr = stats.instr + 1
+      op = instr[0]
+      if (op == "access" && !is_number(instr[2]) && !is_logical(instr[2])) {
+        stats.load = stats.load + 1
+      } else if (op == "access") {
+        stats.const = stats.const + 1
+      } else if (load_ops[op] == true) {
+        stats.load = stats.load + 1
+      } else if (store_ops[op] == true) {
+        stats.store = stats.store + 1
+      } else if (branch_ops[op] == true) {
+        stats.branch = stats.branch + 1
+      } else if (call_ops[op] == true) {
+        stats.call = stats.call + 1
+      } else if (guard_ops[op] == true) {
+        stats.guard = stats.guard + 1
+      } else if (arith_ops[op] == true) {
+        stats.arith = stats.arith + 1
+      } else if (move_ops[op] == true) {
+        stats.move = stats.move + 1
+      } else if (const_ops[op] == true) {
+        stats.const = stats.const + 1
+      } else {
+        stats.other = stats.other + 1
+      }
+    }
+    i = i + 1
+  }
+  return stats
+}
+
+// --- ir_fingerprint ---
+// djb2 hash computed over the JSON-encoded instructions
+
+var djb2 = function(s) {
+  var chars = array(s)
+  var hash = 5381
+  var i = 0
+  var num = length(chars)
+  while (i < num) {
+    hash = ((hash * 33) + number(chars[i])) % 4294967296
+    i = i + 1
+  }
+  return text(hash, 16)
+}
+
+var ir_fingerprint = function(func) {
+  return djb2(json.encode(func.instructions))
+}
+
+// --- canonical_ir ---
+
+var pad_right = function(s, w) {
+  var r = s
+  while (length(r) < w) {
+    r = r + " "
+  }
+  return r
+}
+
+var nop_reason = function(s) {
+  // extract reason from _nop_XX_NNN
+  var parts = array(s, "_")
+  // parts: ["", "nop", "XX", "NNN"]
+  if (length(parts) >= 3) {
+    return parts[2]
+  }
+  return "?"
+}
+
+var fmt_operand = function(v) {
+  if (is_null(v)) {
+    return "null"
+  }
+  if (is_number(v)) {
+    return text(v)
+  }
+  if (is_text(v)) {
+    return `"${v}"`
+  }
+  if (is_logical(v)) {
+    if (v) { return "true" }
+    return "false"
+  }
+  return text(v)
+}
+
+var canonical_ir = function(func, name, opts) {
+  var instructions = func.instructions
+  var nr_args = func.nr_args != null ? func.nr_args : 0
+  var nr_slots = func.nr_slots != null ? func.nr_slots : 0
+  var show_nops = false
+  var show_types = false
+  var slot_types = null
+  var lines = []
+  var i = 0
+  var instr = null
+  var op = null
+  var n = 0
+  var parts = null
+  var j = 0
+  var idx_str = null
+  var op_str = null
+  var operands = null
+  var suffix = null
+  var tag = null
+  var typ = null
+  var reason = null
+  var num = 0
+
+  if (opts != null) {
+    if (opts.show_nops == true) { show_nops = true }
+    if (opts.show_types == true) { show_types = true }
+    if (opts.slot_types != null) { slot_types = opts.slot_types }
+  }
+
+  lines[] = `fn ${name != null ? name : "<anon>"} (args=${text(nr_args)}, slots=${text(nr_slots)})`
+
+  if (instructions == null) {
+    return text(lines, "\n")
+  }
+
+  num = length(instructions)
+  while (i < num) {
+    instr = instructions[i]
+
+    if (is_text(instr)) {
+      if (starts_with(instr, "_nop_")) {
+        if (show_nops) {
+          reason = nop_reason(instr)
+          idx_str = pad_right(`@${text(i)}`, 6)
+          lines[] = `  ${idx_str}--- nop (${reason}) ---`
+        }
+      } else {
+        lines[] = `      ${instr}:`
+      }
+      i = i + 1
+      continue
+    }
+
+    if (!is_array(instr)) {
+      i = i + 1
+      continue
+    }
+
+    op = instr[0]
+    n = length(instr)
+    parts = []
+    j = 1
+    while (j < n - 2) {
+      if (is_number(instr[j]) && op != "int" && !(op == "access" && j == 2)) {
+        parts[] = `s${text(instr[j])}`
+      } else {
+        parts[] = fmt_operand(instr[j])
+      }
+      j = j + 1
+    }
+    operands = text(parts, ", ")
+
+    idx_str = pad_right(`@${text(i)}`, 6)
+    op_str = pad_right(op, 16)
+    suffix = ""
+
+    tag = category_tag(op)
+
+    if (show_types && slot_types != null) {
+      // show type for dest slot if known
+      if (is_number(instr[1])) {
+        typ = slot_types[text(instr[1])]
+        if (typ != null) {
+          suffix = `; -> ${typ}`
+        }
+      }
+      if (tag != null) {
+        suffix = suffix + `  [${tag}]`
+      }
+    } else if (tag != null) {
+      suffix = suffix + `; [${tag}]`
+    }
+
+    if (length(suffix) > 0) {
+      lines[] = `  ${idx_str}${op_str}${operands} ${suffix}`
+    } else {
+      lines[] = `  ${idx_str}${op_str}${operands}`
+    }
+
+    i = i + 1
+  }
+
+  return text(lines, "\n")
+}
+
+// --- type_snapshot ---
+
+var type_snapshot = function(slot_types) {
+  if (slot_types == null) {
+    return {}
+  }
+  return stone(record(slot_types))
+}
+
+// --- type_delta ---
+
+var type_delta = function(before_types, after_types) {
+  var result = {
+    added: {},
+    removed: {},
+    strengthened: {},
+    weakened: {}
+  }
+  var bt = before_types != null ? before_types : {}
+  var at = after_types != null ? after_types : {}
+  var keys = null
+  var i = 0
+  var k = null
+  var bv = null
+  var av = null
+
+  // check after for added/changed
+  keys = array(at)
+  i = 0
+  while (i < length(keys)) {
+    k = keys[i]
+    av = at[k]
+    bv = bt[k]
+    if (bv == null) {
+      result.added[k] = av
+    } else if (bv != av) {
+      if (bv == "unknown" || (bv == "num" && (av == "int" || av == "float"))) {
+        result.strengthened[k] = {from: bv, to: av}
+      } else if (av == "unknown" || (av == "num" && (bv == "int" || bv == "float"))) {
+        result.weakened[k] = {from: bv, to: av}
+      } else {
+        result.strengthened[k] = {from: bv, to: av}
+      }
+    }
+    i = i + 1
+  }
+
+  // check before for removed
+  keys = array(bt)
+  i = 0
+  while (i < length(keys)) {
+    k = keys[i]
+    if (at[k] == null) {
+      result.removed[k] = bt[k]
+    }
+    i = i + 1
+  }
+
+  return result
+}
+
+return {
+  detailed_stats: detailed_stats,
+  ir_fingerprint: ir_fingerprint,
+  canonical_ir: canonical_ir,
+  type_snapshot: type_snapshot,
+  type_delta: type_delta,
+  category_tag: category_tag
+}

link.cm

@@ -34,9 +34,10 @@ function ensure_dir(path) {
   if (fd.stat(path).isDirectory) return
   var parts = array(path, '/')
   var current = starts_with(path, '/') ? '/' : ''
-  for (var i = 0; i < length(parts); i++) {
+  var i = 0
+  for (i = 0; i < length(parts); i++) {
     if (parts[i] == '') continue
-    current += parts[i] + '/'
+    current = current + parts[i] + '/'
     if (!fd.stat(current).isDirectory) {
       fd.mkdir(current)
     }
@@ -66,14 +67,16 @@ Link.load = function() {
     return link_cache
   }
   
-  try {
+  var _load = function() {
     var content = text(fd.slurp(path))
     var cfg = toml.decode(content)
-    link_cache = cfg.links || {}
-  } catch (e) {
-    log.console("Warning: Failed to load link.toml: " + e)
+    if (cfg && cfg.links) link_cache = cfg.links
+    else link_cache = {}
+  } disruption {
+    print("Warning: Failed to load link.toml\n")
     link_cache = {}
   }
+  _load()
   return link_cache
 }
 
@@ -90,14 +93,16 @@ Link.add = function(canonical, target, shop) {
   // Validate canonical package exists in shop
   var lock = shop.load_lock()
   if (!lock[canonical]) {
-    throw Error('Package ' + canonical + ' is not installed. Install it first with: cell get ' + canonical)
+    print('Package ' + canonical + ' is not installed. Install it first with: cell get ' + canonical + '\n')
+    disrupt
   }
 
   // Validate target is a valid package
   if (starts_with(target, '/')) {
     // Local path - must have cell.toml
     if (!fd.is_file(target + '/cell.toml')) {
-      throw Error('Target ' + target + ' is not a valid package (no cell.toml)')
+      print('Target ' + target + ' is not a valid package (no cell.toml)\n')
+      disrupt
     }
   } else {
     // Remote package target - ensure it's installed
@@ -115,34 +120,36 @@ Link.add = function(canonical, target, shop) {
   // Read the target's cell.toml to find its dependencies
   var target_path = starts_with(target, '/') ? target : get_package_abs_dir(target)
   var toml_path = target_path + '/cell.toml'
+  var _install_deps = null
   if (fd.is_file(toml_path)) {
-    try {
+    _install_deps = function() {
       var content = text(fd.slurp(toml_path))
       var cfg = toml.decode(content)
-      if (cfg.dependencies) {
+      if (cfg && cfg.dependencies) {
         arrfor(array(cfg.dependencies), function(alias) {
           var dep_locator = cfg.dependencies[alias]
           // Skip local dependencies that don't exist
           if (starts_with(dep_locator, '/') && !fd.is_dir(dep_locator)) {
-            log.console("  Skipping missing local dependency: " + dep_locator)
+            print("  Skipping missing local dependency: " + dep_locator + "\n")
             return
           }
           // Install the dependency if not already in shop
-          try {
+          var _get_dep = function() {
             shop.get(dep_locator)
             shop.extract(dep_locator)
-          } catch (e) {
-            log.console(`  Warning: Could not install dependency ${dep_locator}: ${e.message}`)
-            log.error(e)
+          } disruption {
+            print(`  Warning: Could not install dependency ${dep_locator}\n`)
           }
+          _get_dep()
         })
       }
-    } catch (e) {
-      log.console(`  Warning: Could not read dependencies from ${toml_path}`)
+    } disruption {
+      print(`  Warning: Could not read dependencies from ${toml_path}\n`)
     }
+    _install_deps()
   }
 
-  log.console("Linked " + canonical + " -> " + target)
+  print("Linked " + canonical + " -> " + target + "\n")
   return true
 }
 
@@ -154,12 +161,12 @@ Link.remove = function(canonical) {
   var target_dir = get_package_abs_dir(canonical)
   if (fd.is_link(target_dir)) {
     fd.unlink(target_dir)
-    log.console("Removed symlink at " + target_dir)
+    print("Removed symlink at " + target_dir + "\n")
   }
-  
+
   delete links[canonical]
   Link.save(links)
-  log.console("Unlinked " + canonical)
+  print("Unlinked " + canonical + "\n")
   return true
 }
 
@@ -174,7 +181,7 @@ Link.clear = function() {
   })
   
   Link.save({})
-  log.console("Cleared all links")
+  print("Cleared all links\n")
   return true
 }
 
@@ -218,7 +225,7 @@ Link.sync_all = function(shop) {
 
   arrfor(array(links), function(canonical) {
     var target = links[canonical]
-    try {
+    var _sync = function() {
       // Validate target exists
       var link_target = resolve_link_target(target)
       if (!fd.is_dir(link_target)) {
@@ -234,10 +241,10 @@ Link.sync_all = function(shop) {
 
       // Install dependencies of the linked package
       var toml_path = link_target + '/cell.toml'
-      try {
+      var _install = function() {
         var content = text(fd.slurp(toml_path))
         var cfg = toml.decode(content)
-        if (cfg.dependencies) {
+        if (cfg && cfg.dependencies) {
           arrfor(array(cfg.dependencies), function(alias) {
             var dep_locator = cfg.dependencies[alias]
             // Skip local dependencies that don't exist
@@ -245,22 +252,25 @@ Link.sync_all = function(shop) {
               return
             }
             // Install the dependency if not already in shop
-            try {
+            var _get = function() {
               shop.get(dep_locator)
               shop.extract(dep_locator)
-            } catch (e) {
+            } disruption {
               // Silently continue - dependency may already be installed
             }
+            _get()
           })
         }
-      } catch (e) {
+      } disruption {
         // Could not read dependencies - continue anyway
       }
+      _install()
 
-      count++
-    } catch (e) {
-      push(errors, canonical + ': ' + e.message)
+      count = count + 1
+    } disruption {
+      push(errors, canonical + ': sync failed')
     }
+    _sync()
   })
 
   return { synced: count, errors: errors }
@@ -269,7 +279,7 @@ Link.sync_all = function(shop) {
 // Check if a package is currently linked
 Link.is_linked = function(canonical) {
   var links = Link.load()
-  return canonical in links
+  return links[canonical] != null
 }
 
 // Get the link target for a package (or null if not linked)