rm push/pop

Use PPretext for parser string building to avoid GC issues during parsing.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

.cell/lock.toml

@@ -1,6 +0,0 @@
-[modules]
-[modules.extramath]
-hash = "MCLZT3JABTAENS4WVXKGWJ7JPBLZER4YQ5VN2PE7ZD2Z4WYGTIMA===="
-url = "https://gitea.pockle.world/john/extramath@master"
-downloaded = "Monday June 2 12:07:20.42 PM -5 2025 AD"
-commit = "84d81a19a8455bcf8dc494739e9e6d545df6ff2c"

.clang-format

@@ -1,9 +1,20 @@
 BasedOnStyle: GNU
+Language: C
+
 IndentWidth: 2
 TabWidth: 2
 UseTab: Never
-ContinuationIndentWidth: 2  # Indents continuation lines by 2 spaces
+ContinuationIndentWidth: 2
+
 AllowShortFunctionsOnASingleLine: true
 AllowShortBlocksOnASingleLine: true
 AllowShortIfStatementsOnASingleLine: true
 BreakBeforeBraces: Attach
+ColumnLimit: 0
+BreakFunctionDefinitionParameters: false
+BinPackParameters: false
+BinPackArguments: false
+
+# --- Fix the "static T\nname(...)" style ---
+AlwaysBreakAfterDefinitionReturnType: None
+BreakAfterReturnType: None

.gitattributes

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

.gitignore

@@ -1,5 +1,12 @@
 .git/
 .obj/
+website/public/
+website/site/
+website/.hugo_build.lock
+.cache
+.cell
+cell
+libcell_runtime*
 bin/
 build/
 *.zip
@@ -14,6 +21,7 @@ build/
 source/shaders/*.h
 .DS_Store
 *.html
+!website/themes/**/*.html
 .vscode
 *.icns
 icon.ico

CLAUDE.md

@@ -0,0 +1,237 @@
+# ƿit (pit) Language Project
+
+## Building
+
+Build (or rebuild after changes): `make`
+Install to system: `make install`
+Run `cell --help` to see all CLI flags.
+
+## Code Style
+
+All code uses 2 spaces for indentation. K&R style for C and Javascript.
+
+## ƿit Script Quick Reference
+
+ƿit script files: `.ce` (actors) and `.cm` (modules). The syntax is similar to JavaScript with important differences listed below.
+
+### 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 `switch`/`case` — use record dispatch (a record keyed by case, values are functions or results) instead of if/else chains
+- No `for...in`, `for...of`, spread (`...`), rest params, or default params
+- Functions have a maximum of 4 parameters — use a record for more
+- 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: `object()`, `length()`, `stone()`, `is_stone()`, `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')`)
+- C symbol naming: `js_<pkg>_<file>_use` (e.g., `js_core_math_radians_use` for `core/math/radians`)
+- Core is the `core` package — its symbols follow the same `js_core_<name>_use` pattern as all other packages
+- Package directories should contain only source files (no `.mach`/`.mcode` alongside source)
+- Build cache files in `build/` are bare hashes (no extensions)
+
+### MANDATORY: GC Rooting for C Functions
+
+This project uses a **copying garbage collector**. ANY JS allocation (`JS_NewObject`, `JS_NewString`, `JS_NewArray`, `JS_NewInt32`, `JS_SetPropertyStr`, `js_new_blob_stoned_copy`, etc.) can trigger GC, which **invalidates all unrooted JSValue locals**. This is not theoretical — it causes real crashes.
+
+**Before writing or modifying ANY C function**, apply this checklist:
+
+1. Count the number of `JS_New*`, `JS_SetProperty*`, and `js_new_blob*` calls in the function
+2. If there are 2 or more, the function MUST use `JS_FRAME`/`JS_ROOT`/`JS_RETURN`
+3. Every JSValue that is held across an allocating call must be rooted
+
+**Pattern — object with properties:**
+```c
+JS_FRAME(js);
+JS_ROOT(obj, JS_NewObject(js));
+JS_SetPropertyStr(js, obj.val, "x", JS_NewInt32(js, 42));
+JSValue name = JS_NewString(js, "hello");
+JS_SetPropertyStr(js, obj.val, "name", name);
+JS_RETURN(obj.val);
+```
+
+**Pattern — array with loop (declare root BEFORE the loop):**
+```c
+JS_FRAME(js);
+JS_ROOT(arr, JS_NewArray(js));
+JSGCRef item = { .val = JS_NULL, .prev = NULL };
+JS_PushGCRef(js, &item);
+for (int i = 0; i < count; i++) {
+  item.val = JS_NewObject(js);
+  JS_SetPropertyStr(js, item.val, "v", JS_NewInt32(js, i));
+  JS_SetPropertyNumber(js, arr.val, i, item.val);
+}
+JS_RETURN(arr.val);
+```
+
+**Rules:**
+- Access rooted values via `.val` (e.g., `obj.val`, not `obj`)
+- NEVER put `JS_ROOT` inside a loop — it pushes the same stack address twice, corrupting the GC chain
+- Error returns before `JS_FRAME` use plain `return`
+- Error returns after `JS_FRAME` must use `JS_RETURN_EX()` or `JS_RETURN_NULL()`
+
+**CRITICAL — C argument evaluation order bug:**
+
+Allocating functions (`JS_NewString`, `JS_NewFloat64`, `js_new_blob_stoned_copy`, etc.) used as arguments to `JS_SetPropertyStr` can crash because C evaluates arguments in unspecified order. The compiler may read `obj.val` BEFORE the allocating call, then GC moves the object, leaving a stale pointer.
+
+```c
+// UNSAFE — intermittent crash:
+JS_SetPropertyStr(js, obj.val, "format", JS_NewString(js, "rgba32"));
+JS_SetPropertyStr(js, obj.val, "pixels", js_new_blob_stoned_copy(js, data, len));
+
+// SAFE — separate the allocation:
+JSValue fmt = JS_NewString(js, "rgba32");
+JS_SetPropertyStr(js, obj.val, "format", fmt);
+JSValue pixels = js_new_blob_stoned_copy(js, data, len);
+JS_SetPropertyStr(js, obj.val, "pixels", pixels);
+```
+
+`JS_NewInt32`, `JS_NewUint32`, and `JS_NewBool` do NOT allocate and are safe inline.
+
+See `docs/c-modules.md` for the full GC safety reference.
+
+## 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)
+
+## Package Management (Shop CLI)
+
+**Two shops:** `cell <cmd>` uses the global shop at `~/.cell/packages/`. `cell --dev <cmd>` uses the local shop at `.cell/packages/`. Linked packages (via `cell link`) are symlinked into the shop — edit the source directory directly.
+
+```
+cell add <path>                    # add a package (local path or remote)
+cell remove <path>                 # remove a package (cleans lock, symlink, dylibs)
+cell build <path>                  # build C modules for a package
+cell build <path> --force          # force rebuild (ignore stat cache)
+cell test package <path>           # run tests for a package
+cell list                          # list installed packages
+cell link                          # list linked packages
+```
+
+The build step compiles C files to content-addressed dylibs in `~/.cell/build/<hash>` and writes a per-package manifest so the runtime can find them. C files in `src/` are support files linked into module dylibs, not standalone modules.
+
+## Debugging Compiler Issues
+
+When investigating bugs in compiled output (wrong values, missing operations, incorrect comparisons), **start from the optimizer down, not the VM up**. The compiler inspection tools will usually identify the problem faster than adding C-level tracing:
+
+```
+./cell --dev streamline --types <file>    # show inferred slot types — look for wrong types
+./cell --dev ir_report --events <file>    # show every optimization applied and why
+./cell --dev ir_report --types <file>     # show type inference results per function
+./cell --dev mcode --pretty <file>        # show raw IR before optimization
+./cell --dev streamline --ir <file>       # show human-readable optimized IR
+```
+
+**Triage order:**
+1. `streamline --types` — are slot types correct? Wrong type inference causes wrong optimizations.
+2. `ir_report --events` — are type checks being incorrectly eliminated? Look for `known_type_eliminates_guard` on slots that shouldn't have known types.
+3. `mcode --pretty` — is the raw IR correct before optimization? If so, the bug is in streamline.
+4. Only dig into `source/mach.c` if the IR looks correct at all levels.
+
+See `docs/compiler-tools.md` for the full tool reference and `docs/spec/streamline.md` for pass details.
+
+## 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

@@ -1,80 +1,47 @@
-# Development build: creates libcell_runtime.dylib + thin main wrapper
-# This is the default target for working on cell itself
-#
-# If cell doesn't exist yet, use 'make bootstrap' first (requires meson)
-# or manually build with meson once.
-#
-# The cell shop is at ~/.cell and core scripts are installed to ~/.cell/core
+BUILD     = build
+BUILD_DBG = build_debug
+INSTALL_BIN = /opt/homebrew/bin
+INSTALL_LIB = /opt/homebrew/lib
+INSTALL_INC = /opt/homebrew/include
+CELL_SHOP   = $(HOME)/.cell
 
-CELL_SHOP = $(HOME)/.cell
-CELL_CORE_PACKAGE = $(CELL_SHOP)/packages/core
+all: $(BUILD)/build.ninja
+	meson compile -C $(BUILD)
+	cp $(BUILD)/libcell_runtime.dylib .
+	cp $(BUILD)/cell .
 
-makecell:
-	cell pack core -o cell
-	cp cell /opt/homebrew/bin/
+$(BUILD)/build.ninja:
+	meson setup $(BUILD) -Dbuildtype=release
 
-# Install core: symlink this directory to ~/.cell/core
-install: bootstrap $(CELL_SHOP)
-	@echo "Linking cell core to $(CELL_CORE_PACKAGE)"
-	rm -rf $(CELL_CORE_PACKAGE)
-	ln -s $(PWD) $(CELL_CORE_PACKAGE)
-	cp cell /opt/homebrew/bin/
-	cp libcell_runtime.dylib /opt/homebrew/lib/
-	@echo "Core installed."
+debug: $(BUILD_DBG)/build.ninja
+	meson compile -C $(BUILD_DBG)
+	cp $(BUILD_DBG)/libcell_runtime.dylib .
+	cp $(BUILD_DBG)/cell .
 
-cell: libcell_runtime.dylib cell_main
-	cp cell_main cell
-	chmod +x cell
-	cp cell /opt/homebrew/bin/cell
-	cp libcell_runtime.dylib /opt/homebrew/lib/
+$(BUILD_DBG)/build.ninja:
+	meson setup $(BUILD_DBG) -Dbuildtype=debug -Db_sanitize=address
 
-# Build the shared runtime library (everything except main.c)
-# Uses existing cell to run build -d
-libcell_runtime.dylib: $(CELL_SHOP)/build/dynamic
-	cell build -d
-	cp $(CELL_SHOP)/build/dynamic/libcell_runtime.dylib .
+install: all $(CELL_SHOP)
+	cp cell $(INSTALL_BIN)/cell
+	cp libcell_runtime.dylib $(INSTALL_LIB)/
+	cp source/cell.h $(INSTALL_INC)/
+	rm -rf $(CELL_SHOP)/packages/core
+	ln -s $(CURDIR) $(CELL_SHOP)/packages/core
+	@echo "Installed cell to $(INSTALL_BIN) and $(INSTALL_LIB)"
 
-# Build the thin main wrapper that links to libcell_runtime
-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
+install_debug: debug $(CELL_SHOP)
+	cp cell $(INSTALL_BIN)/cell
+	cp libcell_runtime.dylib $(INSTALL_LIB)/
+	cp source/cell.h $(INSTALL_INC)/
+	rm -rf $(CELL_SHOP)/packages/core
+	ln -s $(CURDIR) $(CELL_SHOP)/packages/core
+	@echo "Installed cell (debug+asan) to $(INSTALL_BIN) and $(INSTALL_LIB)"
 
-# Create the cell shop directories
 $(CELL_SHOP):
-	mkdir -p $(CELL_SHOP)
-	mkdir -p $(CELL_SHOP)/packages
-	mkdir -p $(CELL_SHOP)/cache
-	mkdir -p $(CELL_SHOP)/build
+	mkdir -p $(CELL_SHOP)/packages $(CELL_SHOP)/cache $(CELL_SHOP)/build
 
-$(CELL_CORE):
-	ln -s $(PWD) $(CELL_CORE)
-
-# Static build: creates a fully static cell binary (for distribution)
-static:
-	cell build
-	cp $(CELL_SHOP)/build/static/cell .
-
-# Bootstrap: build cell from scratch using meson (only needed once)
-# Also installs core scripts to ~/.cell/core
-bootstrap: 
-	meson setup build_bootstrap -Dbuildtype=debugoptimized
-	meson compile -C build_bootstrap
-	cp build_bootstrap/cell .
-	cp build_bootstrap/libcell_runtime.dylib .
-	@echo "Bootstrap complete. Cell shop initialized at $(CELL_SHOP)"
-	@echo "Now run 'make' to rebuild with cell itself."
-
-# Clean build artifacts
 clean:
-	rm -rf $(CELL_SHOP)/build build_bootstrap
-	rm -f cell cell_main libcell_runtime.dylib
+	rm -rf $(BUILD) $(BUILD_DBG)
+	rm -f cell libcell_runtime.dylib
 
-# Ensure dynamic build directory exists
-$(CELL_SHOP)/build/dynamic: $(CELL_SHOP)
-	mkdir -p $(CELL_SHOP)/build/dynamic
-
-# Legacy meson target
-meson:
-	meson setup build_dbg -Dbuildtype=debugoptimized
-	meson install -C build_dbg
-
-.PHONY: cell static bootstrap clean meson install
+.PHONY: all install debug install_debug clean

add.ce

@@ -1,28 +1,135 @@
-// cell add <locator> [alias] - Add and install a package with its dependencies
+// cell add <locator> [alias] - Add a dependency to the current package
+//
+// Usage:
+//   cell add <locator>         Add a dependency using default alias
+//   cell add <locator> <alias> Add a dependency with custom alias
+//   cell add -r <directory>    Recursively find and add all packages in directory
+//
+// This adds the dependency to cell.toml and installs it to the shop.
 
 var shop = use('internal/shop')
+var pkg = use('package')
 var fd = use('fd')
 
-if (args.length < 1) {
-  log.console("Usage: cell add <locator> [alias]")
-  log.console("Examples:")
-  log.console("  cell add gitea.pockle.world/john/prosperon@main")
-  log.console("  cell add github.com/user/repo@v1.0.0 myalias")
-  $stop()
-  return
-}
+var locator = null
+var alias = null
+var recursive = false
+var cwd = fd.realpath('.')
+var parts = null
+var locators = null
+var added = 0
+var failed = 0
+var _add_dep = null
+var _install = null
+var i = 0
 
-var locator = args[0]
-
-// Resolve relative paths to absolute paths
-if (locator == '.' || locator.startsWith('./') || locator.startsWith('../') || fd.is_dir(locator)) {
-  var resolved = fd.realpath(locator)
-  if (resolved) {
-    locator = resolved
+var run = function() {
+  for (i = 0; i < length(args); i++) {
+    if (args[i] == '--help' || args[i] == '-h') {
+      log.console("Usage: cell add <locator> [alias]")
+      log.console("")
+      log.console("Add a dependency to the current package.")
+      log.console("")
+      log.console("Examples:")
+      log.console("  cell add gitea.pockle.world/john/prosperon")
+      log.console("  cell add gitea.pockle.world/john/cell-image image")
+      log.console("  cell add ../local-package")
+      log.console("  cell add -r ../packages")
+      return
+    } else if (args[i] == '-r') {
+      recursive = true
+    } else if (!starts_with(args[i], '-')) {
+      if (!locator) {
+        locator = args[i]
+      } else if (!alias) {
+        alias = args[i]
+      }
+    }
   }
+
+  if (!locator && !recursive) {
+    log.console("Usage: cell add <locator> [alias]")
+    return
+  }
+
+  if (locator)
+    locator = shop.resolve_locator(locator)
+
+  // Generate default alias from locator
+  if (!alias && locator) {
+    parts = array(locator, '/')
+    alias = parts[length(parts) - 1]
+    if (search(alias, '@') != null)
+      alias = array(alias, '@')[0]
+  }
+
+  // Check we're in a package directory
+  if (!fd.is_file(cwd + '/cell.toml')) {
+    log.error("Not in a package directory (no cell.toml found)")
+    return
+  }
+
+  // Recursive mode
+  if (recursive) {
+    if (!locator) locator = '.'
+    locator = shop.resolve_locator(locator)
+    if (!fd.is_dir(locator)) {
+      log.error(`${locator} is not a directory`)
+      return
+    }
+    locators = filter(pkg.find_packages(locator), function(p) {
+      return p != cwd
+    })
+    if (length(locators) == 0) {
+      log.console("No packages found in " + locator)
+      return
+    }
+    log.console(`Found ${text(length(locators))} package(s) in ${locator}`)
+
+    added = 0
+    failed = 0
+    arrfor(locators, function(loc) {
+      var loc_parts = array(loc, '/')
+      var loc_alias = loc_parts[length(loc_parts) - 1]
+      log.console("  Adding " + loc + " as '" + loc_alias + "'...")
+      var _add = function() {
+        pkg.add_dependency(null, loc, loc_alias)
+        shop.sync(loc)
+        added = added + 1
+      } disruption {
+        log.console(`  Warning: Failed to add ${loc}`)
+        failed = failed + 1
+      }
+      _add()
+    })
+
+    log.console("Added " + text(added) + " package(s)." + (failed > 0 ? " Failed: " + text(failed) + "." : ""))
+    return
+  }
+
+  // Single package add
+  log.console("Adding " + locator + " as '" + alias + "'...")
+
+  _add_dep = function() {
+    pkg.add_dependency(null, locator, alias)
+    log.console("  Added to cell.toml")
+  } disruption {
+    log.error("Failed to update cell.toml")
+    return
+  }
+  _add_dep()
+
+  _install = function() {
+    shop.sync_with_deps(locator)
+    log.console("  Installed to shop")
+  } disruption {
+    log.error("Failed to install")
+    return
+  }
+  _install()
+
+  log.console("Added " + alias + " (" + locator + ")")
 }
-var alias = args.length > 1 ? args[1] : null
+run()
 
-shop.get(locator, alias)
-
-$stop()
+$stop()

analyze.cm

@@ -0,0 +1,144 @@
+// analyze.cm — Static analysis over index data.
+//
+// All functions take an index object (from index.cm) and return structured results.
+// Does not depend on streamline — operates purely on source-semantic data.
+
+var analyze = {}
+
+// Find all references to a name, with optional scope filter.
+// scope: "top" (enclosing == null), "fn" (enclosing != null), null (all)
+analyze.find_refs = function(idx, name, scope) {
+  var hits = []
+  var i = 0
+  var ref = null
+  while (i < length(idx.references)) {
+    ref = idx.references[i]
+    if (ref.name == name) {
+      if (scope == null) {
+        hits[] = ref
+      } else if (scope == "top" && ref.enclosing == null) {
+        hits[] = ref
+      } else if (scope == "fn" && ref.enclosing != null) {
+        hits[] = ref
+      }
+    }
+    i = i + 1
+  }
+  return hits
+}
+
+// Find all <name>.<property> usage patterns (channel analysis).
+// Only counts unshadowed uses (name not declared as local var in scope).
+analyze.channels = function(idx, name) {
+  var channels = {}
+  var summary = {}
+  var i = 0
+  var cs = null
+  var callee = null
+  var prop = null
+  var prefix_dot = name + "."
+  while (i < length(idx.call_sites)) {
+    cs = idx.call_sites[i]
+    callee = cs.callee
+    if (callee != null && starts_with(callee, prefix_dot)) {
+      prop = text(callee, length(prefix_dot), length(callee))
+      if (channels[prop] == null) {
+        channels[prop] = []
+      }
+      channels[prop][] = {span: cs.span}
+      if (summary[prop] == null) {
+        summary[prop] = 0
+      }
+      summary[prop] = summary[prop] + 1
+    }
+    i = i + 1
+  }
+  return {channels: channels, summary: summary}
+}
+
+// Find declarations by name, with optional kind filter.
+// kind: "var", "def", "fn", "param", or null (any)
+analyze.find_decls = function(idx, name, kind) {
+  var hits = []
+  var i = 0
+  var sym = null
+  while (i < length(idx.symbols)) {
+    sym = idx.symbols[i]
+    if (sym.name == name) {
+      if (kind == null || sym.kind == kind) {
+        hits[] = sym
+      }
+    }
+    i = i + 1
+  }
+  return hits
+}
+
+// Find intrinsic usage by name.
+analyze.find_intrinsic = function(idx, name) {
+  var hits = []
+  var i = 0
+  var ref = null
+  if (idx.intrinsic_refs == null) return hits
+  while (i < length(idx.intrinsic_refs)) {
+    ref = idx.intrinsic_refs[i]
+    if (ref.name == name) {
+      hits[] = ref
+    }
+    i = i + 1
+  }
+  return hits
+}
+
+// Call sites with >4 args — always a compile error (max arity is 4).
+analyze.excess_args = function(idx) {
+  var hits = []
+  var i = 0
+  var cs = null
+  while (i < length(idx.call_sites)) {
+    cs = idx.call_sites[i]
+    if (cs.args_count > 4) {
+      hits[] = {span: cs.span, callee: cs.callee, args_count: cs.args_count}
+    }
+    i = i + 1
+  }
+  return hits
+}
+
+// Extract module export shape from index data (for cross-module analysis).
+analyze.module_summary = function(idx) {
+  var exports = {}
+  var i = 0
+  var j = 0
+  var exp = null
+  var sym = null
+  var found = false
+  if (idx.exports == null) return {exports: exports}
+  while (i < length(idx.exports)) {
+    exp = idx.exports[i]
+    found = false
+    if (exp.symbol_id != null) {
+      j = 0
+      while (j < length(idx.symbols)) {
+        sym = idx.symbols[j]
+        if (sym.symbol_id == exp.symbol_id) {
+          if (sym.kind == "fn" && sym.params != null) {
+            exports[exp.name] = {type: "function", arity: length(sym.params)}
+          } else {
+            exports[exp.name] = {type: sym.kind}
+          }
+          found = true
+          break
+        }
+        j = j + 1
+      }
+    }
+    if (!found) {
+      exports[exp.name] = {type: "unknown"}
+    }
+    i = i + 1
+  }
+  return {exports: exports}
+}
+
+return analyze

archive/miniz.c

@@ -1,6 +1,5 @@
-#include "quickjs.h"
-#include "miniz.h"
 #include "cell.h"
+#include "miniz.h"
 
 static JSClassID js_reader_class_id;
 static JSClassID js_writer_class_id;
@@ -8,14 +7,14 @@ static JSClassID js_writer_class_id;
 static void js_reader_finalizer(JSRuntime *rt, JSValue val) {
   mz_zip_archive *zip = JS_GetOpaque(val, js_reader_class_id);
   mz_zip_reader_end(zip);
-  js_free_rt(rt,zip);
+  js_free_rt(zip);
 }
 
 static void js_writer_finalizer(JSRuntime *rt, JSValue val) {
   mz_zip_archive *zip = JS_GetOpaque(val, js_writer_class_id);
   mz_zip_writer_finalize_archive(zip);
   mz_zip_writer_end(zip);
-  js_free_rt(rt,zip);
+  js_free_rt(zip);
 }
 
 static JSClassDef js_reader_class = {
@@ -42,19 +41,19 @@ static JSValue js_miniz_read(JSContext *js, JSValue self, int argc, JSValue *arg
 {
   size_t len;
   void *data = js_get_blob_data(js, &len, argv[0]);
-  if (data == -1)
+  if (data == (void *)-1)
     return JS_EXCEPTION;
 
   mz_zip_archive *zip = calloc(sizeof(*zip), 1);
   if (!zip)
-    return JS_ThrowOutOfMemory(js);
+    return JS_RaiseOOM(js);
 
   mz_bool success = mz_zip_reader_init_mem(zip, data, len, 0);
   
   if (!success) {
     int err = mz_zip_get_last_error(zip);
     free(zip);
-    return JS_ThrowInternalError(js, "Failed to initialize zip reader: %s", mz_zip_get_error_string(err));
+    return JS_RaiseDisrupt(js, "Failed to initialize zip reader: %s", mz_zip_get_error_string(err));
   }
 
   JSValue jszip = JS_NewObjectClass(js, js_reader_class_id);
@@ -71,7 +70,7 @@ static JSValue js_miniz_write(JSContext *js, JSValue self, int argc, JSValue *ar
   mz_zip_archive *zip = calloc(sizeof(*zip), 1);
   if (!zip) {
     JS_FreeCString(js, file);
-    return JS_ThrowOutOfMemory(js);
+    return JS_RaiseOOM(js);
   }
   
   mz_bool success = mz_zip_writer_init_file(zip, file, 0);
@@ -81,7 +80,7 @@ static JSValue js_miniz_write(JSContext *js, JSValue self, int argc, JSValue *ar
     int err = mz_zip_get_last_error(zip);
     mz_zip_writer_end(zip);
     free(zip);
-    return JS_ThrowInternalError(js, "Failed to initialize zip writer: %s", mz_zip_get_error_string(err));
+    return JS_RaiseDisrupt(js, "Failed to initialize zip writer: %s", mz_zip_get_error_string(err));
   }
   
   JSValue jszip = JS_NewObjectClass(js, js_writer_class_id);
@@ -93,7 +92,7 @@ static JSValue js_miniz_compress(JSContext *js, JSValue this_val,
                                  int argc, JSValueConst *argv)
 {
   if (argc < 1)
-    return JS_ThrowTypeError(js,
+    return JS_RaiseDisrupt(js,
             "compress needs a string or ArrayBuffer");
 
   /* ─── 1. Grab the input data ──────────────────────────────── */
@@ -101,7 +100,7 @@ static JSValue js_miniz_compress(JSContext *js, JSValue this_val,
   size_t      in_len  = 0;
   const void *in_ptr  = NULL;
 
-  if (JS_IsString(argv[0])) {
+  if (JS_IsText(argv[0])) {
     /* String → UTF-8 bytes without the terminating NUL */
     cstring = JS_ToCStringLen(js, &in_len, argv[0]);
     if (!cstring)
@@ -109,35 +108,38 @@ static JSValue js_miniz_compress(JSContext *js, JSValue this_val,
     in_ptr = cstring;
   } else { 
     in_ptr = js_get_blob_data(js, &in_len, argv[0]);
-    if (in_ptr == -1)
+    if (in_ptr == (const void *)-1)
       return JS_EXCEPTION;
   }
 
-  /* ─── 2. Allocate an output buffer big enough  ────────────── */
+  /* ─── 2. Allocate output blob (before getting blob input ptr) ── */
   mz_ulong out_len_est = mz_compressBound(in_len);
-  void *out_buf = js_malloc(js, out_len_est);
-  if (!out_buf) {
+  void *out_ptr;
+  JSValue abuf = js_new_blob_alloc(js, (size_t)out_len_est, &out_ptr);
+  if (JS_IsException(abuf)) {
     if (cstring) JS_FreeCString(js, cstring);
-    return JS_EXCEPTION;
+    return abuf;
+  }
+
+  /* Re-derive blob input pointer after alloc (GC may have moved it) */
+  if (!cstring) {
+    in_ptr = js_get_blob_data(js, &in_len, argv[0]);
   }
 
   /* ─── 3. Do the compression (MZ_DEFAULT_COMPRESSION = level 6) */
   mz_ulong out_len = out_len_est;
-  int st = mz_compress2(out_buf, &out_len,
+  int st = mz_compress2(out_ptr, &out_len,
                         in_ptr, in_len, MZ_DEFAULT_COMPRESSION);
 
   /* clean-up for string input */
   if (cstring) JS_FreeCString(js, cstring);
 
-  if (st != MZ_OK) {
-    js_free(js, out_buf);
-    return JS_ThrowInternalError(js,
+  if (st != MZ_OK)
+    return JS_RaiseDisrupt(js,
             "miniz: compression failed (%d)", st);
-  }
 
-  /* ─── 4. Hand JavaScript a copy of the compressed data ────── */
-  JSValue abuf = js_new_blob_stoned_copy(js, out_buf, out_len);
-  js_free(js, out_buf);
+  /* ─── 4. Stone with actual compressed size ────────────────── */
+  js_blob_stone(abuf, (size_t)out_len);
   return abuf;
 }
 
@@ -147,13 +149,13 @@ static JSValue js_miniz_decompress(JSContext *js,
                                    JSValueConst *argv)
 {
   if (argc < 1)
-    return JS_ThrowTypeError(js,
+    return JS_RaiseDisrupt(js,
             "decompress: need compressed ArrayBuffer");
 
   /* grab compressed data */
   size_t in_len;
   void  *in_ptr = js_get_blob_data(js, &in_len, argv[0]);
-  if (in_ptr == -1)
+  if (in_ptr == (void *)-1)
     return JS_EXCEPTION;
 
   /* zlib header present → tell tinfl to parse it */
@@ -163,7 +165,7 @@ static JSValue js_miniz_decompress(JSContext *js,
                      TINFL_FLAG_PARSE_ZLIB_HEADER);
 
   if (!out_ptr)
-    return JS_ThrowInternalError(js,
+    return JS_RaiseDisrupt(js,
             "miniz: decompression failed");
 
   JSValue ret;
@@ -187,16 +189,16 @@ static const JSCFunctionListEntry js_miniz_funcs[] = {
 JSValue js_writer_add_file(JSContext *js, JSValue self, int argc, JSValue *argv)
 {
   if (argc < 2)
-    return JS_ThrowTypeError(js, "add_file requires (path, arrayBuffer)");
+    return JS_RaiseDisrupt(js, "add_file requires (path, arrayBuffer)");
   
   mz_zip_archive *zip = js2writer(js, self);
   const char *pathInZip = JS_ToCString(js, argv[0]);
   if (!pathInZip)
-    return JS_ThrowTypeError(js, "Could not parse path argument");
+    return JS_RaiseDisrupt(js, "Could not parse path argument");
   
   size_t dataLen;
   void *data = js_get_blob_data(js, &dataLen, argv[1]);
-  if (data == -1) {
+  if (data == (void *)-1) {
     JS_FreeCString(js, pathInZip);
     return JS_EXCEPTION;
   }
@@ -205,7 +207,7 @@ JSValue js_writer_add_file(JSContext *js, JSValue self, int argc, JSValue *argv)
   JS_FreeCString(js, pathInZip);
   
   if (!success)
-    return JS_ThrowInternalError(js, "Failed to add memory to zip");
+    return JS_RaiseDisrupt(js, "Failed to add memory to zip");
   
   return JS_NULL;
 }
@@ -225,7 +227,7 @@ JSValue js_reader_mod(JSContext *js, JSValue self, int argc, JSValue *argv)
   mz_zip_archive *zip = js2reader(js, self);
   if (!zip) {
     JS_FreeCString(js, file);
-    return JS_ThrowInternalError(js, "Invalid zip reader");
+    return JS_RaiseDisrupt(js, "Invalid zip reader");
   }
   
   mz_zip_archive_file_stat pstat;
@@ -233,19 +235,19 @@ JSValue js_reader_mod(JSContext *js, JSValue self, int argc, JSValue *argv)
   
   if (index == (mz_uint)-1) {
     JS_FreeCString(js, file);
-    return JS_ThrowReferenceError(js, "File '%s' not found in archive", file);
+    return JS_RaiseDisrupt(js, "File '%s' not found in archive", file);
   }
   
   JS_FreeCString(js, file);
   
   if (!mz_zip_reader_file_stat(zip, index, &pstat)) {
     int err = mz_zip_get_last_error(zip);
-    return JS_ThrowInternalError(js, "Failed to get file stats: %s", mz_zip_get_error_string(err));
+    return JS_RaiseDisrupt(js, "Failed to get file stats: %s", mz_zip_get_error_string(err));
   }
   
   return JS_NewFloat64(js, pstat.m_time);
 #else
-  return JS_ThrowInternalError(js, "MINIZ_NO_TIME is defined");
+  return JS_RaiseDisrupt(js, "MINIZ_NO_TIME is defined");
 #endif
 }
 
@@ -258,7 +260,7 @@ JSValue js_reader_exists(JSContext *js, JSValue self, int argc, JSValue *argv)
   mz_zip_archive *zip = js2reader(js, self);
   if (!zip) {
     JS_FreeCString(js, file);
-    return JS_ThrowInternalError(js, "Invalid zip reader");
+    return JS_RaiseDisrupt(js, "Invalid zip reader");
   }
   
   mz_uint index = mz_zip_reader_locate_file(zip, file, NULL, 0);
@@ -276,7 +278,7 @@ JSValue js_reader_slurp(JSContext *js, JSValue self, int argc, JSValue *argv)
   mz_zip_archive *zip = js2reader(js, self);
   if (!zip) {
     JS_FreeCString(js, file);
-    return JS_ThrowInternalError(js, "Invalid zip reader");
+    return JS_RaiseDisrupt(js, "Invalid zip reader");
   }
   
   size_t len;
@@ -286,7 +288,7 @@ JSValue js_reader_slurp(JSContext *js, JSValue self, int argc, JSValue *argv)
     int err = mz_zip_get_last_error(zip);
     const char *filename = file;
     JS_FreeCString(js, file);
-    return JS_ThrowInternalError(js, "Failed to extract file '%s': %s", filename, mz_zip_get_error_string(err));
+    return JS_RaiseDisrupt(js, "Failed to extract file '%s': %s", filename, mz_zip_get_error_string(err));
   }
   
   JS_FreeCString(js, file);
@@ -300,7 +302,7 @@ JSValue js_reader_list(JSContext *js, JSValue self, int argc, JSValue *argv)
 {
   mz_zip_archive *zip = js2reader(js, self);
   if (!zip)
-    return JS_ThrowInternalError(js, "Invalid zip reader");
+    return JS_RaiseDisrupt(js, "Invalid zip reader");
   
   mz_uint num_files = mz_zip_reader_get_num_files(zip);
   
@@ -316,10 +318,9 @@ JSValue js_reader_list(JSContext *js, JSValue self, int argc, JSValue *argv)
     
     JSValue filename = JS_NewString(js, file_stat.m_filename);
     if (JS_IsException(filename)) {
-      JS_FreeValue(js, arr);
       return filename;
     }
-    JS_SetPropertyUint32(js, arr, arr_index++, filename);
+    JS_SetPropertyNumber(js, arr, arr_index++, filename);
   }
   
   return arr;
@@ -328,7 +329,7 @@ JSValue js_reader_list(JSContext *js, JSValue self, int argc, JSValue *argv)
 JSValue js_reader_is_directory(JSContext *js, JSValue self, int argc, JSValue *argv)
 {
   if (argc < 1)
-    return JS_ThrowTypeError(js, "is_directory requires a file index");
+    return JS_RaiseDisrupt(js, "is_directory requires a file index");
     
   int32_t index;
   if (JS_ToInt32(js, &index, argv[0]))
@@ -336,7 +337,7 @@ JSValue js_reader_is_directory(JSContext *js, JSValue self, int argc, JSValue *a
   
   mz_zip_archive *zip = js2reader(js, self);
   if (!zip)
-    return JS_ThrowInternalError(js, "Invalid zip reader");
+    return JS_RaiseDisrupt(js, "Invalid zip reader");
   
   return JS_NewBool(js, mz_zip_reader_is_file_a_directory(zip, index));
 }
@@ -344,7 +345,7 @@ JSValue js_reader_is_directory(JSContext *js, JSValue self, int argc, JSValue *a
 JSValue js_reader_get_filename(JSContext *js, JSValue self, int argc, JSValue *argv)
 {
   if (argc < 1)
-    return JS_ThrowTypeError(js, "get_filename requires a file index");
+    return JS_RaiseDisrupt(js, "get_filename requires a file index");
     
   int32_t index;
   if (JS_ToInt32(js, &index, argv[0]))
@@ -352,11 +353,11 @@ JSValue js_reader_get_filename(JSContext *js, JSValue self, int argc, JSValue *a
   
   mz_zip_archive *zip = js2reader(js, self);
   if (!zip)
-    return JS_ThrowInternalError(js, "Invalid zip reader");
+    return JS_RaiseDisrupt(js, "Invalid zip reader");
   
   mz_zip_archive_file_stat file_stat;
   if (!mz_zip_reader_file_stat(zip, index, &file_stat))
-    return JS_ThrowInternalError(js, "Failed to get file stats");
+    return JS_RaiseDisrupt(js, "Failed to get file stats");
     
   return JS_NewString(js, file_stat.m_filename);
 }
@@ -365,7 +366,7 @@ JSValue js_reader_count(JSContext *js, JSValue self, int argc, JSValue *argv)
 {
   mz_zip_archive *zip = js2reader(js, self);
   if (!zip)
-    return JS_ThrowInternalError(js, "Invalid zip reader");
+    return JS_RaiseDisrupt(js, "Invalid zip reader");
   return JS_NewUint32(js, mz_zip_reader_get_num_files(zip));
 }
 
@@ -379,21 +380,23 @@ static const JSCFunctionListEntry js_reader_funcs[] = {
   JS_CFUNC_DEF("count", 0, js_reader_count),
 };
 
-JSValue js_miniz_use(JSContext *js)
+JSValue js_core_miniz_use(JSContext *js)
 {
+  JS_FRAME(js);
+
   JS_NewClassID(&js_reader_class_id);
-  JS_NewClass(JS_GetRuntime(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_NewClass(js, js_reader_class_id, &js_reader_class);
+  JS_ROOT(reader_proto, JS_NewObject(js));
+  JS_SetPropertyFunctionList(js, reader_proto.val, js_reader_funcs, sizeof(js_reader_funcs) / sizeof(JSCFunctionListEntry));
+  JS_SetClassProto(js, js_reader_class_id, reader_proto.val);
 
   JS_NewClassID(&js_writer_class_id);
-  JS_NewClass(JS_GetRuntime(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);
-  
-  JSValue export = JS_NewObject(js);
-  JS_SetPropertyFunctionList(js, export, js_miniz_funcs, sizeof(js_miniz_funcs)/sizeof(JSCFunctionListEntry));
-  return export;
+  JS_NewClass(js, js_writer_class_id, &js_writer_class);
+  JS_ROOT(writer_proto, JS_NewObject(js));
+  JS_SetPropertyFunctionList(js, writer_proto.val, js_writer_funcs, sizeof(js_writer_funcs) / sizeof(JSCFunctionListEntry));
+  JS_SetClassProto(js, js_writer_class_id, writer_proto.val);
+
+  JS_ROOT(export, JS_NewObject(js));
+  JS_SetPropertyFunctionList(js, export.val, js_miniz_funcs, sizeof(js_miniz_funcs)/sizeof(JSCFunctionListEntry));
+  JS_RETURN(export.val);
 }

audit.ce

@@ -0,0 +1,149 @@
+// cell audit [<locator>] - Test-compile all .ce and .cm scripts
+//
+// Usage:
+//   cell audit              Audit all packages
+//   cell audit <locator>    Audit specific package
+//   cell audit .            Audit current directory package
+//   cell audit --function-hoist [<locator>]   Report function hoisting usage
+//
+// Compiles every script in the package(s) to check for errors.
+// Continues past failures and reports all issues at the end.
+
+var shop = use('internal/shop')
+var pkg = use('package')
+var fd = use('fd')
+
+var target_package = null
+var function_hoist = false
+var i = 0
+
+var run = function() {
+  var packages = null
+  var tokenize_mod = null
+  var parse_mod = null
+  var hoist_files = 0
+  var hoist_refs = 0
+  var total_ok = 0
+  var total_errors = 0
+  var total_scripts = 0
+  var all_failures = []
+  var all_unresolved = []
+  var summary = null
+
+  for (i = 0; i < length(args); i++) {
+    if (args[i] == '--help' || args[i] == '-h') {
+      log.console("Usage: cell audit [--function-hoist] [<locator>]")
+      log.console("")
+      log.console("Test-compile all .ce and .cm scripts in package(s).")
+      log.console("Reports all errors without stopping at the first failure.")
+      log.console("")
+      log.console("Flags:")
+      log.console("  --function-hoist   Report files that rely on function hoisting")
+      return
+    } else if (args[i] == '--function-hoist') {
+      function_hoist = true
+    } else if (!starts_with(args[i], '-')) {
+      target_package = args[i]
+    }
+  }
+
+  // Resolve local paths
+  if (target_package) {
+    target_package = shop.resolve_locator(target_package)
+  }
+
+  if (target_package) {
+    packages = [target_package]
+  } else {
+    packages = shop.list_packages()
+  }
+
+  if (function_hoist) {
+    tokenize_mod = use('tokenize')
+    parse_mod = use('parse')
+
+    arrfor(packages, function(p) {
+      var scripts = shop.get_package_scripts(p)
+      var pkg_dir = shop.get_package_dir(p)
+      if (length(scripts) == 0) return
+
+      arrfor(scripts, function(script) {
+        var src_path = pkg_dir + '/' + script
+        var src = null
+        var tok_result = null
+        var ast = null
+        var scan = function() {
+          if (!fd.is_file(src_path)) return
+          src = text(fd.slurp(src_path))
+          tok_result = tokenize_mod(src, script)
+          ast = parse_mod(tok_result.tokens, src, script, tokenize_mod)
+          if (ast._hoisted_fns != null && length(ast._hoisted_fns) > 0) {
+            log.console(p + '/' + script + ":")
+            hoist_files = hoist_files + 1
+            arrfor(ast._hoisted_fns, function(ref) {
+              var msg = "  " + ref.name
+              if (ref.line != null) msg = msg + " (ref line " + text(ref.line)
+              if (ref.decl_line != null) msg = msg + ", declared line " + text(ref.decl_line)
+              if (ref.line != null) msg = msg + ")"
+              log.console(msg)
+              hoist_refs = hoist_refs + 1
+            })
+          }
+        } disruption {
+          // skip files that fail to parse
+        }
+        scan()
+      })
+    })
+
+    log.console("")
+    log.console("Summary: " + text(hoist_files) + " files with function hoisting, " + text(hoist_refs) + " total forward references")
+    return
+  }
+
+  arrfor(packages, function(p) {
+    var scripts = shop.get_package_scripts(p)
+    var result = null
+    var resolution = null
+    if (length(scripts) == 0) return
+
+    log.console("Auditing " + p + " (" + text(length(scripts)) + " scripts)...")
+    result = shop.build_package_scripts(p)
+    total_ok = total_ok + result.ok
+    total_errors = total_errors + length(result.errors)
+    total_scripts = total_scripts + result.total
+
+    arrfor(result.errors, function(e) {
+      all_failures[] = p + ": " + e
+    })
+
+    // Check use() resolution
+    resolution = shop.audit_use_resolution(p)
+    arrfor(resolution.unresolved, function(u) {
+      all_unresolved[] = p + '/' + u.script + ": use('" + u.module + "') cannot be resolved"
+    })
+  })
+
+  log.console("")
+  if (length(all_failures) > 0) {
+    log.console("Failed scripts:")
+    arrfor(all_failures, function(f) {
+      log.console("  " + f)
+    })
+    log.console("")
+  }
+
+  if (length(all_unresolved) > 0) {
+    log.console("Unresolved modules:")
+    arrfor(all_unresolved, function(u) {
+      log.console("  " + u)
+    })
+    log.console("")
+  }
+
+  summary = "Audit complete: " + text(total_ok) + "/" + text(total_scripts) + " scripts compiled"
+  if (total_errors > 0) summary = summary + ", " + text(total_errors) + " failed"
+  if (length(all_unresolved) > 0) summary = summary + ", " + text(length(all_unresolved)) + " unresolved use() calls"
+  log.console(summary)
+}
+run()

bench.ce

@@ -1,18 +1,39 @@
+// cell bench - Run benchmarks with statistical analysis
+
 var shop = use('internal/shop')
 var pkg = use('package')
 var fd = use('fd')
 var time = use('time')
 var json = use('json')
 var blob = use('blob')
-var os = use('os')
+var os = use('internal/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
 var all_pkgs = false
+var bench_mode = "bytecode" // "bytecode", "native", or "compare"
+
+// Strip mode flags from args before parsing
+function strip_mode_flags() {
+  var filtered = []
+  arrfor(_args, function(a) {
+    if (a == '--native') {
+      bench_mode = "native"
+    } else if (a == '--bytecode') {
+      bench_mode = "bytecode"
+    } else if (a == '--compare') {
+      bench_mode = "compare"
+    } else {
+      filtered[] = a
+    }
+  })
+  _args = filtered
+}
+strip_mode_flags()
 
 // Benchmark configuration
 def WARMUP_BATCHES = 3
@@ -24,63 +45,50 @@ def MAX_BATCH_SIZE = 100000000 // 100M iterations max per batch
 
 // Statistical functions
 function median(arr) {
-  if (arr.length == 0) return 0
-  var sorted = arr.slice().sort(function(a, b) { return a - b })
-  var mid = number.floor(arr.length / 2)
-  if (arr.length % 2 == 0) {
+  if (length(arr) == 0) return 0
+  var sorted = sort(arr)
+  var mid = floor(length(arr) / 2)
+  if (length(arr) % 2 == 0) {
     return (sorted[mid - 1] + sorted[mid]) / 2
   }
   return sorted[mid]
 }
 
 function mean(arr) {
-  if (arr.length == 0) return 0
+  if (length(arr) == 0) return 0
   var sum = 0
-  for (var i = 0; i < arr.length; i++) {
-    sum += arr[i]
-  }
-  return sum / arr.length
+  arrfor(arr, function(val) {
+    sum += val
+  })
+  return sum / length(arr)
 }
 
 function stddev(arr, mean_val) {
-  if (arr.length < 2) return 0
+  if (length(arr) < 2) return 0
   var sum_sq_diff = 0
-  for (var i = 0; i < arr.length; i++) {
-    var diff = arr[i] - mean_val
+  arrfor(arr, function(val) {
+    var diff = val - mean_val
     sum_sq_diff += diff * diff
-  }
-  return math.sqrt(sum_sq_diff / (arr.length - 1))
+  })
+  return math.sqrt(sum_sq_diff / (length(arr) - 1))
 }
 
 function percentile(arr, p) {
-  if (arr.length == 0) return 0
-  var sorted = arr.slice().sort(function(a, b) { return a - b })
-  var idx = number.floor(arr.length * p / 100)
-  if (idx >= arr.length) idx = arr.length - 1
+  if (length(arr) == 0) return 0
+  var sorted = sort(arr)
+  var idx = floor(length(arr) * p / 100)
+  if (idx >= length(arr)) idx = length(arr) - 1
   return sorted[idx]
 }
 
-function min_val(arr) {
-  if (arr.length == 0) return 0
-  var m = arr[0]
-  for (var i = 1; i < arr.length; i++) {
-    if (arr[i] < m) m = arr[i]
-  }
-  return m
-}
-
-function max_val(arr) {
-  if (arr.length == 0) return 0
-  var m = arr[0]
-  for (var i = 1; i < arr.length; i++) {
-    if (arr[i] > m) m = arr[i]
-  }
-  return m
-}
-
 // Parse arguments similar to test.ce
 function parse_args() {
-  if (args.length == 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
@@ -89,7 +97,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
@@ -98,28 +106,28 @@ function parse_args() {
     return true
   }
 
-  if (args[0] == 'package') {
-    if (args.length < 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 (name.startsWith('/') && testlib.is_valid_package(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 {
@@ -132,8 +140,8 @@ function parse_args() {
       }
     }
 
-    if (args.length >= 3) {
-      target_bench = args[2]
+    if (length(_args) >= 3) {
+      target_bench = _args[2]
     }
 
     log.console(`Benchmarking package: ${target_pkg}`)
@@ -141,10 +149,10 @@ 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 (!bench_path.startsWith('benches/') && !bench_path.startsWith('/')) {
+  if (!starts_with(bench_path, 'benches/') && !starts_with(bench_path, '/')) {
     if (!fd.is_file(bench_path + '.cm') && !fd.is_file(bench_path)) {
       if (fd.is_file('benches/' + bench_path + '.cm') || fd.is_file('benches/' + bench_path)) {
         bench_path = 'benches/' + bench_path
@@ -177,19 +185,21 @@ function collect_benches(package_name, specific_bench) {
 
   var files = pkg.list_files(package_name)
   var bench_files = []
-  for (var i = 0; i < files.length; i++) {
-    var f = files[i]
-    if (f.startsWith("benches/") && f.endsWith(".cm")) {
+  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 = f.substring(0, f.length - 3)
-        var match_name = specific_bench
-        if (!match_name.startsWith('benches/')) match_name = 'benches/' + match_name
-        var match_base = match_name.endsWith('.cm') ? match_name.substring(0, match_name.length - 3) : match_name
-        if (bench_name != match_base) continue
+        bench_name = text(f, 0, -3)
+        match_name = specific_bench
+        if (!starts_with(match_name, 'benches/')) match_name = 'benches/' + match_name
+        match_base = ends_with(match_name, '.cm') ? text(match_name, 0, -3) : match_name
+        if (bench_name != match_base) return
       }
-      bench_files.push(f)
+      bench_files[] = f
     }
-  }
+  })
   return bench_files
 }
 
@@ -199,25 +209,26 @@ 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 (typeof n != 'number' || n < 1) {
+    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
-    if (typeof new_n != 'number' || new_n > MAX_BATCH_SIZE) {
+    new_n = n * 2
+    if (!is_number(new_n) || new_n > MAX_BATCH_SIZE) {
       n = MAX_BATCH_SIZE
       break
     }
@@ -225,12 +236,11 @@ function calibrate_batch_size(bench_fn, is_batch) {
   }
 
   // Adjust to target sample duration
-  if (dt > 0 && dt < TARGET_SAMPLE_NS && typeof n == 'number' && typeof dt == 'number') {
-    var calc = n * TARGET_SAMPLE_NS / dt
-    if (typeof calc == 'number' && calc > 0) {
-      var target_n = number.floor(calc)
-      // Check if floor returned a valid number
-      if (typeof target_n == 'number' && target_n > 0) {
+  if (dt > 0 && dt < TARGET_SAMPLE_NS && is_number(n) && is_number(dt)) {
+    calc = n * TARGET_SAMPLE_NS / dt
+    if (is_number(calc) && calc > 0) {
+      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
         n = target_n
@@ -238,8 +248,7 @@ function calibrate_batch_size(bench_fn, is_batch) {
     }
   }
 
-  // Safety check - ensure we always return a valid batch size
-  if (typeof n != 'number' || n < 1) {
+  if (!is_number(n) || n < 1) {
     n = 1
   }
 
@@ -249,71 +258,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 = typeof bench_fn == 'object' && bench_fn.run
+  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 (typeof batch_size != 'number' || batch_size < 1) {
+    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
-    if (typeof batch_size != 'number' || batch_size < 1) {
-      log.console(`WARNING: batch_size became ${typeof batch_size} = ${batch_size}, resetting to 1`)
+  for (i = 0; i < WARMUP_BATCHES; i++) {
+    if (!is_number(batch_size) || batch_size < 1) {
       batch_size = 1
     }
 
     if (is_structured) {
-      var state = setup_fn()
+      state = setup_fn()
       if (is_batch) {
         run_fn(batch_size, state)
       } else {
@@ -330,65 +338,63 @@ 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)
-    if (typeof batch_size != 'number' || batch_size < 1) {
+  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
-      timings_per_op.push(ns_per_op)
+      ns_per_op = is_batch ? duration / batch_size : duration
+      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
-      timings_per_op.push(ns_per_op)
+      ns_per_op = is_batch ? duration / batch_size : duration
+      timings_per_op[] = ns_per_op
     }
   }
 
   // Calculate statistics
   var mean_ns = mean(timings_per_op)
   var median_ns = median(timings_per_op)
-  var min_ns = min_val(timings_per_op)
-  var max_ns = max_val(timings_per_op)
+  var min_ns = reduce(timings_per_op, min)
+  var max_ns = reduce(timings_per_op, max)
   var stddev_ns = stddev(timings_per_op, mean_ns)
   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 = number.floor(1000000000 / median_ns)
+    ops_per_sec = floor(1000000000 / median_ns)
   }
 
   return {
     name: bench_name,
     batch_size: batch_size,
     samples: SAMPLES,
-    mean_ns: number.round(mean_ns),
-    median_ns: number.round(median_ns),
-    min_ns: number.round(min_ns),
-    max_ns: number.round(max_ns),
-    stddev_ns: number.round(stddev_ns),
-    p95_ns: number.round(p95_ns),
-    p99_ns: number.round(p99_ns),
+    mean_ns: round(mean_ns),
+    median_ns: round(median_ns),
+    min_ns: round(min_ns),
+    max_ns: round(max_ns),
+    stddev_ns: round(stddev_ns),
+    p95_ns: round(p95_ns),
+    p99_ns: round(p99_ns),
     ops_per_sec: ops_per_sec
   }
 }
@@ -396,17 +402,64 @@ function run_single_bench(bench_fn, bench_name) {
 // Format nanoseconds for display
 function format_ns(ns) {
   if (ns < 1000) return `${ns}ns`
-  if (ns < 1000000) return `${number.round(ns / 1000 * 100) / 100}µs`
-  if (ns < 1000000000) return `${number.round(ns / 1000000 * 100) / 100}ms`
-  return `${number.round(ns / 1000000000 * 100) / 100}s`
+  if (ns < 1000000) return `${round(ns / 1000 * 100) / 100}µs`
+  if (ns < 1000000000) return `${round(ns / 1000000 * 100) / 100}ms`
+  return `${round(ns / 1000000000 * 100) / 100}s`
 }
 
 // Format ops/sec for display
 function format_ops(ops) {
   if (ops < 1000) return `${ops} ops/s`
-  if (ops < 1000000) return `${number.round(ops / 1000 * 100) / 100}K ops/s`
-  if (ops < 1000000000) return `${number.round(ops / 1000000 * 100) / 100}M ops/s`
-  return `${number.round(ops / 1000000000 * 100) / 100}G ops/s`
+  if (ops < 1000000) return `${round(ops / 1000 * 100) / 100}K ops/s`
+  if (ops < 1000000000) return `${round(ops / 1000000 * 100) / 100}M ops/s`
+  return `${round(ops / 1000000000 * 100) / 100}G ops/s`
+}
+
+// Load a module for benchmarking in the given mode
+// Returns the module value, or null on failure
+function resolve_bench_load(f, package_name) {
+  var mod_path = text(f, 0, -3)
+  var use_pkg = package_name ? package_name : fd.realpath('.')
+  var prefix = testlib.get_pkg_dir(package_name)
+  var src_path = prefix + '/' + f
+  return {mod_path, use_pkg, src_path}
+}
+
+function load_bench_module_native(f, package_name) {
+  var r = resolve_bench_load(f, package_name)
+  return shop.use_native(r.src_path, r.use_pkg)
+}
+
+function load_bench_module(f, package_name, mode) {
+  var r = resolve_bench_load(f, package_name)
+  if (mode == "native") {
+    return load_bench_module_native(f, package_name)
+  }
+  return shop.use(r.mod_path, r.use_pkg)
+}
+
+// Collect benchmark functions from a loaded module
+function collect_bench_fns(bench_mod) {
+  var benches = []
+  if (is_function(bench_mod)) {
+    benches[] = {name: 'main', fn: bench_mod}
+  } else if (is_object(bench_mod)) {
+    arrfor(array(bench_mod), function(k) {
+      if (is_function(bench_mod[k]))
+        benches[] = {name: k, fn: bench_mod[k]}
+    })
+  }
+  return benches
+}
+
+// Print results for a single benchmark
+function print_bench_result(result, label) {
+  var prefix = label ? `[${label}] ` : ''
+  log.console(`    ${prefix}${format_ns(result.median_ns)}/op  ${format_ops(result.ops_per_sec)}`)
+  log.console(`    ${prefix}min: ${format_ns(result.min_ns)}  max: ${format_ns(result.max_ns)}  stddev: ${format_ns(result.stddev_ns)}`)
+  if (result.batch_size > 1) {
+    log.console(`    ${prefix}batch: ${result.batch_size}  samples: ${result.samples}`)
+  }
 }
 
 // Run benchmarks for a package
@@ -419,151 +472,198 @@ function run_benchmarks(package_name, specific_bench) {
     total: 0
   }
 
-  if (bench_files.length == 0) return pkg_result
+  if (length(bench_files) == 0) return pkg_result
 
-  if (package_name) log.console(`Running benchmarks for ${package_name}`)
-  else log.console(`Running benchmarks for local package`)
+  var mode_label = bench_mode == "compare" ? "bytecode vs native" : bench_mode
+  if (package_name) log.console(`Running benchmarks for ${package_name} (${mode_label})`)
+  else log.console(`Running benchmarks for local package (${mode_label})`)
 
-  for (var i = 0; i < bench_files.length; i++) {
-    var f = bench_files[i]
-    var mod_path = f.substring(0, f.length - 3)
+  arrfor(bench_files, function(f) {
+    var load_error = false
+    var benches = []
+    var native_benches = []
+    var bench_mod = null
+    var native_mod = null
+    var error_result = null
 
     var file_result = {
       name: f,
       benchmarks: []
     }
 
-    try {
-      var bench_mod
-      var use_pkg = package_name ? package_name : fd.realpath('.')
-      bench_mod = shop.use(mod_path, use_pkg)
-
-      var benches = []
-      if (typeof bench_mod == 'function') {
-        benches.push({name: 'main', fn: bench_mod})
-      } else if (typeof bench_mod == 'object') {
-        for (var k in bench_mod) {
-          if (typeof bench_mod[k] == 'function') {
-            benches.push({name: k, fn: bench_mod[k]})
-          }
+    var _load_file = function() {
+      var _load_native = null
+      if (bench_mode == "compare") {
+        bench_mod = load_bench_module(f, package_name, "bytecode")
+        benches = collect_bench_fns(bench_mod)
+        _load_native = function() {
+          native_mod = load_bench_module(f, package_name, "native")
+          native_benches = collect_bench_fns(native_mod)
+        } disruption {
+          log.console(`  ${f}: native compilation failed, comparing skipped`)
+          native_benches = []
         }
+        _load_native()
+      } else {
+        bench_mod = load_bench_module(f, package_name, bench_mode)
+        benches = collect_bench_fns(bench_mod)
       }
 
-      if (benches.length > 0) {
+      if (length(benches) > 0) {
         log.console(`  ${f}`)
-        for (var j = 0; j < benches.length; j++) {
-          var b = benches[j]
-          try {
-            var result = run_single_bench(b.fn, b.name)
+        arrfor(benches, function(b) {
+          var bench_error = false
+          var result = null
+          var nat_b = null
+          var nat_error = false
+          var nat_result = null
+
+          var _run_bench = function() {
+            var speedup = 0
+            var _run_nat = null
+            result = run_single_bench(b.fn, b.name)
             result.package = pkg_result.package
-            file_result.benchmarks.push(result)
+            result.mode = bench_mode == "compare" ? "bytecode" : bench_mode
+            file_result.benchmarks[] = result
             pkg_result.total++
 
             log.console(`    ${result.name}`)
-            log.console(`      ${format_ns(result.median_ns)}/op  ${format_ops(result.ops_per_sec)}`)
-            log.console(`      min: ${format_ns(result.min_ns)}  max: ${format_ns(result.max_ns)}  stddev: ${format_ns(result.stddev_ns)}`)
-            if (result.batch_size > 1) {
-              log.console(`      batch: ${result.batch_size}  samples: ${result.samples}`)
+            if (bench_mode == "compare") {
+              print_bench_result(result, "bytecode")
+
+              // Find matching native bench and run it
+              nat_b = find(native_benches, function(nb) { return nb.name == b.name })
+              if (nat_b != null) {
+                _run_nat = function() {
+                  nat_result = run_single_bench(native_benches[nat_b].fn, b.name)
+                  nat_result.package = pkg_result.package
+                  nat_result.mode = "native"
+                  file_result.benchmarks[] = nat_result
+                  pkg_result.total++
+                  print_bench_result(nat_result, "native ")
+
+                  if (nat_result.median_ns > 0) {
+                    speedup = result.median_ns / nat_result.median_ns
+                    log.console(`    speedup: ${round(speedup * 100) / 100}x`)
+                  }
+                } disruption {
+                  nat_error = true
+                }
+                _run_nat()
+                if (nat_error) {
+                  log.console(`    [native ] ERROR`)
+                }
+              } else {
+                log.console(`    [native ] (no matching function)`)
+              }
+            } else {
+              print_bench_result(result, null)
             }
-          } 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"
             }
-            file_result.benchmarks.push(error_result)
+            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"
       }
-      file_result.benchmarks.push(error_result)
+      file_result.benchmarks[] = error_result
       pkg_result.total++
     }
 
-    if (file_result.benchmarks.length > 0) {
-      pkg_result.files.push(file_result)
+    if (length(file_result.benchmarks) > 0) {
+      pkg_result.files[] = file_result
     }
-  }
+  })
 
   return pkg_result
 }
 
 // Run all benchmarks
 var all_results = []
+var packages = null
 
 if (all_pkgs) {
   if (testlib.is_valid_package('.')) {
-    all_results.push(run_benchmarks(null, null))
+    all_results[] = run_benchmarks(null, null)
   }
 
-  var packages = shop.list_packages()
-  for (var i = 0; i < packages.length; i++) {
-    all_results.push(run_benchmarks(packages[i], null))
-  }
+  packages = shop.list_packages()
+  arrfor(packages, function(p) {
+    all_results[] = run_benchmarks(p, null)
+  })
 } else {
-  all_results.push(run_benchmarks(target_pkg, target_bench))
+  all_results[] = run_benchmarks(target_pkg, target_bench)
 }
 
 // Calculate totals
 var total_benches = 0
-for (var i = 0; i < all_results.length; i++) {
-  total_benches += all_results[i].total
-}
+arrfor(all_results, function(result) {
+  total_benches += result.total
+})
 
 log.console(`----------------------------------------`)
 log.console(`Benchmarks: ${total_benches} total`)
 
 // Generate reports
 function generate_reports() {
-  var timestamp = text(number.floor(time.number()))
+  var timestamp = text(floor(time.number()))
   var report_dir = shop.get_reports_dir() + '/bench_' + timestamp
   testlib.ensure_dir(report_dir)
 
+  var mode_str = bench_mode == "compare" ? "bytecode vs native" : bench_mode
   var txt_report = `BENCHMARK REPORT
 Date: ${time.text(time.number())}
+Mode: ${mode_str}
 Total benchmarks: ${total_benches}
 
 === SUMMARY ===
 `
-  for (var i = 0; i < all_results.length; i++) {
-    var pkg_res = all_results[i]
-    if (pkg_res.total == 0) continue
+  arrfor(all_results, function(pkg_res) {
+    if (pkg_res.total == 0) return
     txt_report += `Package: ${pkg_res.package}\n`
-    for (var j = 0; j < pkg_res.files.length; j++) {
-      var f = pkg_res.files[j]
+    arrfor(pkg_res.files, function(f) {
       txt_report += `  ${f.name}\n`
-      for (var k = 0; k < f.benchmarks.length; k++) {
-        var b = f.benchmarks[k]
+      arrfor(f.benchmarks, function(b) {
+        var mode_tag = b.mode ? ` [${b.mode}]` : ''
         if (b.error) {
           txt_report += `    ERROR ${b.name}: ${b.error}\n`
         } else {
-          txt_report += `    ${b.name}: ${format_ns(b.median_ns)}/op (${format_ops(b.ops_per_sec)})\n`
+          txt_report += `    ${b.name}${mode_tag}: ${format_ns(b.median_ns)}/op (${format_ops(b.ops_per_sec)})\n`
         }
-      }
-    }
-  }
+      })
+    })
+  })
 
   txt_report += `\n=== DETAILED RESULTS ===\n`
-  for (var i = 0; i < all_results.length; i++) {
-    var pkg_res = all_results[i]
-    if (pkg_res.total == 0) continue
+  arrfor(all_results, function(pkg_res) {
+    if (pkg_res.total == 0) return
 
-    for (var j = 0; j < pkg_res.files.length; j++) {
-      var f = pkg_res.files[j]
-      for (var k = 0; k < f.benchmarks.length; k++) {
-        var b = f.benchmarks[k]
-        if (b.error) continue
+    arrfor(pkg_res.files, function(f) {
+      arrfor(f.benchmarks, function(b) {
+        if (b.error) return
 
-        txt_report += `\n${pkg_res.package}::${b.name}\n`
+        var detail_mode = b.mode ? ` [${b.mode}]` : ''
+        txt_report += `\n${pkg_res.package}::${b.name}${detail_mode}\n`
         txt_report += `  batch_size: ${b.batch_size}  samples: ${b.samples}\n`
         txt_report += `  median: ${format_ns(b.median_ns)}/op\n`
         txt_report += `  mean: ${format_ns(b.mean_ns)}/op\n`
@@ -573,30 +673,28 @@ Total benchmarks: ${total_benches}
         txt_report += `  p95: ${format_ns(b.p95_ns)}\n`
         txt_report += `  p99: ${format_ns(b.p99_ns)}\n`
         txt_report += `  ops/s: ${format_ops(b.ops_per_sec)}\n`
-      }
-    }
-  }
+      })
+    })
+  })
 
   testlib.ensure_dir(report_dir)
-  fd.slurpwrite(`${report_dir}/bench.txt`, stone(new blob(txt_report)))
+  fd.slurpwrite(`${report_dir}/bench.txt`, stone(blob(txt_report)))
   log.console(`Report written to ${report_dir}/bench.txt`)
 
   // Generate JSON per package
-  for (var i = 0; i < all_results.length; i++) {
-    var pkg_res = all_results[i]
-    if (pkg_res.total == 0) continue
+  arrfor(all_results, function(pkg_res) {
+    if (pkg_res.total == 0) return
 
     var pkg_benches = []
-    for (var j = 0; j < pkg_res.files.length; j++) {
-      var f = pkg_res.files[j]
-      for (var k = 0; k < f.benchmarks.length; k++) {
-        pkg_benches.push(f.benchmarks[k])
-      }
-    }
+    arrfor(pkg_res.files, function(f) {
+      arrfor(f.benchmarks, function(benchmark) {
+        pkg_benches[] = benchmark
+      })
+    })
 
-    var json_path = `${report_dir}/${pkg_res.package.replace(/\//g, '_')}.json`
-    fd.slurpwrite(json_path, stone(new blob(json.encode(pkg_benches))))
-  }
+    var json_path = `${report_dir}/${replace(pkg_res.package, /\//, '_')}.json`
+    fd.slurpwrite(json_path, stone(blob(json.encode(pkg_benches))))
+  })
 }
 
 generate_reports()

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 mailbox.queue[]
+}
+
+function drain(mailbox) {
+  var count = 0
+  while (length(mailbox.queue) > 0) {
+    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
+    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) {
+      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] = []
+    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
+    }
+    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++) {
+    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]
+    })
+    constraints[] = c
+    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++) {
+    src[] = make_variable(`src${i}`, i * 10)
+    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]
+    })
+    constraints[] = scale_c
+    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/encoders.cm

@@ -0,0 +1,405 @@
+// encoders.cm — nota/wota/json encode+decode benchmark
+// Isolates per-type bottlenecks across all three serializers.
+
+var nota = use('internal/nota')
+var wota = use('internal/wota')
+var json = use('json')
+
+// --- Test data shapes ---
+
+// Small integers: fast path for all encoders
+var integers_small = array(100, function(i) { return i + 1 })
+
+// Floats: stresses nota's snprintf path
+var floats_array = array(100, function(i) {
+  return 3.14159 * (i + 1) + 0.00001 * i
+})
+
+// Short strings in records: per-string overhead, property enumeration
+var strings_short = array(50, function(i) {
+  var r = {}
+  r[`k${i}`] = `value_${i}`
+  return r
+})
+
+// Single long string: throughput test (wota byte loop, nota kim)
+var long_str = ""
+var li = 0
+for (li = 0; li < 100; li++) {
+  long_str = `${long_str}abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMN`
+}
+var strings_long = long_str
+
+// Unicode text: nota's kim encoding, wota's byte packing
+var strings_unicode = "こんにちは世界 🌍🌎🌏 Ñoño café résumé naïve Ω∑∏ 你好世界"
+
+// Nested records: cycle detection, property enumeration
+function make_nested(depth, breadth) {
+  var obj = {}
+  var i = 0
+  var k = null
+  if (depth <= 0) {
+    for (i = 0; i < breadth; i++) {
+      k = `v${i}`
+      obj[k] = i * 2.5
+    }
+    return obj
+  }
+  for (i = 0; i < breadth; i++) {
+    k = `n${i}`
+    obj[k] = make_nested(depth - 1, breadth)
+  }
+  return obj
+}
+var nested_records = make_nested(3, 4)
+
+// Flat record: property enumeration cost
+var flat_record = {}
+var fi = 0
+for (fi = 0; fi < 50; fi++) {
+  flat_record[`prop_${fi}`] = fi * 1.1
+}
+
+// Mixed payload: realistic workload
+var mixed_payload = array(50, function(i) {
+  var r = {}
+  r.id = i
+  r.name = `item_${i}`
+  r.active = i % 2 == 0
+  r.score = i * 3.14
+  r.tags = [`t${i % 5}`, `t${(i + 1) % 5}`]
+  return r
+})
+
+// --- Pre-encode for decode benchmarks ---
+
+var nota_enc_integers = nota.encode(integers_small)
+var nota_enc_floats = nota.encode(floats_array)
+var nota_enc_strings_short = nota.encode(strings_short)
+var nota_enc_strings_long = nota.encode(strings_long)
+var nota_enc_strings_unicode = nota.encode(strings_unicode)
+var nota_enc_nested = nota.encode(nested_records)
+var nota_enc_flat = nota.encode(flat_record)
+var nota_enc_mixed = nota.encode(mixed_payload)
+
+var wota_enc_integers = wota.encode(integers_small)
+var wota_enc_floats = wota.encode(floats_array)
+var wota_enc_strings_short = wota.encode(strings_short)
+var wota_enc_strings_long = wota.encode(strings_long)
+var wota_enc_strings_unicode = wota.encode(strings_unicode)
+var wota_enc_nested = wota.encode(nested_records)
+var wota_enc_flat = wota.encode(flat_record)
+var wota_enc_mixed = wota.encode(mixed_payload)
+
+var json_enc_integers = json.encode(integers_small)
+var json_enc_floats = json.encode(floats_array)
+var json_enc_strings_short = json.encode(strings_short)
+var json_enc_strings_long = json.encode(strings_long)
+var json_enc_strings_unicode = json.encode(strings_unicode)
+var json_enc_nested = json.encode(nested_records)
+var json_enc_flat = json.encode(flat_record)
+var json_enc_mixed = json.encode(mixed_payload)
+
+// --- Benchmark functions ---
+
+return {
+  // NOTA encode
+  nota_encode_integers: function(n) {
+    var i = 0
+    var r = null
+    for (i = 0; i < n; i++) { r = nota.encode(integers_small) }
+    return r
+  },
+  nota_encode_floats: function(n) {
+    var i = 0
+    var r = null
+    for (i = 0; i < n; i++) { r = nota.encode(floats_array) }
+    return r
+  },
+  nota_encode_strings_short: function(n) {
+    var i = 0
+    var r = null
+    for (i = 0; i < n; i++) { r = nota.encode(strings_short) }
+    return r
+  },
+  nota_encode_strings_long: function(n) {
+    var i = 0
+    var r = null
+    for (i = 0; i < n; i++) { r = nota.encode(strings_long) }
+    return r
+  },
+  nota_encode_strings_unicode: function(n) {
+    var i = 0
+    var r = null
+    for (i = 0; i < n; i++) { r = nota.encode(strings_unicode) }
+    return r
+  },
+  nota_encode_nested: function(n) {
+    var i = 0
+    var r = null
+    for (i = 0; i < n; i++) { r = nota.encode(nested_records) }
+    return r
+  },
+  nota_encode_flat: function(n) {
+    var i = 0
+    var r = null
+    for (i = 0; i < n; i++) { r = nota.encode(flat_record) }
+    return r
+  },
+  nota_encode_mixed: function(n) {
+    var i = 0
+    var r = null
+    for (i = 0; i < n; i++) { r = nota.encode(mixed_payload) }
+    return r
+  },
+
+  // NOTA decode
+  nota_decode_integers: function(n) {
+    var i = 0
+    var r = null
+    for (i = 0; i < n; i++) { r = nota.decode(nota_enc_integers) }
+    return r
+  },
+  nota_decode_floats: function(n) {
+    var i = 0
+    var r = null
+    for (i = 0; i < n; i++) { r = nota.decode(nota_enc_floats) }
+    return r
+  },
+  nota_decode_strings_short: function(n) {
+    var i = 0
+    var r = null
+    for (i = 0; i < n; i++) { r = nota.decode(nota_enc_strings_short) }
+    return r
+  },
+  nota_decode_strings_long: function(n) {
+    var i = 0
+    var r = null
+    for (i = 0; i < n; i++) { r = nota.decode(nota_enc_strings_long) }
+    return r
+  },
+  nota_decode_strings_unicode: function(n) {
+    var i = 0
+    var r = null
+    for (i = 0; i < n; i++) { r = nota.decode(nota_enc_strings_unicode) }
+    return r
+  },
+  nota_decode_nested: function(n) {
+    var i = 0
+    var r = null
+    for (i = 0; i < n; i++) { r = nota.decode(nota_enc_nested) }
+    return r
+  },
+  nota_decode_flat: function(n) {
+    var i = 0
+    var r = null
+    for (i = 0; i < n; i++) { r = nota.decode(nota_enc_flat) }
+    return r
+  },
+  nota_decode_mixed: function(n) {
+    var i = 0
+    var r = null
+    for (i = 0; i < n; i++) { r = nota.decode(nota_enc_mixed) }
+    return r
+  },
+
+  // WOTA encode
+  wota_encode_integers: function(n) {
+    var i = 0
+    var r = null
+    for (i = 0; i < n; i++) { r = wota.encode(integers_small) }
+    return r
+  },
+  wota_encode_floats: function(n) {
+    var i = 0
+    var r = null
+    for (i = 0; i < n; i++) { r = wota.encode(floats_array) }
+    return r
+  },
+  wota_encode_strings_short: function(n) {
+    var i = 0
+    var r = null
+    for (i = 0; i < n; i++) { r = wota.encode(strings_short) }
+    return r
+  },
+  wota_encode_strings_long: function(n) {
+    var i = 0
+    var r = null
+    for (i = 0; i < n; i++) { r = wota.encode(strings_long) }
+    return r
+  },
+  wota_encode_strings_unicode: function(n) {
+    var i = 0
+    var r = null
+    for (i = 0; i < n; i++) { r = wota.encode(strings_unicode) }
+    return r
+  },
+  wota_encode_nested: function(n) {
+    var i = 0
+    var r = null
+    for (i = 0; i < n; i++) { r = wota.encode(nested_records) }
+    return r
+  },
+  wota_encode_flat: function(n) {
+    var i = 0
+    var r = null
+    for (i = 0; i < n; i++) { r = wota.encode(flat_record) }
+    return r
+  },
+  wota_encode_mixed: function(n) {
+    var i = 0
+    var r = null
+    for (i = 0; i < n; i++) { r = wota.encode(mixed_payload) }
+    return r
+  },
+
+  // WOTA decode
+  wota_decode_integers: function(n) {
+    var i = 0
+    var r = null
+    for (i = 0; i < n; i++) { r = wota.decode(wota_enc_integers) }
+    return r
+  },
+  wota_decode_floats: function(n) {
+    var i = 0
+    var r = null
+    for (i = 0; i < n; i++) { r = wota.decode(wota_enc_floats) }
+    return r
+  },
+  wota_decode_strings_short: function(n) {
+    var i = 0
+    var r = null
+    for (i = 0; i < n; i++) { r = wota.decode(wota_enc_strings_short) }
+    return r
+  },
+  wota_decode_strings_long: function(n) {
+    var i = 0
+    var r = null
+    for (i = 0; i < n; i++) { r = wota.decode(wota_enc_strings_long) }
+    return r
+  },
+  wota_decode_strings_unicode: function(n) {
+    var i = 0
+    var r = null
+    for (i = 0; i < n; i++) { r = wota.decode(wota_enc_strings_unicode) }
+    return r
+  },
+  wota_decode_nested: function(n) {
+    var i = 0
+    var r = null
+    for (i = 0; i < n; i++) { r = wota.decode(wota_enc_nested) }
+    return r
+  },
+  wota_decode_flat: function(n) {
+    var i = 0
+    var r = null
+    for (i = 0; i < n; i++) { r = wota.decode(wota_enc_flat) }
+    return r
+  },
+  wota_decode_mixed: function(n) {
+    var i = 0
+    var r = null
+    for (i = 0; i < n; i++) { r = wota.decode(wota_enc_mixed) }
+    return r
+  },
+
+  // JSON encode
+  json_encode_integers: function(n) {
+    var i = 0
+    var r = null
+    for (i = 0; i < n; i++) { r = json.encode(integers_small) }
+    return r
+  },
+  json_encode_floats: function(n) {
+    var i = 0
+    var r = null
+    for (i = 0; i < n; i++) { r = json.encode(floats_array) }
+    return r
+  },
+  json_encode_strings_short: function(n) {
+    var i = 0
+    var r = null
+    for (i = 0; i < n; i++) { r = json.encode(strings_short) }
+    return r
+  },
+  json_encode_strings_long: function(n) {
+    var i = 0
+    var r = null
+    for (i = 0; i < n; i++) { r = json.encode(strings_long) }
+    return r
+  },
+  json_encode_strings_unicode: function(n) {
+    var i = 0
+    var r = null
+    for (i = 0; i < n; i++) { r = json.encode(strings_unicode) }
+    return r
+  },
+  json_encode_nested: function(n) {
+    var i = 0
+    var r = null
+    for (i = 0; i < n; i++) { r = json.encode(nested_records) }
+    return r
+  },
+  json_encode_flat: function(n) {
+    var i = 0
+    var r = null
+    for (i = 0; i < n; i++) { r = json.encode(flat_record) }
+    return r
+  },
+  json_encode_mixed: function(n) {
+    var i = 0
+    var r = null
+    for (i = 0; i < n; i++) { r = json.encode(mixed_payload) }
+    return r
+  },
+
+  // JSON decode
+  json_decode_integers: function(n) {
+    var i = 0
+    var r = null
+    for (i = 0; i < n; i++) { r = json.decode(json_enc_integers) }
+    return r
+  },
+  json_decode_floats: function(n) {
+    var i = 0
+    var r = null
+    for (i = 0; i < n; i++) { r = json.decode(json_enc_floats) }
+    return r
+  },
+  json_decode_strings_short: function(n) {
+    var i = 0
+    var r = null
+    for (i = 0; i < n; i++) { r = json.decode(json_enc_strings_short) }
+    return r
+  },
+  json_decode_strings_long: function(n) {
+    var i = 0
+    var r = null
+    for (i = 0; i < n; i++) { r = json.decode(json_enc_strings_long) }
+    return r
+  },
+  json_decode_strings_unicode: function(n) {
+    var i = 0
+    var r = null
+    for (i = 0; i < n; i++) { r = json.decode(json_enc_strings_unicode) }
+    return r
+  },
+  json_decode_nested: function(n) {
+    var i = 0
+    var r = null
+    for (i = 0; i < n; i++) { r = json.decode(json_enc_nested) }
+    return r
+  },
+  json_decode_flat: function(n) {
+    var i = 0
+    var r = null
+    for (i = 0; i < n; i++) { r = json.decode(json_enc_flat) }
+    return r
+  },
+  json_decode_mixed: function(n) {
+    var i = 0
+    var r = null
+    for (i = 0; i < n; i++) { r = json.decode(json_enc_mixed) }
+    return r
+  }
+}

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++) {
+    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++) {
+    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++) {
+    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] = []
+    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++) {
+    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_core.cm

@@ -0,0 +1,302 @@
+// micro_core.cm — direct microbenchmarks for core ops
+
+function blackhole(sink, x) {
+  return (sink + (x | 0)) | 0
+}
+
+function make_obj_xy(x, y) {
+  return {x: x, y: y}
+}
+
+function make_obj_yx(x, y) {
+  // Different insertion order to force a different shape
+  return {y: y, x: x}
+}
+
+function make_packed_array(n) {
+  var a = []
+  var i = 0
+  for (i = 0; i < n; i++) a[] = i
+  return a
+}
+
+function make_holey_array(n) {
+  var a = []
+  var i = 0
+  for (i = 0; i < n; i += 2) a[i] = i
+  return a
+}
+
+return {
+  loop_empty: function(n) {
+    var sink = 0
+    var i = 0
+    for (i = 0; i < n; i++) {}
+    return blackhole(sink, n)
+  },
+
+  i32_add: function(n) {
+    var sink = 0
+    var x = 1
+    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
+    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
+    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
+    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
+    var i = 0
+    for (i = 0; i < n; i++) x = (x + 0x10000000) | 0
+    return blackhole(sink, x)
+  },
+
+  call_direct: function(n) {
+    var sink = 0
+    var f = function(a) { return (a + 1) | 0 }
+    var x = 0
+    var i = 0
+    for (i = 0; i < n; i++) x = f(x)
+    return blackhole(sink, x)
+  },
+
+  call_indirect: function(n) {
+    var sink = 0
+    var f = function(a) { return (a + 1) | 0 }
+    var g = f
+    var x = 0
+    var i = 0
+    for (i = 0; i < n; i++) x = g(x)
+    return blackhole(sink, x)
+  },
+
+  call_closure: function(n) {
+    var sink = 0
+    var make_adder = function(k) {
+      return function(a) { return (a + k) | 0 }
+    }
+    var add3 = make_adder(3)
+    var x = 0
+    var i = 0
+    for (i = 0; i < n; i++) x = add3(x)
+    return blackhole(sink, x)
+  },
+
+  array_read_packed: function(n) {
+    var sink = 0
+    var a = make_packed_array(1024)
+    var x = 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)
+    var i = 0
+    for (i = 0; i < n; i++) a[i & 1023] = i
+    return blackhole(sink, a[17] | 0)
+  },
+
+  array_read_holey: function(n) {
+    var sink = 0
+    var a = make_holey_array(2048)
+    var x = 0
+    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)
+  },
+
+  array_push_steady: function(n) {
+    var sink = 0
+    var x = 0
+    var j = 0
+    var i = 0
+    var a = null
+    for (j = 0; j < n; j++) {
+      a = []
+      for (i = 0; i < 256; i++) a[] = i
+      x = (x + length(a)) | 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)
+  },
+
+  prop_read_mono: function(n) {
+    var sink = 0
+    var o = make_obj_xy(1, 2)
+    var x = 0
+    var i = 0
+    for (i = 0; i < n; i++) x = (x + o.x) | 0
+    return blackhole(sink, x)
+  },
+
+  prop_read_poly_2: function(n) {
+    var sink = 0
+    var a = make_obj_xy(1, 2)
+    var b = make_obj_yx(1, 2)
+    var x = 0
+    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)
+  },
+
+  string_concat_small: 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 < 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_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)
+  },
+
+  guard_hot_number: function(n) {
+    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) {
+    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)
+  },
+
+  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/micro_ops.cm

@@ -1,39 +1,41 @@
-// 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
-    out.push(o)
+    push(out, o)
   }
   return out
 }
 
 function make_packed_array(n) {
   var a = []
-  for (var i = 0; i < n; i++) a.push(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,10 +252,44 @@ 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++) a.push(i)
-      x = (x + a.length) | 0
+    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 = 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)
   },
@@ -213,10 +298,52 @@ return {
   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"
-      x = (x + s.length) | 0
+    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) {
+        tokens[] = buf
+        buf = ""
+      }
+    } else if (ch == "(" || ch == ")" || ch == "+" || ch == "-"
+            || ch == "*" || ch == "=" || ch == ";" || ch == ",") {
+      if (length(buf) > 0) {
+        tokens[] = buf
+        buf = ""
+      }
+      tokens[] = ch
+    } else {
+      buf = buf + ch
+    }
+  }
+  if (length(buf) > 0) 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]
+      ast[] = node
+    } else if (tok == "return") {
+      node = {type: "return", value: null}
+      i++
+      if (i < length(tokens)) node.value = tokens[i]
+      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++
+      ast[] = node
+    } else {
+      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)
+    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)
+        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) queue[] = keys[i]
+  }
+
+  var order = []
+  var current = null
+  var neighbors = null
+  var qi = 0
+  while (qi < length(queue)) {
+    current = queue[qi]
+    qi++
+    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) 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
+    a[] = x % 10000
+  }
+  return a
+}
+
+function make_descending(n) {
+  var a = []
+  var i = 0
+  for (i = n - 1; i >= 0; i--) 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]) {
+      result[] = a[i]
+      i++
+    } else {
+      result[] = b[j]
+      j++
+    }
+  }
+  while (i < length(a)) {
+    result[] = a[i]
+    i++
+  }
+  while (j < length(b)) {
+    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
+    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] = []
+    }
+    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)
+  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++) 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
+  }
+}

benchmarks/binarytree.ce

@@ -1,14 +1,16 @@
 function mainThread() {
-  var maxDepth = number.max(6, Number(arg[0] || 16));
-
+  var maxDepth = max(6, Number(arg[0] || 16));
   var stretchDepth = maxDepth + 1;
   var check = itemCheck(bottomUpTree(stretchDepth));
+  var longLivedTree = null
+  var depth = null
+  var iterations = null
   log.console(`stretch tree of depth ${stretchDepth}\t check: ${check}`);
 
-  var longLivedTree = bottomUpTree(maxDepth);
+  longLivedTree = bottomUpTree(maxDepth);
 
-  for (let depth = 4; depth <= maxDepth; depth += 2) {
-    var iterations = 1 << maxDepth - depth + 4;
+  for (depth = 4; depth <= maxDepth; depth += 2) {
+    iterations = 1 << maxDepth - depth + 4;
     work(iterations, depth);
   }
 
@@ -16,8 +18,9 @@ function mainThread() {
 }
 
 function work(iterations, depth) {
-  let check = 0;
-  for (let i = 0; i < iterations; i++)
+  var check = 0;
+  var i = 0
+  for (i = 0; i < iterations; i++)
     check += itemCheck(bottomUpTree(depth));
   log.console(`${iterations}\t trees of depth ${depth}\t check: ${check}`);
 }
@@ -34,8 +37,8 @@ function itemCheck(node) {
 
 function bottomUpTree(depth) {
   return depth > 0
-    ? new TreeNode(bottomUpTree(depth - 1), bottomUpTree(depth - 1))
-    : new TreeNode(null, null);
+    ? TreeNode(bottomUpTree(depth - 1), bottomUpTree(depth - 1))
+    : TreeNode(null, null);
 }
 
 mainThread()

benchmarks/eratosthenes.ce

@@ -1,15 +1,18 @@
 var blob = use('blob')
 var math = use('math/radians')
 
+var i = 0
+var j = 0
+
 function eratosthenes (n) {
-  var sieve = new blob(n, true)
-  var sqrtN = number.whole(math.sqrt(n));
+  var sieve = blob(n, true)
+  var sqrtN = whole(math.sqrt(n));
 
   for (i = 2; i <= sqrtN; i++)
     if (sieve.read_logical(i))
       for (j = i * i; j <= n; j += i)
           sieve.write_bit(j, false);
-          
+
   return sieve;
 }
 
@@ -17,9 +20,9 @@ var sieve = eratosthenes(10000000);
 stone(sieve)
 
 var c = 0
-for (var i = 0; i < sieve.length; i++)
+for (i = 0; i < length(sieve); i++)
   if (sieve.read_logical(i)) c++
-  
+
 log.console(c)
 
-$stop()
+$stop()

benchmarks/fannkuch.ce

@@ -1,58 +1,65 @@
 function fannkuch(n) {
-   var perm1 = [n]   
-   for (let i = 0; i < n; i++) perm1[i] = i      
+   var perm1 = [n]
+   var i = 0
+   var k = null
+   var r = null
+   var t = null
+   var p0 = null
+   var j = null
+   var more = null
+   for (i = 0; i < n; i++) perm1[i] = i
    var perm = [n]
-   var count = [n]       
-   var f = 0, flips = 0, nperm = 0, checksum = 0      
-   var i, k, r      
-  
+   var count = [n]
+   var f = 0
+   var flips = 0
+   var nperm = 0
+   var checksum = 0
+
    r = n
-   while (r > 0) { 
-      i = 0  
-      while (r != 1) { count[r-1] = r; r -= 1 }   
-      while (i < n) { perm[i] = perm1[i]; i += 1 }     
-        
-      // Count flips and update max and checksum
+   while (r > 0) {
+      i = 0
+      while (r != 1) { count[r-1] = r; r -= 1 }
+      while (i < n) { perm[i] = perm1[i]; i += 1 }
+
       f = 0
-      k = perm[0]  
+      k = perm[0]
       while (k != 0) {
-         i = 0  
-         while (2*i < k) {          
-            let t = perm[i]; perm[i] = perm[k-i]; perm[k-i] = t  
-            i += 1           
+         i = 0
+         while (2*i < k) {
+            t = perm[i]; perm[i] = perm[k-i]; perm[k-i] = t
+            i += 1
          }
          k = perm[0]
-         f += 1   
-      }         
-      if (f > flips) flips = f         
+         f += 1
+      }
+      if (f > flips) flips = f
       if ((nperm & 0x1) == 0) checksum += f; else checksum -= f
-   
-      // Use incremental change to generate another permutation   
-      var more = true
-      while (more) {   
+
+      more = true
+      while (more) {
          if (r == n) {
-            log.console( checksum )               
-            return flips 
+            log.console( checksum )
+            return flips
          }
-         let p0 = perm1[0]
+         p0 = perm1[0]
          i = 0
          while (i < r) {
-            let j = i + 1
+            j = i + 1
             perm1[i] = perm1[j]
-            i = j            
+            i = j
          }
-         perm1[r] = p0 
-         
-         count[r] -= 1        
-         if (count[r] > 0) more = false; else r += 1 
+         perm1[r] = p0
+
+         count[r] -= 1
+         if (count[r] > 0) more = false; else r += 1
       }
       nperm += 1
    }
-   return flips;      
+   return flips;
 }
-   
+
 var n = arg[0] || 10
-       
+
 log.console(`Pfannkuchen(${n}) = ${fannkuch(n)}`)
 
 $stop()

benchmarks/fib.ce

@@ -7,9 +7,9 @@ function fib(n) {
 
 var now = time.number()
 var arr = [1,2,3,4,5]
-for (var i in arr) {
+arrfor(arr, function(i) {
   log.console(fib(28))
-}
+})
 
 log.console(`elapsed: ${time.number()-now}`)
 

benchmarks/hyperfine_wota_nota_json.sh

@@ -1,20 +0,0 @@
-#!/bin/bash
-
-# Run hyperfine with parameter lists
-# This will create a cross-product of all libraries × all scenarios
-hyperfine \
---warmup 3 \
---runs 20 \
--i \
---export-csv      wota_vs_nota_vs_json.csv \
---export-json     wota_vs_nota_vs_json.json \
---export-markdown wota_vs_nota_vs_json.md \
---parameter-list lib  wota,nota,json \
---parameter-list scen empty,integers,floats,strings,objects,nested,large_array \
-'cell benchmarks/wota_nota_json {lib} {scen}'
-
-
-echo "Benchmark complete! Results saved to:"
-echo "  - wota_vs_nota_vs_json.csv"
-echo "  - wota_vs_nota_vs_json.json"
-echo "  - wota_vs_nota_vs_json.md"

benchmarks/js_perf.ce

@@ -1,22 +1,12 @@
 var time = use('time')
 var math = use('math/radians')
 
-////////////////////////////////////////////////////////////////////////////////
-// JavaScript Performance Benchmark Suite
-// Tests core JS operations: property access, function calls, arithmetic, etc.
-////////////////////////////////////////////////////////////////////////////////
-
-// Test configurations
 def iterations = {
   simple: 10000000,
   medium: 1000000,
   complex: 100000
 };
 
-////////////////////////////////////////////////////////////////////////////////
-// Utility: measureTime(fn) => how long fn() takes in seconds
-////////////////////////////////////////////////////////////////////////////////
-
 function measureTime(fn) {
   var start = time.number();
   fn();
@@ -24,26 +14,24 @@ function measureTime(fn) {
   return (end - start);
 }
 
-////////////////////////////////////////////////////////////////////////////////
-// Benchmark: Property Access
-////////////////////////////////////////////////////////////////////////////////
-
 function benchPropertyAccess() {
   var obj = {
     a: 1, b: 2, c: 3, d: 4, e: 5,
     nested: { x: 10, y: 20, z: 30 }
   };
-  
+
   var readTime = measureTime(function() {
     var sum = 0;
-    for (var i = 0; i < iterations.simple; i++) {
+    var i = 0
+    for (i = 0; i < iterations.simple; i++) {
       sum += obj.a + obj.b + obj.c + obj.d + obj.e;
       sum += obj.nested.x + obj.nested.y + obj.nested.z;
     }
   });
-  
+
   var writeTime = measureTime(function() {
-    for (var i = 0; i < iterations.simple; i++) {
+    var i = 0
+    for (i = 0; i < iterations.simple; i++) {
       obj.a = i;
       obj.b = i + 1;
       obj.c = i + 2;
@@ -51,49 +39,48 @@ function benchPropertyAccess() {
       obj.nested.y = i * 3;
     }
   });
-  
+
   return { readTime: readTime, writeTime: writeTime };
 }
 
-////////////////////////////////////////////////////////////////////////////////
-// Benchmark: Function Calls
-////////////////////////////////////////////////////////////////////////////////
-
 function benchFunctionCalls() {
   function add(a, b) { return a + b; }
   function multiply(a, b) { return a * b; }
   function complexCalc(a, b, c) { return (a + b) * c / 2; }
-  
+
   var obj = {
     method: function(x) { return x * 2; },
     nested: {
       deepMethod: function(x, y) { return x + y; }
     }
   };
-  
+
   var simpleCallTime = measureTime(function() {
     var result = 0;
-    for (var i = 0; i < iterations.simple; i++) {
+    var i = 0
+    for (i = 0; i < iterations.simple; i++) {
       result = add(i, 1);
       result = multiply(result, 2);
     }
   });
-  
+
   var methodCallTime = measureTime(function() {
     var result = 0;
-    for (var i = 0; i < iterations.simple; i++) {
+    var i = 0
+    for (i = 0; i < iterations.simple; i++) {
       result = obj.method(i);
       result = obj.nested.deepMethod(result, i);
     }
   });
-  
+
   var complexCallTime = measureTime(function() {
     var result = 0;
-    for (var i = 0; i < iterations.medium; i++) {
+    var i = 0
+    for (i = 0; i < iterations.medium; i++) {
       result = complexCalc(i, i + 1, i + 2);
     }
   });
-  
+
   return {
     simpleCallTime: simpleCallTime,
     methodCallTime: methodCallTime,
@@ -101,37 +88,39 @@ function benchFunctionCalls() {
   };
 }
 
-////////////////////////////////////////////////////////////////////////////////
-// Benchmark: Array Operations
-////////////////////////////////////////////////////////////////////////////////
-
 function benchArrayOps() {
+  var i = 0
+
   var pushTime = measureTime(function() {
     var arr = [];
-    for (var i = 0; i < iterations.medium; i++) {
-      arr.push(i);
+    var j = 0
+    for (j = 0; j < iterations.medium; j++) {
+      arr[] = j;
     }
   });
-  
+
   var arr = [];
-  for (var i = 0; i < 10000; i++) arr.push(i);
-  
+  for (i = 0; i < 10000; i++) arr[] = i;
+
   var accessTime = measureTime(function() {
     var sum = 0;
-    for (var i = 0; i < iterations.medium; i++) {
-      sum += arr[i % 10000];
+    var j = 0
+    for (j = 0; j < iterations.medium; j++) {
+      sum += arr[j % 10000];
     }
   });
-  
+
   var iterateTime = measureTime(function() {
     var sum = 0;
-    for (var j = 0; j < 1000; j++) {
-      for (var i = 0; i < arr.length; i++) {
-        sum += arr[i];
+    var j = 0
+    var k = 0
+    for (j = 0; j < 1000; j++) {
+      for (k = 0; k < length(arr); k++) {
+        sum += arr[k];
       }
     }
   });
-  
+
   return {
     pushTime: pushTime,
     accessTime: accessTime,
@@ -139,28 +128,27 @@ function benchArrayOps() {
   };
 }
 
-////////////////////////////////////////////////////////////////////////////////
-// Benchmark: Object Creation
-////////////////////////////////////////////////////////////////////////////////
-
 function benchObjectCreation() {
   var literalTime = measureTime(function() {
-    for (var i = 0; i < iterations.medium; i++) {
-      var obj = { x: i, y: i * 2, z: i * 3 };
+    var i = 0
+    var obj = null
+    for (i = 0; i < iterations.medium; i++) {
+      obj = { x: i, y: i * 2, z: i * 3 };
     }
   });
-  
+
   function Point(x, y) {
-    this.x = x;
-    this.y = y;
+    return {x,y}
   }
-  
+
   var defructorTime = measureTime(function() {
-    for (var i = 0; i < iterations.medium; i++) {
-      var p = new Point(i, i * 2);
+    var i = 0
+    var p = null
+    for (i = 0; i < iterations.medium; i++) {
+      p = Point(i, i * 2);
     }
   });
-  
+
   var protoObj = {
     x: 0,
     y: 0,
@@ -169,15 +157,17 @@ function benchObjectCreation() {
       this.y += dy;
     }
   };
-  
+
   var prototypeTime = measureTime(function() {
-    for (var i = 0; i < iterations.medium; i++) {
-      var obj = meme(protoObj);
+    var i = 0
+    var obj = null
+    for (i = 0; i < iterations.medium; i++) {
+      obj = meme(protoObj);
       obj.x = i;
       obj.y = i * 2;
     }
   });
-  
+
   return {
     literalTime: literalTime,
     defructorTime: defructorTime,
@@ -185,36 +175,39 @@ function benchObjectCreation() {
   };
 }
 
-////////////////////////////////////////////////////////////////////////////////
-// Benchmark: String Operations
-////////////////////////////////////////////////////////////////////////////////
-
 function benchStringOps() {
+  var i = 0
+  var strings = [];
+
   var concatTime = measureTime(function() {
     var str = "";
-    for (var i = 0; i < iterations.complex; i++) {
-      str = "test" + i + "value";
+    var j = 0
+    for (j = 0; j < iterations.complex; j++) {
+      str = "test" + j + "value";
     }
   });
-  
-  var strings = [];
-  for (var i = 0; i < 1000; i++) {
-    strings.push("string" + i);
+
+  for (i = 0; i < 1000; i++) {
+    strings[] = "string" + i;
   }
-  
+
   var joinTime = measureTime(function() {
-    for (var i = 0; i < iterations.complex; i++) {
-      var result = strings.join(",");
+    var j = 0
+    var result = null
+    for (j = 0; j < iterations.complex; j++) {
+      result = text(strings, ",");
     }
   });
-  
+
   var splitTime = measureTime(function() {
     var str = "a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p";
-    for (var i = 0; i < iterations.medium; i++) {
-      var parts = str.split(",");
+    var j = 0
+    var parts = null
+    for (j = 0; j < iterations.medium; j++) {
+      parts = array(str, ",");
     }
   });
-  
+
   return {
     concatTime: concatTime,
     joinTime: joinTime,
@@ -222,35 +215,34 @@ function benchStringOps() {
   };
 }
 
-////////////////////////////////////////////////////////////////////////////////
-// Benchmark: Arithmetic Operations
-////////////////////////////////////////////////////////////////////////////////
-
 function benchArithmetic() {
   var intMathTime = measureTime(function() {
     var result = 1;
-    for (var i = 0; i < iterations.simple; i++) {
+    var i = 0
+    for (i = 0; i < iterations.simple; i++) {
       result = ((result + i) * 2 - 1) / 3;
       result = result % 1000 + 1;
     }
   });
-  
+
   var floatMathTime = measureTime(function() {
     var result = 1.5;
-    for (var i = 0; i < iterations.simple; i++) {
+    var i = 0
+    for (i = 0; i < iterations.simple; i++) {
       result = math.sine(result) + math.cosine(i * 0.01);
-      result = math.sqrt(number.abs(result)) + 0.1;
+      result = math.sqrt(abs(result)) + 0.1;
     }
   });
-  
+
   var bitwiseTime = measureTime(function() {
     var result = 0;
-    for (var i = 0; i < iterations.simple; i++) {
+    var i = 0
+    for (i = 0; i < iterations.simple; i++) {
       result = (result ^ i) & 0xFFFF;
       result = (result << 1) | (result >> 15);
     }
   });
-  
+
   return {
     intMathTime: intMathTime,
     floatMathTime: floatMathTime,
@@ -258,134 +250,123 @@ function benchArithmetic() {
   };
 }
 
-////////////////////////////////////////////////////////////////////////////////
-// Benchmark: Closure Operations
-////////////////////////////////////////////////////////////////////////////////
-
 function benchClosures() {
+  var i = 0
+
   function makeAdder(x) {
     return function(y) { return x + y; };
   }
-  
+
   var closureCreateTime = measureTime(function() {
     var funcs = [];
-    for (var i = 0; i < iterations.medium; i++) {
-      funcs.push(makeAdder(i));
+    var j = 0
+    for (j = 0; j < iterations.medium; j++) {
+      funcs[] = makeAdder(j);
     }
   });
-  
+
   var adders = [];
-  for (var i = 0; i < 1000; i++) {
-    adders.push(makeAdder(i));
+  for (i = 0; i < 1000; i++) {
+    adders[] = makeAdder(i);
   }
-  
+
   var closureCallTime = measureTime(function() {
     var sum = 0;
-    for (var i = 0; i < iterations.medium; i++) {
-      sum += adders[i % 1000](i);
+    var j = 0
+    for (j = 0; j < iterations.medium; j++) {
+      sum += adders[j % 1000](j);
     }
   });
-  
+
   return {
     closureCreateTime: closureCreateTime,
     closureCallTime: closureCallTime
   };
 }
 
-////////////////////////////////////////////////////////////////////////////////
-// Main benchmark runner
-////////////////////////////////////////////////////////////////////////////////
-
 log.console("JavaScript Performance Benchmark");
 log.console("======================\n");
 
-// Property Access
 log.console("BENCHMARK: Property Access");
 var propResults = benchPropertyAccess();
-log.console("  Read time:  " + propResults.readTime.toFixed(3) + "s => " + 
+log.console("  Read time:  " + propResults.readTime.toFixed(3) + "s => " +
            (iterations.simple / propResults.readTime).toFixed(1) + " reads/sec [" +
            (propResults.readTime / iterations.simple * 1e9).toFixed(1) + " ns/op]");
-log.console("  Write time: " + propResults.writeTime.toFixed(3) + "s => " + 
+log.console("  Write time: " + propResults.writeTime.toFixed(3) + "s => " +
            (iterations.simple / propResults.writeTime).toFixed(1) + " writes/sec [" +
            (propResults.writeTime / iterations.simple * 1e9).toFixed(1) + " ns/op]");
 log.console("");
 
-// Function Calls
 log.console("BENCHMARK: Function Calls");
 var funcResults = benchFunctionCalls();
-log.console("  Simple calls: " + funcResults.simpleCallTime.toFixed(3) + "s => " + 
+log.console("  Simple calls: " + funcResults.simpleCallTime.toFixed(3) + "s => " +
            (iterations.simple / funcResults.simpleCallTime).toFixed(1) + " calls/sec [" +
            (funcResults.simpleCallTime / iterations.simple * 1e9).toFixed(1) + " ns/op]");
-log.console("  Method calls: " + funcResults.methodCallTime.toFixed(3) + "s => " + 
+log.console("  Method calls: " + funcResults.methodCallTime.toFixed(3) + "s => " +
            (iterations.simple / funcResults.methodCallTime).toFixed(1) + " calls/sec [" +
            (funcResults.methodCallTime / iterations.simple * 1e9).toFixed(1) + " ns/op]");
-log.console("  Complex calls: " + funcResults.complexCallTime.toFixed(3) + "s => " + 
+log.console("  Complex calls: " + funcResults.complexCallTime.toFixed(3) + "s => " +
            (iterations.medium / funcResults.complexCallTime).toFixed(1) + " calls/sec [" +
            (funcResults.complexCallTime / iterations.medium * 1e9).toFixed(1) + " ns/op]");
 log.console("");
 
-// Array Operations
 log.console("BENCHMARK: Array Operations");
 var arrayResults = benchArrayOps();
-log.console("  Push: " + arrayResults.pushTime.toFixed(3) + "s => " + 
+log.console("  Push: " + arrayResults.pushTime.toFixed(3) + "s => " +
            (iterations.medium / arrayResults.pushTime).toFixed(1) + " pushes/sec [" +
            (arrayResults.pushTime / iterations.medium * 1e9).toFixed(1) + " ns/op]");
-log.console("  Access: " + arrayResults.accessTime.toFixed(3) + "s => " + 
+log.console("  Access: " + arrayResults.accessTime.toFixed(3) + "s => " +
            (iterations.medium / arrayResults.accessTime).toFixed(1) + " accesses/sec [" +
            (arrayResults.accessTime / iterations.medium * 1e9).toFixed(1) + " ns/op]");
-log.console("  Iterate: " + arrayResults.iterateTime.toFixed(3) + "s => " + 
+log.console("  Iterate: " + arrayResults.iterateTime.toFixed(3) + "s => " +
            (1000 / arrayResults.iterateTime).toFixed(1) + " full iterations/sec");
 log.console("");
 
-// Object Creation
 log.console("BENCHMARK: Object Creation");
 var objResults = benchObjectCreation();
-log.console("  Literal: " + objResults.literalTime.toFixed(3) + "s => " + 
+log.console("  Literal: " + objResults.literalTime.toFixed(3) + "s => " +
            (iterations.medium / objResults.literalTime).toFixed(1) + " creates/sec [" +
            (objResults.literalTime / iterations.medium * 1e9).toFixed(1) + " ns/op]");
-log.console("  Constructor: " + objResults.defructorTime.toFixed(3) + "s => " + 
+log.console("  Constructor: " + objResults.defructorTime.toFixed(3) + "s => " +
            (iterations.medium / objResults.defructorTime).toFixed(1) + " creates/sec [" +
            (objResults.defructorTime / iterations.medium * 1e9).toFixed(1) + " ns/op]");
-log.console("  Prototype: " + objResults.prototypeTime.toFixed(3) + "s => " + 
+log.console("  Prototype: " + objResults.prototypeTime.toFixed(3) + "s => " +
            (iterations.medium / objResults.prototypeTime).toFixed(1) + " creates/sec [" +
            (objResults.prototypeTime / iterations.medium * 1e9).toFixed(1) + " ns/op]");
 log.console("");
 
-// String Operations
 log.console("BENCHMARK: String Operations");
 var strResults = benchStringOps();
-log.console("  Concat: " + strResults.concatTime.toFixed(3) + "s => " + 
+log.console("  Concat: " + strResults.concatTime.toFixed(3) + "s => " +
            (iterations.complex / strResults.concatTime).toFixed(1) + " concats/sec [" +
            (strResults.concatTime / iterations.complex * 1e9).toFixed(1) + " ns/op]");
-log.console("  Join: " + strResults.joinTime.toFixed(3) + "s => " + 
+log.console("  Join: " + strResults.joinTime.toFixed(3) + "s => " +
            (iterations.complex / strResults.joinTime).toFixed(1) + " joins/sec [" +
            (strResults.joinTime / iterations.complex * 1e9).toFixed(1) + " ns/op]");
-log.console("  Split: " + strResults.splitTime.toFixed(3) + "s => " + 
+log.console("  Split: " + strResults.splitTime.toFixed(3) + "s => " +
            (iterations.medium / strResults.splitTime).toFixed(1) + " splits/sec [" +
            (strResults.splitTime / iterations.medium * 1e9).toFixed(1) + " ns/op]");
 log.console("");
 
-// Arithmetic Operations
 log.console("BENCHMARK: Arithmetic Operations");
 var mathResults = benchArithmetic();
-log.console("  Integer math: " + mathResults.intMathTime.toFixed(3) + "s => " + 
+log.console("  Integer math: " + mathResults.intMathTime.toFixed(3) + "s => " +
            (iterations.simple / mathResults.intMathTime).toFixed(1) + " ops/sec [" +
            (mathResults.intMathTime / iterations.simple * 1e9).toFixed(1) + " ns/op]");
-log.console("  Float math: " + mathResults.floatMathTime.toFixed(3) + "s => " + 
+log.console("  Float math: " + mathResults.floatMathTime.toFixed(3) + "s => " +
            (iterations.simple / mathResults.floatMathTime).toFixed(1) + " ops/sec [" +
            (mathResults.floatMathTime / iterations.simple * 1e9).toFixed(1) + " ns/op]");
-log.console("  Bitwise: " + mathResults.bitwiseTime.toFixed(3) + "s => " + 
+log.console("  Bitwise: " + mathResults.bitwiseTime.toFixed(3) + "s => " +
            (iterations.simple / mathResults.bitwiseTime).toFixed(1) + " ops/sec [" +
            (mathResults.bitwiseTime / iterations.simple * 1e9).toFixed(1) + " ns/op]");
 log.console("");
 
-// Closures
 log.console("BENCHMARK: Closures");
 var closureResults = benchClosures();
-log.console("  Create: " + closureResults.closureCreateTime.toFixed(3) + "s => " + 
+log.console("  Create: " + closureResults.closureCreateTime.toFixed(3) + "s => " +
            (iterations.medium / closureResults.closureCreateTime).toFixed(1) + " creates/sec [" +
            (closureResults.closureCreateTime / iterations.medium * 1e9).toFixed(1) + " ns/op]");
-log.console("  Call: " + closureResults.closureCallTime.toFixed(3) + "s => " + 
+log.console("  Call: " + closureResults.closureCallTime.toFixed(3) + "s => " +
            (iterations.medium / closureResults.closureCallTime).toFixed(1) + " calls/sec [" +
            (closureResults.closureCallTime / iterations.medium * 1e9).toFixed(1) + " ns/op]");
 log.console("");

benchmarks/mandelbrot.ce

@@ -1,40 +1,46 @@
 var blob = use('blob')
 
-var iter = 50, limit = 2.0;
-var zr, zi, cr, ci, tr, ti;
+var iter = 50
+var limit = 2.0
+var zr = null
+var zi = null
+var cr = null
+var ci = null
+var tr = null
+var ti = null
+var y = 0
+var x = 0
+var i = 0
+var row = null
 
 var h = Number(arg[0]) || 500
 var w = h
 
 log.console(`P4\n${w} ${h}`);
 
-for (let y = 0; y < h; ++y) {
-  // Create a blob for the row - we need w bits
-  var row = new blob(w);
+for (y = 0; y < h; ++y) {
+  row = blob(w);
 
-  for (let x = 0; x < w; ++x) {
-    zr = zi = tr = ti = 0;
+  for (x = 0; x < w; ++x) {
+    zr = 0; zi = 0; tr = 0; ti = 0;
     cr = 2 * x / w - 1.5;
     ci = 2 * y / h - 1;
-    for (let i = 0; i < iter && (tr + ti <= limit * limit); ++i) {
+    for (i = 0; i < iter && (tr + ti <= limit * limit); ++i) {
       zi = 2 * zr * zi + ci;
       zr = tr - ti + cr;
       tr = zr * zr;
       ti = zi * zi;
     }
 
-    // Write a 1 bit if inside the set, 0 if outside
     if (tr + ti <= limit * limit)
       row.write_bit(1);
     else
       row.write_bit(0);
   }
-  
-  // Convert the blob to stone (immutable) to prepare for output
+
   stone(row)
-  
-  // Output the blob data as raw bytes
-  log.console(text(row, 'b'));  
+
+  log.console(text(row, 'b'));
 }
 
 $stop()

benchmarks/montecarlo.ce

@@ -1,9 +1,12 @@
 var math = use('math/radians')
 var N = 1000000;
 var num = 0;
-for (var i = 0; i < N; i ++) {
-  var x = 2 * $random();
-  var y = $random();
+var i = 0
+var x = null
+var y = null
+for (i = 0; i < N; i++) {
+  x = 2 * $random();
+  y = $random();
   if (y < math.sine(x * x))
     num++;
 }

benchmarks/nbody.ce

@@ -2,66 +2,60 @@ var math = use('math/radians')
 var SOLAR_MASS = 4 * pi * pi;
 var DAYS_PER_YEAR = 365.24;
 
-function Body(x, y, z, vx, vy, vz, mass) {
-    this.x = x;
-    this.y = y;
-    this.z = z;
-    this.vx = vx;
-    this.vy = vy;
-    this.vz = vz;
-    this.mass = mass;
+function Body(p) {
+    return {x: p.x, y: p.y, z: p.z, vx: p.vx, vy: p.vy, vz: p.vz, mass: p.mass};
 }
 
 function Jupiter() {
-    return new Body(
-        4.84143144246472090e+00,
-        -1.16032004402742839e+00,
-        -1.03622044471123109e-01,
-        1.66007664274403694e-03 * DAYS_PER_YEAR,
-        7.69901118419740425e-03 * DAYS_PER_YEAR,
-        -6.90460016972063023e-05 * DAYS_PER_YEAR,
-        9.54791938424326609e-04 * SOLAR_MASS
-    );
+    return Body({
+        x: 4.84143144246472090e+00,
+        y: -1.16032004402742839e+00,
+        z: -1.03622044471123109e-01,
+        vx: 1.66007664274403694e-03 * DAYS_PER_YEAR,
+        vy: 7.69901118419740425e-03 * DAYS_PER_YEAR,
+        vz: -6.90460016972063023e-05 * DAYS_PER_YEAR,
+        mass: 9.54791938424326609e-04 * SOLAR_MASS
+    });
 }
 
 function Saturn() {
-    return new Body(
-        8.34336671824457987e+00,
-        4.12479856412430479e+00,
-        -4.03523417114321381e-01,
-        -2.76742510726862411e-03 * DAYS_PER_YEAR,
-        4.99852801234917238e-03 * DAYS_PER_YEAR,
-        2.30417297573763929e-05 * DAYS_PER_YEAR,
-        2.85885980666130812e-04 * SOLAR_MASS
-    );
+    return Body({
+        x: 8.34336671824457987e+00,
+        y: 4.12479856412430479e+00,
+        z: -4.03523417114321381e-01,
+        vx: -2.76742510726862411e-03 * DAYS_PER_YEAR,
+        vy: 4.99852801234917238e-03 * DAYS_PER_YEAR,
+        vz: 2.30417297573763929e-05 * DAYS_PER_YEAR,
+        mass: 2.85885980666130812e-04 * SOLAR_MASS
+    });
 }
 
 function Uranus() {
-    return new Body(
-        1.28943695621391310e+01,
-        -1.51111514016986312e+01,
-        -2.23307578892655734e-01,
-        2.96460137564761618e-03 * DAYS_PER_YEAR,
-        2.37847173959480950e-03 * DAYS_PER_YEAR,
-        -2.96589568540237556e-05 * DAYS_PER_YEAR,
-        4.36624404335156298e-05 * SOLAR_MASS
-    );
+    return Body({
+        x: 1.28943695621391310e+01,
+        y: -1.51111514016986312e+01,
+        z: -2.23307578892655734e-01,
+        vx: 2.96460137564761618e-03 * DAYS_PER_YEAR,
+        vy: 2.37847173959480950e-03 * DAYS_PER_YEAR,
+        vz: -2.96589568540237556e-05 * DAYS_PER_YEAR,
+        mass: 4.36624404335156298e-05 * SOLAR_MASS
+    });
 }
 
 function Neptune() {
-    return new Body(
-        1.53796971148509165e+01,
-        -2.59193146099879641e+01,
-        1.79258772950371181e-01,
-        2.68067772490389322e-03 * DAYS_PER_YEAR,
-        1.62824170038242295e-03 * DAYS_PER_YEAR,
-        -9.51592254519715870e-05 * DAYS_PER_YEAR,
-        5.15138902046611451e-05 * SOLAR_MASS
-    );
+    return Body({
+        x: 1.53796971148509165e+01,
+        y: -2.59193146099879641e+01,
+        z: 1.79258772950371181e-01,
+        vx: 2.68067772490389322e-03 * DAYS_PER_YEAR,
+        vy: 1.62824170038242295e-03 * DAYS_PER_YEAR,
+        vz: -9.51592254519715870e-05 * DAYS_PER_YEAR,
+        mass: 5.15138902046611451e-05 * SOLAR_MASS
+    });
 }
 
 function Sun() {
-    return new Body(0.0, 0.0, 0.0, 0.0, 0.0, 0.0, SOLAR_MASS);
+    return Body({x: 0.0, y: 0.0, z: 0.0, vx: 0.0, vy: 0.0, vz: 0.0, mass: SOLAR_MASS});
 }
 
 var bodies = Array(Sun(), Jupiter(), Saturn(), Uranus(), Neptune());
@@ -70,44 +64,62 @@ function offsetMomentum() {
     var px = 0;
     var py = 0;
     var pz = 0;
-    var size = bodies.length;
-    for (var i = 0; i < size; i++) {
-        var body = bodies[i];
-        var mass = body.mass;
+    var size = length(bodies);
+    var i = 0
+    var body = null
+    var mass = null
+    for (i = 0; i < size; i++) {
+        body = bodies[i];
+        mass = body.mass;
         px += body.vx * mass;
         py += body.vy * mass;
         pz += body.vz * mass;
     }
 
-    var body = bodies[0];
+    body = bodies[0];
     body.vx = -px / SOLAR_MASS;
     body.vy = -py / SOLAR_MASS;
     body.vz = -pz / SOLAR_MASS;
 }
 
 function advance(dt) {
-    var size = bodies.length;
+    var size = length(bodies);
+    var i = 0
+    var j = 0
+    var bodyi = null
+    var bodyj = null
+    var vxi = null
+    var vyi = null
+    var vzi = null
+    var dx = null
+    var dy = null
+    var dz = null
+    var d2 = null
+    var mag = null
+    var massj = null
+    var massi = null
+    var body = null
 
-    for (var i = 0; i < size; i++) {
-        var bodyi = bodies[i];
-        var vxi = bodyi.vx;
-        var vyi = bodyi.vy;
-        var vzi = bodyi.vz;
-        for (var j = i + 1; j < size; j++) {
-            var bodyj = bodies[j];
-            var dx = bodyi.x - bodyj.x;
-            var dy = bodyi.y - bodyj.y;
-            var dz = bodyi.z - bodyj.z;
+    for (i = 0; i < size; i++) {
+        bodyi = bodies[i];
+        vxi = bodyi.vx;
+        vyi = bodyi.vy;
+        vzi = bodyi.vz;
+        for (j = i + 1; j < size; j++) {
+            bodyj = bodies[j];
+            dx = bodyi.x - bodyj.x;
+            dy = bodyi.y - bodyj.y;
+            dz = bodyi.z - bodyj.z;
 
-            var d2 = dx * dx + dy * dy + dz * dz;
-            var mag = dt / (d2 * math.sqrt(d2));
+            d2 = dx * dx + dy * dy + dz * dz;
+            mag = dt / (d2 * math.sqrt(d2));
 
-            var massj = bodyj.mass;
+            massj = bodyj.mass;
             vxi -= dx * massj * mag;
             vyi -= dy * massj * mag;
             vzi -= dz * massj * mag;
 
-            var massi = bodyi.mass;
+            massi = bodyi.mass;
             bodyj.vx += dx * massi * mag;
             bodyj.vy += dy * massi * mag;
             bodyj.vz += dz * massi * mag;
@@ -117,8 +129,8 @@ function advance(dt) {
         bodyi.vz = vzi;
     }
 
-    for (var i = 0; i < size; i++) {
-        var body = bodies[i];
+    for (i = 0; i < size; i++) {
+        body = bodies[i];
         body.x += dt * body.vx;
         body.y += dt * body.vy;
         body.z += dt * body.vz;
@@ -127,21 +139,29 @@ function advance(dt) {
 
 function energy() {
     var e = 0;
-    var size = bodies.length;
+    var size = length(bodies);
+    var i = 0
+    var j = 0
+    var bodyi = null
+    var bodyj = null
+    var dx = null
+    var dy = null
+    var dz = null
+    var distance = null
 
-    for (var i = 0; i < size; i++) {
-        var bodyi = bodies[i];
+    for (i = 0; i < size; i++) {
+        bodyi = bodies[i];
 
-        e += 0.5 * bodyi.mass * ( bodyi.vx * bodyi.vx + 
+        e += 0.5 * bodyi.mass * ( bodyi.vx * bodyi.vx +
             bodyi.vy * bodyi.vy + bodyi.vz * bodyi.vz );
 
-        for (var j = i + 1; j < size; j++) {
-            var bodyj = bodies[j];
-            var dx = bodyi.x - bodyj.x;
-            var dy = bodyi.y - bodyj.y;
-            var dz = bodyi.z - bodyj.z;
+        for (j = i + 1; j < size; j++) {
+            bodyj = bodies[j];
+            dx = bodyi.x - bodyj.x;
+            dy = bodyi.y - bodyj.y;
+            dz = bodyi.z - bodyj.z;
 
-            var distance = math.sqrt(dx * dx + dy * dy + dz * dz);
+            distance = math.sqrt(dx * dx + dy * dy + dz * dz);
             e -= (bodyi.mass * bodyj.mass) / distance;
         }
     }
@@ -149,12 +169,13 @@ function energy() {
 }
 
 var n = arg[0] || 100000
+var i = 0
 
 offsetMomentum();
 
 log.console(`n = ${n}`)
 log.console(energy().toFixed(9))
-for (var i = 0; i < n; i++)
+for (i = 0; i < n; i++)
     advance(0.01);
 log.console(energy().toFixed(9))
 

benchmarks/nota.ce

@@ -1,5 +1,5 @@
-var nota = use('nota')
-var os = use('os')
+var nota = use('internal/nota')
+var os = use('internal/os')
 var io = use('fd')
 var json = use('json')
 
@@ -7,49 +7,48 @@ var ll = io.slurp('benchmarks/nota.json')
 
 var newarr = []
 var accstr = ""
-for (var i = 0; i < 10000; i++) {
+var i = 0
+var start = null
+var jll = null
+var jsonStr = null
+var nll = null
+var oll = null
+for (i = 0; i < 10000; i++) {
   accstr += i;
-  newarr.push(i.toString())
+  newarr[] = text(i)
 }
-// Arrays to store timing results
 var jsonDecodeTimes = [];
 var jsonEncodeTimes = [];
 var notaEncodeTimes = [];
 var notaDecodeTimes = [];
 var notaSizes = [];
 
-// Run 100 tests
-for (let i = 0; i < 100; i++) {
-    // JSON Decode test
-    let start = os.now();
-    var jll = json.decode(ll);
-    jsonDecodeTimes.push((os.now() - start) * 1000);
-
-    // JSON Encode test
+for (i = 0; i < 100; i++) {
     start = os.now();
-    let jsonStr = JSON.stringify(jll);
-    jsonEncodeTimes.push((os.now() - start) * 1000);
+    jll = json.decode(ll);
+    jsonDecodeTimes[] = (os.now() - start) * 1000;
 
-    // NOTA Encode test
     start = os.now();
-    var nll = nota.encode(jll);
-    notaEncodeTimes.push((os.now() - start) * 1000);
+    jsonStr = JSON.stringify(jll);
+    jsonEncodeTimes[] = (os.now() - start) * 1000;
 
-    // NOTA Decode test
     start = os.now();
-    var oll = nota.decode(nll);
-    notaDecodeTimes.push((os.now() - start) * 1000);
+    nll = nota.encode(jll);
+    notaEncodeTimes[] = (os.now() - start) * 1000;
+
+    start = os.now();
+    oll = nota.decode(nll);
+    notaDecodeTimes[] = (os.now() - start) * 1000;
 }
 
-// Calculate statistics
 function getStats(arr) {
-    def avg = arr.reduce((a, b) => a + b) / arr.length;
-    def min = number.min(...arr);
-    def max = number.max(...arr);
-    return { avg, min, max };
+    return {
+      avg: reduce(arr, (a,b) => a+b, 0) / length(arr),
+      min: reduce(arr, min),
+      max: reduce(arr, max)
+    };
 }
 
-// Pretty print results
 log.console("\n== Performance Test Results (100 iterations) ==");
 log.console("\nJSON Decoding (ms):");
 def jsonDecStats = getStats(jsonDecodeTimes);
@@ -74,4 +73,3 @@ def notaDecStats = getStats(notaDecodeTimes);
 log.console(`Average: ${notaDecStats.avg.toFixed(2)} ms`);
 log.console(`Min: ${notaDecStats.min.toFixed(2)} ms`);
 log.console(`Max: ${notaDecStats.max.toFixed(2)} ms`);
-

benchmarks/spectral-norm.ce

@@ -1,25 +1,31 @@
-const math = require('math/radians');
+def math = use('math/radians');
 
 function A(i,j) {
   return 1/((i+j)*(i+j+1)/2+i+1);
 }
 
 function Au(u,v) {
-  for (var i=0; i<u.length; ++i) {
-    var t = 0;
-    for (var j=0; j<u.length; ++j)
+  var i = 0
+  var j = 0
+  var t = null
+  for (i = 0; i < length(u); ++i) {
+    t = 0;
+    for (j = 0; j < length(u); ++j)
       t += A(i,j) * u[j];
-      
+
     v[i] = t;
   }
 }
 
 function Atu(u,v) {
-  for (var i=0; i<u.length; ++i) {
-    var t = 0;
-    for (var j=0; j<u.length; ++j)
+  var i = 0
+  var j = 0
+  var t = null
+  for (i = 0; i < length(u); ++i) {
+    t = 0;
+    for (j = 0; j < length(u); ++j)
       t += A(j,i) * u[j];
-      
+
     v[i] = t;
   }
 }
@@ -30,20 +36,26 @@ function AtAu(u,v,w) {
 }
 
 function spectralnorm(n) {
-  var i, u=[], v=[], w=[], vv=0, vBv=0;
-  for (i=0; i<n; ++i)
-    u[i] = 1; v[i] = w[i] = 0; 
+  var i = 0
+  var u = []
+  var v = []
+  var w = []
+  var vv = 0
+  var vBv = 0
+  for (i = 0; i < n; ++i) {
+    u[i] = 1; v[i] = 0; w[i] = 0;
+  }
 
-  for (i=0; i<10; ++i) {
+  for (i = 0; i < 10; ++i) {
     AtAu(u,v,w);
     AtAu(v,u,w);
   }
-  
-  for (i=0; i<n; ++i) {
+
+  for (i = 0; i < n; ++i) {
     vBv += u[i]*v[i];
     vv  += v[i]*v[i];
   }
-  
+
   return math.sqrt(vBv/vv);
 }
 

benchmarks/wota.ce

@@ -1,41 +1,22 @@
-//
-// wota_benchmark.js
-//
-// Usage in QuickJS:
-//     qjs wota_benchmark.js
-//
-// Prerequisite:
-     var wota = use('wota');
-     var os   = use('os');
-// or otherwise ensure `wota` and `os` are available.
-// Make sure wota_benchmark.js is loaded after wota.js or combined with it.
-//
+var wota = use('internal/wota');
+var os   = use('internal/os');
+
+var i = 0
 
-// Helper to run a function repeatedly and measure total time in seconds.
-// Returns elapsed time in seconds.
 function measureTime(fn, iterations) {
-    let t1 = os.now();
-    for (let i = 0; i < iterations; i++) {
+    var t1 = os.now();
+    for (i = 0; i < iterations; i++) {
         fn();
     }
-    let t2 = os.now();
+    var t2 = os.now();
     return t2 - t1;
 }
 
-// We'll define a function that does `encode -> decode` for a given value:
 function roundTripWota(value) {
-    let encoded = wota.encode(value);
-    let decoded = wota.decode(encoded);
-    // Not doing a deep compare here, just measuring performance.
-    // (We trust the test suite to verify correctness.)
+    var encoded = wota.encode(value);
+    var decoded = wota.decode(encoded);
 }
 
-// A small suite of data we want to benchmark. Each entry includes:
-//   name: label for printing
-//   data: the test value(s) to encode/decode
-//   iterations: how many times to loop
-//
-// You can tweak these as you like for heavier or lighter tests.
 def benchmarks = [
   {
     name: "Small Integers",
@@ -62,45 +43,28 @@ def benchmarks = [
   },
   {
     name: "Large Array (1k numbers)",
-    // A thousand random numbers
-    data: [ Array.from({length:1000}, (_, i) => i * 0.5) ],
+    data: [ array(1000, i => i *0.5) ],
     iterations: 1000
   },
-  {
-    name: "Large Binary Blob (256KB)",
-    // A 256KB ArrayBuffer
-    data: [ new Uint8Array(256 * 1024).buffer ],
-    iterations: 200
-  }
 ];
 
-// Print a header
 log.console("Wota Encode/Decode Benchmark");
 log.console("===================\n");
 
-// We'll run each benchmark scenario in turn.
-for (let bench of benchmarks) {
-    // We'll measure how long it takes to do 'iterations' *for each test value*
-    // in bench.data. The total loop count is `bench.iterations * bench.data.length`.
-    // Then we compute an overall encode+decode throughput (ops/s).
-    let totalIterations = bench.iterations * bench.data.length;
-    
-    // We'll define a function that does a roundTrip for *each* data item in bench.data
-    // to measure in one loop iteration. Then we multiply by bench.iterations.
+arrfor(benchmarks, function(bench) {
+    var totalIterations = bench.iterations * length(bench.data);
+
     function runAllData() {
-        for (let val of bench.data) {
-            roundTripWota(val);
-        }
+      arrfor(bench.data, roundTripWota)
     }
 
-    let elapsedSec = measureTime(runAllData, bench.iterations);
-    let opsPerSec  = (totalIterations / elapsedSec).toFixed(1);
+    var elapsedSec = measureTime(runAllData, bench.iterations);
+    var opsPerSec  = (totalIterations / elapsedSec).toFixed(1);
 
     log.console(`${bench.name}:`);
-    log.console(`  Iterations: ${bench.iterations} × ${bench.data.length} data items = ${totalIterations}`);
+    log.console(`  Iterations: ${bench.iterations} × ${length(bench.data)} data items = ${totalIterations}`);
     log.console(`  Elapsed:    ${elapsedSec.toFixed(3)} s`);
     log.console(`  Throughput: ${opsPerSec} encode+decode ops/sec\n`);
-}
+})
 
-// All done
 log.console("Benchmark completed.\n");

benchmarks/wota_nota_json.ce

@@ -1,19 +1,10 @@
-//
-// benchmark_wota_nota_json.js
-//
-// Usage in QuickJS:
-//    qjs benchmark_wota_nota_json.js <LibraryName> <ScenarioName>
-//
-// Ensure wota, nota, json, and os are all available, e.g.:
-    var wota = use('wota');
-    var nota = use('nota');
-    var json = use('json');
-    var jswota = use('jswota')
-    var os   = use('os');
-//
+var wota = use('internal/wota');
+var nota = use('internal/nota');
+var json = use('json');
+var jswota = use('jswota')
+var os   = use('internal/os');
 
-// Parse command line arguments
-if (arg.length != 2) {
+if (length(arg) != 2) {
   log.console('Usage: cell benchmark_wota_nota_json.ce <LibraryName> <ScenarioName>');
   $stop()
 }
@@ -21,47 +12,33 @@ if (arg.length != 2) {
 var lib_name = arg[0];
 var scenario_name = arg[1];
 
-////////////////////////////////////////////////////////////////////////////////
-// 1. Setup "libraries" array to easily switch among wota, nota, and json
-////////////////////////////////////////////////////////////////////////////////
-
 def libraries = [
   {
     name: "wota",
     encode: wota.encode,
     decode: wota.decode,
-    // wota produces an ArrayBuffer. We'll count `buffer.byteLength` as size.
     getSize(encoded) {
-      return encoded.length;
+      return length(encoded);
     }
   },
   {
     name: "nota",
     encode: nota.encode,
     decode: nota.decode,
-    // nota also produces an ArrayBuffer:
     getSize(encoded) {
-      return encoded.length;
+      return length(encoded);
     }
   },
   {
     name: "json",
     encode: json.encode,
     decode: json.decode,
-    // json produces a JS string. We'll measure its UTF-16 code unit length
-    // as a rough "size". Alternatively, you could convert to UTF-8 for
-    // a more accurate byte size. Here we just use `string.length`.
     getSize(encodedStr) {
-      return encodedStr.length;
+      return length(encodedStr);
     }
   }
 ];
 
-////////////////////////////////////////////////////////////////////////////////
-// 2. Test data sets (similar to wota benchmarks).
-//    Each scenario has { name, data, iterations }
-////////////////////////////////////////////////////////////////////////////////
-
 def benchmarks = [
   {
     name: "empty",
@@ -98,94 +75,67 @@ def benchmarks = [
   },
   {
     name: "large_array",
-    data: [ Array.from({length:1000}, (_, i) => i) ],
+    data: [ array(1000, i => i) ],
     iterations: 1000
   },
 ];
 
-////////////////////////////////////////////////////////////////////////////////
-// 3. Utility: measureTime(fn) => how long fn() takes in seconds.
-////////////////////////////////////////////////////////////////////////////////
-
 function measureTime(fn) {
-  let start = os.now();
+  var start = os.now();
   fn();
-  let end   = os.now();
-  return (end - start);  // in seconds
+  var end   = os.now();
+  return (end - start);
 }
 
-////////////////////////////////////////////////////////////////////////////////
-// 4. For each library, we run each benchmark scenario and measure:
-//    - Encoding time (seconds)
-//    - Decoding time (seconds)
-//    - Total encoded size (bytes or code units for json)
-//
-////////////////////////////////////////////////////////////////////////////////
-
 function runBenchmarkForLibrary(lib, bench) {
-  // We'll encode and decode each item in `bench.data`.
-  // We do 'bench.iterations' times. Then sum up total time.
+  var encodedList = [];
+  var totalSize = 0;
+  var i = 0
+  var j = 0
+  var e = null
 
-  // Pre-store the encoded results for all items so we can measure decode time
-  // in a separate pass. Also measure total size once.
-  let encodedList = [];
-  let totalSize = 0;
-
-  // 1) Measure ENCODING
-  let encodeTime = measureTime(() => {
-    for (let i = 0; i < bench.iterations; i++) {
-      // For each data item, encode it
-      for (let j = 0; j < bench.data.length; j++) {
-        let e = lib.encode(bench.data[j]);
-        // store only in the very first iteration, so we can decode them later
-        // but do not store them every iteration or we blow up memory.
+  var encodeTime = measureTime(() => {
+    for (i = 0; i < bench.iterations; i++) {
+      for (j = 0; j < length(bench.data); j++) {
+        e = lib.encode(bench.data[j]);
         if (i == 0) {
-          encodedList.push(e);
+          encodedList[] = e;
           totalSize += lib.getSize(e);
         }
       }
     }
   });
 
-  // 2) Measure DECODING
-  let decodeTime = measureTime(() => {
-    for (let i = 0; i < bench.iterations; i++) {
-      // decode everything we stored during the first iteration
-      for (let e of encodedList) {
-        let decoded = lib.decode(e);
-        // not verifying correctness here, just measuring speed
-      }
+  var decodeTime = measureTime(() => {
+    for (i = 0; i < bench.iterations; i++) {
+      arrfor(encodedList, lib.decode)
     }
   });
 
   return { encodeTime, decodeTime, totalSize };
 }
 
-////////////////////////////////////////////////////////////////////////////////
-// 5. Main driver: run only the specified library and scenario
-////////////////////////////////////////////////////////////////////////////////
-
-// Find the requested library and scenario
-var lib = libraries.find(l => l.name == lib_name);
-var bench = benchmarks.find(b => b.name == scenario_name);
+var lib = libraries[find(libraries, l => l.name == lib_name)];
+var bench = benchmarks[find(benchmarks, b => b.name == scenario_name)];
 
 if (!lib) {
   log.console('Unknown library:', lib_name);
-  log.console('Available libraries:', libraries.map(l => l.name).join(', '));
+  log.console('Available libraries:', text(array(libraries, l => l.name), ', '));
   $stop()
 }
 
 if (!bench) {
   log.console('Unknown scenario:', scenario_name);
-  log.console('Available scenarios:', benchmarks.map(b => b.name).join(', '));
+  log.console('Available scenarios:', text(array(benchmarks, b => b.name), ', '));
   $stop()
 }
 
-// Run the benchmark for this library/scenario combination
-var { encodeTime, decodeTime, totalSize } = runBenchmarkForLibrary(lib, bench);
+var bench_result = runBenchmarkForLibrary(lib, bench);
+var encodeTime = bench_result.encodeTime;
+var decodeTime = bench_result.decodeTime;
+var totalSize = bench_result.totalSize;
 
-// Output json for easy parsing by hyperfine or other tools
-var totalOps = bench.iterations * bench.data.length;
+var totalOps = bench.iterations * length(bench.data);
 var result = {
   lib: lib_name,
   scenario: scenario_name,

boot.ce

@@ -0,0 +1,192 @@
+// cell boot [--native] <program> - Pre-compile all module dependencies in parallel
+//
+// Discovers all transitive module dependencies for a program,
+// checks which are not yet cached, and compiles uncached ones
+// in parallel using worker actors composed via parallel() requestors.
+//
+// Also used as a child actor by engine.cm for auto-boot.
+
+var shop = use('internal/shop')
+var fd = use('fd')
+var pkg_tools = use('package')
+var build = use('build')
+
+var is_native = false
+var target_prog = null
+var target_pkg = null
+var i = 0
+
+// Child actor mode: receive message from engine.cm
+var _child_mode = false
+var run_boot = null
+
+$receiver(function(msg) {
+  _child_mode = true
+  is_native = msg.native || false
+  target_prog = msg.program
+  target_pkg = msg.package
+  run_boot()
+})
+
+// CLI mode: parse arguments
+if (args && length(args) > 0) {
+  for (i = 0; i < length(args); i = i + 1) {
+    if (args[i] == '--native') {
+      is_native = true
+    } else if (args[i] == '--help' || args[i] == '-h') {
+      log.console("Usage: cell boot [--native] <program>")
+      log.console("")
+      log.console("Pre-compile all module dependencies for a program.")
+      log.console("Uncached modules are compiled in parallel.")
+      $stop()
+    } else if (!starts_with(args[i], '-')) {
+      target_prog = args[i]
+    }
+  }
+  if (!target_prog) {
+    log.error("boot: no program specified")
+    $stop()
+  }
+}
+
+// Discover all transitive module dependencies for a file
+function discover_deps(file_path) {
+  return shop.trace_deps(file_path)
+}
+
+// Filter out already-cached modules
+function filter_uncached(deps) {
+  var uncached = []
+  var j = 0
+  var s = null
+
+  j = 0
+  while (j < length(deps.scripts)) {
+    s = deps.scripts[j]
+    if (is_native) {
+      if (!shop.is_native_cached(s.path, s.package)) {
+        uncached[] = {type: 'native_script', path: s.path, package: s.package}
+      }
+    } else {
+      if (!shop.is_cached(s.path)) {
+        uncached[] = {type: 'script', path: s.path, package: s.package}
+      }
+    }
+    j = j + 1
+  }
+
+  // Expand C packages into individual files for parallel compilation
+  var target = build.detect_host_target()
+  var pkg = null
+  var c_files = null
+  var k = 0
+  j = 0
+  while (j < length(deps.c_packages)) {
+    pkg = deps.c_packages[j]
+    if (pkg != 'core') {
+      c_files = pkg_tools.get_c_files(pkg, target, true)
+      k = 0
+      while (k < length(c_files)) {
+        uncached[] = {type: 'c_file', package: pkg, file: c_files[k]}
+        k = k + 1
+      }
+    }
+    j = j + 1
+  }
+
+  return uncached
+}
+
+function item_name(item) {
+  if (item.path) return item.path
+  if (item.file) return item.package + '/' + item.file
+  return item.package
+}
+
+// Create a requestor that spawns a compile_worker actor for one item
+function make_compile_requestor(item) {
+  var worker = null
+  var name = item_name(item)
+  return function(callback, value) {
+    log.console('boot: spawning worker for ' + name)
+    $start(function(event) {
+      if (event.type == 'greet') {
+        worker = event.actor
+        send(event.actor, {
+          type: item.type,
+          path: item.path,
+          package: item.package,
+          file: item.file
+        })
+      }
+      if (event.type == 'stop') {
+        callback(name)
+      }
+      if (event.type == 'disrupt') {
+        log.error('boot: worker failed for ' + name)
+        callback(null, {message: 'compile failed: ' + name})
+      }
+    }, 'compile_worker')
+    return function cancel(reason) {
+      if (worker) $stop(worker)
+    }
+  }
+}
+
+run_boot = function() {
+  var prog_path = null
+  var prog_info = null
+  var deps = null
+  var uncached = null
+  var requestors = null
+  var p = null
+
+  // Resolve the program path
+  if (target_prog) {
+    p = target_prog
+    if (ends_with(p, '.ce')) p = text(p, 0, -3)
+    prog_info = shop.resolve_program ? shop.resolve_program(p, target_pkg) : null
+    if (prog_info) {
+      prog_path = prog_info.path
+      if (!target_pkg && prog_info.pkg) target_pkg = prog_info.pkg
+    } else {
+      prog_path = p + '.ce'
+      if (!fd.is_file(prog_path)) {
+        prog_path = null
+      }
+    }
+  }
+
+  if (!prog_path || !fd.is_file(prog_path)) {
+    log.error('boot: could not find program: ' + text(target_prog || ''))
+    $stop()
+    return
+  }
+
+  // Discover all transitive deps
+  deps = discover_deps(prog_path)
+  uncached = filter_uncached(deps)
+
+  if (length(uncached) == 0) {
+    log.console('boot: all modules cached')
+    $stop()
+    return
+  }
+
+  // Compile uncached modules in parallel using worker actors
+  log.console('boot: ' + text(length(uncached)) + ' modules to compile')
+  requestors = array(uncached, make_compile_requestor)
+  parallel(requestors)(function(results, reason) {
+    if (reason) {
+      log.error('boot: ' + (reason.message || text(reason)))
+    } else {
+      log.console('boot: compiled ' + text(length(results)) + ' modules')
+    }
+    $stop()
+  }, null)
+}
+
+// CLI mode: start immediately
+if (!_child_mode && target_prog) {
+  run_boot()
+}

boot_miscompile_bad.cm

@@ -0,0 +1,74 @@
+// boot_miscompile_bad.cm — Documents a boot compiler miscompilation bug.
+//
+// BUG SUMMARY:
+// The boot compiler's optimizer (likely compress_slots, eliminate_moves,
+// or infer_param_types) miscompiles a specific pattern when it appears
+// inside streamline.cm. The pattern: an array-loaded value used as a
+// dynamic index for another array store, inside a guarded block:
+//
+//   sv = instr[j]
+//   if (is_number(sv) && sv >= 0 && sv < nr_slots) {
+//     last_ref[sv] = i    // <-- miscompiled: sv reads wrong slot
+//   }
+//
+// The bug is CONTEXT-DEPENDENT on streamline.cm's exact function/closure
+// structure. A standalone module with the same pattern does NOT trigger it.
+// The boot optimizer's cross-function analysis (infer_param_types, type
+// propagation, etc.) makes different decisions in the full streamline.cm
+// context, leading to the miscompilation.
+//
+// SYMPTOMS:
+// - 'log' is not defined  (comparison error path fires on non-comparable values)
+// - array index must be a number  (store_dynamic with corrupted index)
+// - Error line has NO reference to 'log' — the reference comes from the
+//   error-reporting code path of the < operator
+// - Non-deterministic: different error messages on different runs
+// - NOT a GC bug: persists with --heap 4GB
+// - NOT slot overflow: function has only 85 raw slots
+//
+// TO REPRODUCE:
+// In streamline.cm, replace the build_slot_liveness function body with
+// this version (raw operand scanning instead of get_slot_refs):
+//
+//   var build_slot_liveness = function(instructions, nr_slots) {
+//     var last_ref = array(nr_slots, -1)
+//     var n = length(instructions)
+//     var i = 0
+//     var j = 0
+//     var limit = 0
+//     var sv = 0
+//     var instr = null
+//
+//     while (i < n) {
+//       instr = instructions[i]
+//       if (is_array(instr)) {
+//         j = 1
+//         limit = length(instr) - 2
+//         while (j < limit) {
+//           sv = instr[j]
+//           if (is_number(sv) && sv >= 0 && sv < nr_slots) {
+//             last_ref[sv] = i
+//           }
+//           j = j + 1
+//         }
+//       }
+//       i = i + 1
+//     }
+//     return last_ref
+//   }
+//
+// Then: rm -rf .cell/build && ./cell --dev vm_suite
+//
+// WORKAROUND:
+// Use get_slot_refs(instr) to iterate only over known slot-reference
+// positions. This produces different IR that the boot optimizer handles
+// correctly, and is also more semantically correct.
+//
+// FIXING:
+// To find the root cause, compare the boot-compiled bytecodes of
+// build_slot_liveness (in the full streamline.cm context) vs the
+// source-compiled bytecodes. Use disasm.ce with --optimized to see
+// what the source compiler produces. The boot-compiled bytecodes
+// would need a C-level MachCode dump to inspect.
+
+return null

build.ce

@@ -1,9 +1,12 @@
-// cell build [options] - Build dynamic libraries locally for the current machine
+// cell build [<locator>] - Build dynamic libraries locally for the current machine
 //
 // Usage:
-//   cell build                Build dynamic libraries for all packages
-//   cell build -p <pkg>       Build dynamic library for specific package
+//   cell build                Build dynamic libraries for all packages in shop
+//   cell build .              Build dynamic library for current directory package
+//   cell build <locator>      Build dynamic library for specific package
 //   cell build -t <target>    Cross-compile dynamic libraries for target platform
+//   cell build -b <type>      Build type: release (default), debug, or minsize
+//   cell build --verbose      Print resolved flags, commands, and cache status
 
 var build = use('build')
 var shop = use('internal/shop')
@@ -12,43 +15,67 @@ var fd = use('fd')
 
 var target = null
 var target_package = null
-var buildtype = 'debug'
+var buildtype = 'release'
+var verbose = false
+var force_rebuild = false
+var dry_run = false
+var i = 0
+var targets = null
+var t = 0
+var lib = null
+var results = null
+var success = 0
+var failed = 0
 
-for (var i = 0; i < args.length; i++) {
-  if (args[i] == '-t' || args[i] == '--target') {
-    if (i + 1 < args.length) {
-      target = args[++i]
-    } else {
-      log.error('-t requires a target')
-      $stop()
-    }
-  } else if (args[i] == '-p' || args[i] == '--package') {
-    if (i + 1 < args.length) {
-      target_package = args[++i]
-    } else {
-      log.error('-p requires a package name')
-      $stop()
-    }
-  } else if (args[i] == '-b' || args[i] == '--buildtype') {
-    if (i + 1 < args.length) {
-      buildtype = args[++i]
-      if (buildtype != 'release' && buildtype != 'debug' && buildtype != 'minsize') {
-        log.error('Invalid buildtype: ' + buildtype + '. Must be release, debug, or minsize')
-        $stop()
+var run = function() {
+  for (i = 0; i < length(args); i++) {
+    if (args[i] == '-t' || args[i] == '--target') {
+      if (i + 1 < length(args)) {
+        target = args[++i]
+      } else {
+        log.error('-t requires a target')
+        return
       }
-    } else {
-      log.error('-b requires a buildtype (release, debug, minsize)')
-      $stop()
+    } else if (args[i] == '-p' || args[i] == '--package') {
+      // Legacy support for -p flag
+      if (i + 1 < length(args)) {
+        target_package = args[++i]
+      } else {
+        log.error('-p requires a package name')
+        return
+      }
+    } else if (args[i] == '-b' || args[i] == '--buildtype') {
+      if (i + 1 < length(args)) {
+        buildtype = args[++i]
+        if (buildtype != 'release' && buildtype != 'debug' && buildtype != 'minsize') {
+          log.error('Invalid buildtype: ' + buildtype + '. Must be release, debug, or minsize')
+          return
+        }
+      } else {
+        log.error('-b requires a buildtype (release, debug, minsize)')
+        return
+      }
+    } else if (args[i] == '--force') {
+      force_rebuild = true
+    } else if (args[i] == '--verbose' || args[i] == '-v') {
+      verbose = true
+    } else if (args[i] == '--dry-run') {
+      dry_run = true
+    } else if (args[i] == '--list-targets') {
+      log.console('Available targets:')
+      targets = build.list_targets()
+      for (t = 0; t < length(targets); t++) {
+        log.console('  ' + targets[t])
+      }
+      return
+    } else if (!starts_with(args[i], '-') && !target_package) {
+      // Positional argument - treat as package locator
+      target_package = args[i]
     }
-  } else if (args[i] == '--list-targets') {
-    log.console('Available targets:')
-    var targets = build.list_targets()
-    for (var t = 0; t < targets.length; t++) {
-      log.console('  ' + targets[t])
-    }
-    $stop()
   }
-}
+
+if (target_package)
+  target_package = shop.resolve_locator(target_package)
 
 // Detect target if not specified
 if (!target) {
@@ -56,47 +83,48 @@ if (!target) {
   if (target) log.console('Target: ' + target)
 }
 
-if (target && !build.has_target(target)) {
-  log.error('Invalid target: ' + target)
-  log.console('Available targets: ' + build.list_targets().join(', '))
-  $stop()
-}
+  if (target && !build.has_target(target)) {
+    log.error('Invalid target: ' + target)
+    log.console('Available targets: ' + text(build.list_targets(), ', '))
+    return
+  }
 
 var packages = shop.list_packages()
-log.console('Preparing packages...')
-for (var package of packages) {
-  if (package == 'core') continue
-  shop.extract(package)
-}
+arrfor(packages, function(package) {
+  if (package == 'core') return
+  shop.sync(package, {no_build: true})
+})
 
+var _build = null
 if (target_package) {
   // Build single package
   log.console('Building ' + target_package + '...')
-  try {
-    var lib = build.build_dynamic(target_package, target, buildtype)
+  _build = function() {
+    lib = build.build_dynamic(target_package, target, buildtype, {verbose: verbose, force: force_rebuild})
     if (lib) {
-      log.console('Built: ' + lib)
+      log.console(`Built ${text(length(lib))} module(s)`)
     }
-  } catch (e) {
-    log.error('Build failed: ' + e)
+  } disruption {
+    log.error('Build failed')
     $stop()
   }
+  _build()
 } else {
   // Build all packages
   log.console('Building all packages...')
-  var results = build.build_all_dynamic(target, buildtype)
-  
-  var success = 0
-  var failed = 0
-  for (var i = 0; i < results.length; i++) {
-    if (results[i].library) {
-      success++
-    } else if (results[i].error) {
-      failed++
+  results = build.build_all_dynamic(target, buildtype, {verbose: verbose, force: force_rebuild})
+
+  success = 0
+  failed = 0
+  for (i = 0; i < length(results); i++) {
+    if (results[i].modules) {
+      success = success + length(results[i].modules)
     }
   }
-  
+
   log.console(`Build complete: ${success} libraries built${failed > 0 ? `, ${failed} failed` : ''}`)
 }
+}
+run()
 
 $stop()

cell.toml

@@ -1,13 +1,2 @@
-[compilation]
-CFLAGS = "-Isource -Wno-incompatible-pointer-types -Wno-missing-braces -Wno-strict-prototypes -Wno-unused-function -Wno-int-conversion"
-LDFLAGS = "-lstdc++ -lm"
-
-[compilation.macos_arm64]
-CFLAGS = "-x objective-c"
-LDFLAGS = "-framework CoreFoundation -framework CFNetwork"
-
 [compilation.playdate]
 CFLAGS = "-DMINIZ_NO_TIME -DTARGET_EXTENSION -DTARGET_PLAYDATE -I$LOCAL/PlaydateSDK/C_API"
-
-[compilation.windows]
-LDFLAGS = "-lws2_32 -lwinmm -liphlpapi -lbcrypt -lwinhttp -static-libgcc -static-libstdc++"

cellfs.cm

@@ -1,153 +1,132 @@
 var cellfs = {}
 
-// CellFS: A filesystem implementation using miniz and raw OS filesystem
-// Supports mounting multiple sources (fs, zip) and named mounts (@name)
-
 var fd = use('fd')
 var miniz = use('miniz')
-var qop = use('qop')
-var wildstar = use('wildstar')
+var qop = use('internal/qop')
+var wildstar = use('internal/wildstar')
+var blib = use('blob')
 
-// Internal state
-var mounts = []  // Array of {source, type, handle, name}
+var mounts = []
 
-var writepath = "."
+var write_mount = null
 
-// Helper to normalize paths
 function normalize_path(path) {
   if (!path) return ""
-  // Remove leading/trailing slashes and normalize
-  return path.replace(/^\/+|\/+$/g, "")
+  return replace(path, /^\/+|\/+$/, "")
 }
 
-// Helper to get directory from path
-function dirname(path) {
-  var idx = path.lastIndexOf("/")
-  if (idx == -1) return ""
-  return path.substring(0, idx)
-}
-
-// Helper to get basename from path
-function basename(path) {
-  var idx = path.lastIndexOf("/")
-  if (idx == -1) return path
-  return path.substring(idx + 1)
-}
-
-// Helper to join paths
-function join_paths(base, rel) {
-  base = base.replace(/\/+$/, "")
-  rel = rel.replace(/^\/+/, "")
-  if (!base) return rel
-  if (!rel) return base
-  return base + "/" + rel
-}
-
-// Check if a file exists in a specific mount
 function mount_exists(mount, path) {
+  var result = false
+  var full_path = null
+  var st = null
+  var _check = null
   if (mount.type == 'zip') {
-    try {
+    _check = function() {
       mount.handle.mod(path)
-      return true
-    } catch (e) {
-      return false
-    }
+      result = true
+    } disruption {}
+    _check()
   } else if (mount.type == 'qop') {
-    try {
-      return mount.handle.stat(path) != null
-    } catch (e) {
-      return false
-    }
-  } else { // fs
-    var full_path = join_paths(mount.source, path)
-    try {
-      var st = fd.stat(full_path)
-      return st.isFile || st.isDirectory
-    } catch (e) {
-      return false
-    }
+    _check = function() {
+      result = mount.handle.stat(path) != null
+    } disruption {}
+    _check()
+  } else if (mount.type == 'fs') {
+    full_path = fd.join_paths(mount.source, path)
+    _check = function() {
+      st = fd.stat(full_path)
+      result = st.isFile || st.isDirectory
+    } disruption {}
+    _check()
   }
+  return result
 }
 
-// Check if a path refers to a directory in a specific mount
 function is_directory(path) {
   var res = resolve(path)
   var mount = res.mount
+  var result = false
+  var full_path = null
+  var st = null
+  var _check = null
   if (mount.type == 'zip') {
-    try {
-      return mount.handle.is_directory(path);
-    } catch (e) {
-      return false;
-    }
+    _check = function() {
+      result = mount.handle.is_directory(path)
+    } disruption {}
+    _check()
   } else if (mount.type == 'qop') {
-    try {
-      return mount.handle.is_directory(path);
-    } catch (e) {
-      return false;
-    }
-  } else { // fs
-    var full_path = join_paths(mount.source, path)
-    try {
-      var st = fd.stat(full_path)
-      return st.isDirectory
-    } catch (e) {
-      return false
-    }
+    _check = function() {
+      result = mount.handle.is_directory(path)
+    } disruption {}
+    _check()
+  } else {
+    full_path = fd.join_paths(mount.source, path)
+    _check = function() {
+      st = fd.stat(full_path)
+      result = st.isDirectory
+    } disruption {}
+    _check()
   }
+  return result
 }
 
-// Resolve a path to a specific mount and relative path
-// Returns { mount, path } or throws/returns null
 function resolve(path, must_exist) {
-  path = normalize_path(path)
-  
-  // Check for named mount
-  if (path.startsWith("@")) {
-    var idx = path.indexOf("/")
-    var mount_name = ""
-    var rel_path = ""
-    
-    if (idx == -1) {
-      mount_name = path.substring(1)
+  var idx = null
+  var mount_name = ""
+  var rel_path = ""
+  var mount = null
+  var found_mount = null
+  var npath = normalize_path(path)
+
+  if (starts_with(npath, "@")) {
+    idx = search(npath, "/")
+
+    if (idx == null) {
+      mount_name = text(npath, 1)
       rel_path = ""
     } else {
-      mount_name = path.substring(1, idx)
-      rel_path = path.substring(idx + 1)
+      mount_name = text(npath, 1, idx)
+      rel_path = text(npath, idx + 1)
     }
-    
-    // Find named mount
-    var mount = null
-    for (var m of mounts) {
+
+    arrfor(mounts, function(m) {
       if (m.name == mount_name) {
         mount = m
-        break
+        return true
       }
-    }
-    
+    }, false, true)
+
     if (!mount) {
-      throw new Error("Unknown mount point: @" + mount_name)
+      log.error("Unknown mount point: @" + mount_name); disrupt
     }
-    
+
     return { mount: mount, path: rel_path }
   }
-  
-  // Search path
-  for (var mount of mounts) {
-    if (mount_exists(mount, path)) {
-      return { mount: mount, path: path }
+
+  arrfor(mounts, function(m) {
+    if (mount_exists(m, npath)) {
+      found_mount = { mount: m, path: npath }
+      return true
     }
+  }, false, true)
+
+  if (found_mount) {
+    return found_mount
   }
-  
+
   if (must_exist) {
-    throw new Error("File not found in any mount: " + path)
+    log.error("File not found in any mount: " + npath); disrupt
   }
 }
 
-// Mount a source
 function mount(source, name) {
-  // Check if source exists
-  var st = fd.stat(source)
-  
+  var st = null
+  var blob = null
+  var qop_archive = null
+  var zip = null
+  var _try_qop = null
+  var http = null
+
   var mount_info = {
     source: source,
     name: name || null,
@@ -155,109 +134,129 @@ function mount(source, name) {
     handle: null,
     zip_blob: null
   }
-  
+
+  if (starts_with(source, 'http://') || starts_with(source, 'https://')) {
+    http = use('http')
+    mount_info.type = 'http'
+    mount_info.handle = {
+      base_url: source,
+      get: function(path, callback) {
+        var url = source + '/' + path
+        $clock(function(_t) {
+          var resp = http.request('GET', url, null, null)
+          if (resp && resp.status == 200) {
+            callback(resp.body)
+          } else {
+            callback(null, "HTTP " + text(resp ? resp.status : 0) + ": " + url)
+          }
+        })
+      }
+    }
+    mounts[] = mount_info
+    return
+  }
+
+  st = fd.stat(source)
+
   if (st.isDirectory) {
     mount_info.type = 'fs'
   } else if (st.isFile) {
-    var blob = fd.slurp(source)
-    
-    // Try QOP first (it's likely faster to fail?) or Zip?
-    // QOP open checks magic.
-    var qop_archive = null
-    try {
-        qop_archive = qop.open(blob)
-    } catch(e) {}
+    blob = fd.slurp(source)
+
+    qop_archive = null
+    _try_qop = function() {
+      qop_archive = qop.open(blob)
+    } disruption {}
+    _try_qop()
 
     if (qop_archive) {
-        mount_info.type = 'qop'
-        mount_info.handle = qop_archive
-        mount_info.zip_blob = blob // keep blob alive
+      mount_info.type = 'qop'
+      mount_info.handle = qop_archive
+      mount_info.zip_blob = blob
     } else {
-        var zip = miniz.read(blob)
-        if (!zip || typeof zip.count != 'function') {
-          throw new Error("Invalid archive file (not zip or qop): " + source)
-        }
-        
-        mount_info.type = 'zip'
-        mount_info.handle = zip
-        mount_info.zip_blob = blob // keep blob alive
+      zip = miniz.read(blob)
+      if (!is_object(zip) || !is_function(zip.count)) {
+        log.error("Invalid archive file (not zip or qop): " + source); disrupt
+      }
+
+      mount_info.type = 'zip'
+      mount_info.handle = zip
+      mount_info.zip_blob = blob
     }
   } else {
-    throw new Error("Unsupported mount source type: " + source)
+    log.error("Unsupported mount source type: " + source); disrupt
   }
-  
-  mounts.push(mount_info)
+
+  mounts[] = mount_info
 }
 
-// Unmount
 function unmount(name_or_source) {
-  for (var i = 0; i < mounts.length; i++) {
-    if (mounts[i].name == name_or_source || mounts[i].source == name_or_source) {
-      mounts.splice(i, 1)
-      return
-    }
-  }
-  throw new Error("Mount not found: " + name_or_source)
+  mounts = filter(mounts, function(m) {
+    return m.name != name_or_source && m.source != name_or_source
+  })
 }
 
-// Read file
 function slurp(path) {
   var res = resolve(path, true)
-  if (!res) throw new Error("File not found: " + path)
-  
+  var data = null
+  var full_path = null
+  if (!res) { log.error("File not found: " + path); disrupt }
+
   if (res.mount.type == 'zip') {
     return res.mount.handle.slurp(res.path)
   } else if (res.mount.type == 'qop') {
-    var data = res.mount.handle.read(res.path)
-    if (!data) throw new Error("File not found in qop: " + path)
+    data = res.mount.handle.read(res.path)
+    if (!data) { log.error("File not found in qop: " + path); disrupt }
     return data
   } else {
-    var full_path = join_paths(res.mount.source, res.path)
+    full_path = fd.join_paths(res.mount.source, res.path)
     return fd.slurp(full_path)
   }
 }
 
-// Write file
 function slurpwrite(path, data) {
-  var full_path = writepath + "/" + path
-  
-  var f = fd.open(full_path, 'w')
-  fd.write(f, data)
-  fd.close(f)
+  var full_path = null
+  if (write_mount) {
+    full_path = fd.join_paths(write_mount.source, path)
+  } else {
+    full_path = fd.join_paths(".", path)
+  }
+  fd.slurpwrite(full_path, data)
 }
 
-// Check existence
 function exists(path) {
   var res = resolve(path, false)
-  if (path.startsWith("@")) {
+  if (starts_with(path, "@")) {
     return mount_exists(res.mount, res.path)
   }
   return res != null
 }
 
-// Stat
 function stat(path) {
   var res = resolve(path, true)
-  if (!res) throw new Error("File not found: " + path)
-  
+  var mod = null
+  var s = null
+  var full_path = null
+  if (!res) { log.error("File not found: " + path); disrupt }
+
   if (res.mount.type == 'zip') {
-    var mod = res.mount.handle.mod(res.path)
+    mod = res.mount.handle.mod(res.path)
     return {
-      filesize: 0, 
+      filesize: 0,
       modtime: mod * 1000,
-      isDirectory: false 
+      isDirectory: false
     }
   } else if (res.mount.type == 'qop') {
-    var s = res.mount.handle.stat(res.path)
-    if (!s) throw new Error("File not found in qop: " + path)
+    s = res.mount.handle.stat(res.path)
+    if (!s) { log.error("File not found in qop: " + path); disrupt }
     return {
         filesize: s.size,
         modtime: s.modtime,
         isDirectory: s.isDirectory
     }
   } else {
-    var full_path = join_paths(res.mount.source, res.path)
-    var s = fd.stat(full_path)
+    full_path = fd.join_paths(res.mount.source, res.path)
+    s = fd.stat(full_path)
     return {
       filesize: s.size,
       modtime: s.mtime,
@@ -266,51 +265,62 @@ function stat(path) {
   }
 }
 
-// Get search paths
 function searchpath() {
-  return mounts.slice()
+  return array(mounts)
 }
 
-// Mount a package using the shop system
 function mount_package(name) {
   if (name == null) {
     mount('.', null)
     return
   }
-  
+
   var shop = use('internal/shop')
   var dir = shop.get_package_dir(name)
 
   if (!dir) {
-    throw new Error("Package not found: " + name)
+    log.error("Package not found: " + name); disrupt
   }
 
   mount(dir, name)
 }
 
-// New functions for qjs_io compatibility
-
 function match(str, pattern) {
   return wildstar.match(pattern, str, wildstar.WM_PATHNAME | wildstar.WM_PERIOD | wildstar.WM_WILDSTAR)
 }
 
 function rm(path) {
   var res = resolve(path, true)
-  if (res.mount.type != 'fs') throw new Error("Cannot delete from non-fs mount")
-  
-  var full_path = join_paths(res.mount.source, res.path)
-  var st = fd.stat(full_path)
+  var full_path = null
+  var st = null
+  if (res.mount.type != 'fs') { log.error("Cannot delete from non-fs mount"); disrupt }
+
+  full_path = fd.join_paths(res.mount.source, res.path)
+  st = fd.stat(full_path)
   if (st.isDirectory) fd.rmdir(full_path)
   else fd.unlink(full_path)
 }
 
 function mkdir(path) {
-  var full = join_paths(writepath, path)
+  var full = null
+  if (write_mount) {
+    full = fd.join_paths(write_mount.source, path)
+  } else {
+    full = fd.join_paths(".", path)
+  }
   fd.mkdir(full)
 }
 
-function set_writepath(path) {
-  writepath = path
+function set_writepath(mount_name) {
+  var found = null
+  if (mount_name == null) { write_mount = null; return }
+  arrfor(mounts, function(m) {
+    if (m.name == mount_name) { found = m; return true }
+  }, false, true)
+  if (!found || found.type != 'fs') {
+    log.error("writepath: must be an fs mount"); disrupt
+  }
+  write_mount = found
 }
 
 function basedir() {
@@ -324,86 +334,107 @@ function prefdir(org, app) {
 function realdir(path) {
    var res = resolve(path, false)
    if (!res) return null
-   return join_paths(res.mount.source, res.path)
+   return fd.join_paths(res.mount.source, res.path)
 }
 
-function enumerate(path, recurse) {
-    if (path == null) path = ""
-    
+function enumerate(_path, recurse) {
+    var path = _path == null ? "" : _path
+
     var res = resolve(path, true)
     var results = []
-    
+    var full = null
+    var st = null
+    var all = null
+    var prefix = null
+    var prefix_len = null
+    var seen = null
+
     function visit(curr_full, rel_prefix) {
        var list = fd.readdir(curr_full)
        if (!list) return
-       
-       for (var item of list) {
+
+       arrfor(list, function(item) {
           var item_rel = rel_prefix ? rel_prefix + "/" + item : item
-          results.push(item_rel)
-          
+          var child_st = null
+          results[] = item_rel
+
           if (recurse) {
-             var st = fd.stat(join_paths(curr_full, item))
-             if (st.isDirectory) {
-                visit(join_paths(curr_full, item), item_rel)
+             child_st = fd.stat(fd.join_paths(curr_full, item))
+             if (child_st.isDirectory) {
+                visit(fd.join_paths(curr_full, item), item_rel)
              }
           }
-       }
+       })
     }
-    
+
     if (res.mount.type == 'fs') {
-        var full = join_paths(res.mount.source, res.path)
-        var st = fd.stat(full)
+        full = fd.join_paths(res.mount.source, res.path)
+        st = fd.stat(full)
         if (st && st.isDirectory) {
            visit(full, "")
         }
     } else if (res.mount.type == 'qop') {
-        var all = res.mount.handle.list()
-        var prefix = res.path ? res.path + "/" : ""
-        var prefix_len = prefix.length
-        
-        // Use a set to avoid duplicates if we are simulating directories
-        var seen = {}
-        
-        for (var p of all) {
-            if (p.startsWith(prefix)) {
-                var rel = p.substring(prefix_len)
-                if (rel.length == 0) continue
-                
+        all = res.mount.handle.list()
+        prefix = res.path ? res.path + "/" : ""
+        prefix_len = length(prefix)
+
+        seen = {}
+
+        arrfor(all, function(p) {
+            var rel = null
+            var slash = null
+            if (starts_with(p, prefix)) {
+                rel = text(p, prefix_len)
+                if (length(rel) == 0) return
+
                 if (!recurse) {
-                    var slash = rel.indexOf('/')
-                    if (slash != -1) {
-                        rel = rel.substring(0, slash)
+                    slash = search(rel, '/')
+                    if (slash != null) {
+                        rel = text(rel, 0, slash)
                     }
                 }
-                
+
                 if (!seen[rel]) {
                     seen[rel] = true
-                    results.push(rel)
+                    results[] = rel
                 }
             }
-        }
+        })
     }
-    
+
     return results
 }
 
-function globfs(globs, dir) {
-   if (dir == null) dir = ""
+function globfs(globs, _dir) {
+   var dir = _dir == null ? "" : _dir
    var res = resolve(dir, true)
    var results = []
-   
+   var full = null
+   var st = null
+   var all = null
+   var prefix = null
+   var prefix_len = null
+
    function check_neg(path) {
-        for (var g of globs) {
-            if (g.startsWith("!") && wildstar.match(g.substring(1), path, wildstar.WM_WILDSTAR)) return true;
-        }
-        return false;
+        var result = false
+        arrfor(globs, function(g) {
+            if (starts_with(g, "!") && wildstar.match(text(g, 1), path, wildstar.WM_WILDSTAR)) {
+                result = true
+                return true
+            }
+        }, false, true)
+        return result
     }
-    
+
    function check_pos(path) {
-        for (var g of globs) {
-            if (!g.startsWith("!") && wildstar.match(g, path, wildstar.WM_WILDSTAR)) return true;
-        }
-        return false;
+        var result = false
+        arrfor(globs, function(g) {
+            if (!starts_with(g, "!") && wildstar.match(g, path, wildstar.WM_WILDSTAR)) {
+                result = true
+                return true
+            }
+        }, false, true)
+        return result
     }
 
    function visit(curr_full, rel_prefix) {
@@ -411,52 +442,128 @@ function globfs(globs, dir) {
 
        var list = fd.readdir(curr_full)
        if (!list) return
-       
-       for (var item of list) {
+
+       arrfor(list, function(item) {
           var item_rel = rel_prefix ? rel_prefix + "/" + item : item
-          
-          var child_full = join_paths(curr_full, item)
-          var st = fd.stat(child_full)
-          
-          if (st.isDirectory) {
+
+          var child_full = fd.join_paths(curr_full, item)
+          var child_st = fd.stat(child_full)
+
+          if (child_st.isDirectory) {
               if (!check_neg(item_rel)) {
                  visit(child_full, item_rel)
               }
           } else {
               if (!check_neg(item_rel) && check_pos(item_rel)) {
-                  results.push(item_rel)
+                  results[] = item_rel
               }
           }
-       }
+       })
    }
-   
+
    if (res.mount.type == 'fs') {
-        var full = join_paths(res.mount.source, res.path)
-        var st = fd.stat(full)
+        full = fd.join_paths(res.mount.source, res.path)
+        st = fd.stat(full)
         if (st && st.isDirectory) {
            visit(full, "")
         }
    } else if (res.mount.type == 'qop') {
-        var all = res.mount.handle.list()
-        var prefix = res.path ? res.path + "/" : ""
-        var prefix_len = prefix.length
-        
-        for (var p of all) {
-            if (p.startsWith(prefix)) {
-                var rel = p.substring(prefix_len)
-                if (rel.length == 0) continue
-                
+        all = res.mount.handle.list()
+        prefix = res.path ? res.path + "/" : ""
+        prefix_len = length(prefix)
+
+        arrfor(all, function(p) {
+            var rel = null
+            if (starts_with(p, prefix)) {
+                rel = text(p, prefix_len)
+                if (length(rel) == 0) return
+
                 if (!check_neg(rel) && check_pos(rel)) {
-                    results.push(rel)
+                    results[] = rel
                 }
             }
-        }
+        })
    }
-   
+
    return results
 }
 
-// Exports
+// Requestor factory: returns a requestor for reading a file at path
+function get(path) {
+  return function get_requestor(callback, value) {
+    var res = resolve(path, false)
+    var full = null
+    var f = null
+    var acc = null
+    var cancelled = false
+    var data = null
+    var _close = null
+
+    if (!res) { callback(null, "not found: " + path); return }
+
+    if (res.mount.type == 'zip') {
+      callback(res.mount.handle.slurp(res.path))
+      return
+    }
+    if (res.mount.type == 'qop') {
+      data = res.mount.handle.read(res.path)
+      if (data) {
+        callback(data)
+      } else {
+        callback(null, "not found in qop: " + path)
+      }
+      return
+    }
+    if (res.mount.type == 'http') {
+      res.mount.handle.get(res.path, callback)
+      return
+    }
+
+    full = fd.join_paths(res.mount.source, res.path)
+    f = fd.open(full, 'r')
+    acc = blob()
+
+    function next(_t) {
+      var chunk = null
+      if (cancelled) return
+      chunk = fd.read(f, 65536)
+      if (length(chunk) == 0) {
+        fd.close(f)
+        stone(acc)
+        callback(acc)
+        return
+      }
+      acc.write_blob(chunk)
+      $clock(next)
+    }
+
+    next()
+    return function cancel() {
+      cancelled = true
+      _close = function() { fd.close(f) } disruption {}
+      _close()
+    }
+  }
+}
+
+// Requestor factory: returns a requestor for writing data to path
+function put(path, data) {
+  return function put_requestor(callback, value) {
+    var _data = data != null ? data : value
+    var full = null
+    var _do = null
+    if (!write_mount) { callback(null, "no write mount set"); return }
+    full = fd.join_paths(write_mount.source, path)
+    _do = function() {
+      fd.slurpwrite(full, _data)
+      callback(true)
+    } disruption {
+      callback(null, "write failed: " + path)
+    }
+    _do()
+  }
+}
+
 cellfs.mount = mount
 cellfs.mount_package = mount_package
 cellfs.unmount = unmount
@@ -475,7 +582,8 @@ cellfs.writepath = set_writepath
 cellfs.basedir = basedir
 cellfs.prefdir = prefdir
 cellfs.realdir = realdir
-
-cellfs.mount('.')
+cellfs.get = get
+cellfs.put = put
+cellfs.resolve = resolve
 
 return cellfs

cfg.ce

@@ -0,0 +1,456 @@
+// cfg.ce — control flow graph
+//
+// Usage:
+//   cell cfg --fn <N|name> <file>         Text CFG for function
+//   cell cfg --dot --fn <N|name> <file>   DOT output for graphviz
+//   cell cfg <file>                       Text CFG for all functions
+
+var shop = use("internal/shop")
+
+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 text(v)
+  if (is_logical(v)) return v ? "true" : "false"
+  return text(v)
+}
+
+var is_jump_op = function(op) {
+  return op == "jump" || op == "jump_true" || op == "jump_false" || op == "jump_null" || op == "jump_not_null"
+}
+
+var is_conditional_jump = function(op) {
+  return op == "jump_true" || op == "jump_false" || op == "jump_null" || op == "jump_not_null"
+}
+
+var is_terminator = function(op) {
+  return op == "return" || op == "disrupt" || op == "tail_invoke" || op == "goinvoke"
+}
+
+var run = function() {
+  var filename = null
+  var fn_filter = null
+  var show_dot = false
+  var use_optimized = false
+  var i = 0
+  var compiled = null
+  var main_name = null
+  var fi = 0
+  var func = null
+  var fname = null
+
+  while (i < length(args)) {
+    if (args[i] == '--fn') {
+      i = i + 1
+      fn_filter = args[i]
+    } else if (args[i] == '--dot') {
+      show_dot = true
+    } else if (args[i] == '--optimized') {
+      use_optimized = true
+    } else if (args[i] == '--help' || args[i] == '-h') {
+      log.console("Usage: cell cfg [--fn <N|name>] [--dot] [--optimized] <file>")
+      log.console("")
+      log.console("  --fn <N|name>   Filter to function by index or name")
+      log.console("  --dot           Output DOT format for graphviz")
+      log.console("  --optimized     Use optimized IR")
+      return null
+    } else if (!starts_with(args[i], '-')) {
+      filename = args[i]
+    }
+    i = i + 1
+  }
+
+  if (!filename) {
+    log.console("Usage: cell cfg [--fn <N|name>] [--dot] [--optimized] <file>")
+    return null
+  }
+
+  if (use_optimized) {
+    compiled = shop.compile_file(filename)
+  } else {
+    compiled = shop.mcode_file(filename)
+  }
+
+  var fn_matches = function(index, name) {
+    var match = null
+    if (fn_filter == null) return true
+    if (index >= 0 && fn_filter == text(index)) return true
+    if (name != null) {
+      match = search(name, fn_filter)
+      if (match != null && match >= 0) return true
+    }
+    return false
+  }
+
+  var build_cfg = function(func) {
+    var instrs = func.instructions
+    var blocks = []
+    var label_to_block = {}
+    var pc_to_block = {}
+    var label_to_pc = {}
+    var block_start_pcs = {}
+    var after_terminator = false
+    var current_block = null
+    var current_label = null
+    var pc = 0
+    var ii = 0
+    var bi = 0
+    var instr = null
+    var op = null
+    var n = 0
+    var line_num = null
+    var blk = null
+    var last_instr_data = null
+    var last_op = null
+    var target_label = null
+    var target_bi = null
+    var edge_type = null
+
+    if (instrs == null || length(instrs) == 0) return []
+
+    // Pass 1: identify block start PCs
+    block_start_pcs["0"] = true
+    pc = 0
+    ii = 0
+    while (ii < length(instrs)) {
+      instr = instrs[ii]
+      if (is_array(instr)) {
+        op = instr[0]
+        if (after_terminator) {
+          block_start_pcs[text(pc)] = true
+          after_terminator = false
+        }
+        if (is_jump_op(op) || is_terminator(op)) {
+          after_terminator = true
+        }
+        pc = pc + 1
+      }
+      ii = ii + 1
+    }
+
+    // Pass 2: map labels to PCs and mark as block starts
+    pc = 0
+    ii = 0
+    while (ii < length(instrs)) {
+      instr = instrs[ii]
+      if (is_text(instr) && !starts_with(instr, "_nop_")) {
+        label_to_pc[instr] = pc
+        block_start_pcs[text(pc)] = true
+      } else if (is_array(instr)) {
+        pc = pc + 1
+      }
+      ii = ii + 1
+    }
+
+    // Pass 3: build basic blocks
+    pc = 0
+    ii = 0
+    current_label = null
+    while (ii < length(instrs)) {
+      instr = instrs[ii]
+      if (is_text(instr)) {
+        if (!starts_with(instr, "_nop_")) {
+          current_label = instr
+        }
+        ii = ii + 1
+        continue
+      }
+
+      if (is_array(instr)) {
+        if (block_start_pcs[text(pc)]) {
+          if (current_block != null) {
+            blocks[] = current_block
+          }
+          current_block = {
+            id: length(blocks),
+            label: current_label,
+            start_pc: pc,
+            end_pc: pc,
+            instrs: [],
+            edges: [],
+            first_line: null,
+            last_line: null
+          }
+          current_label = null
+        }
+
+        if (current_block != null) {
+          current_block.instrs[] = {pc: pc, instr: instr}
+          current_block.end_pc = pc
+          n = length(instr)
+          line_num = instr[n - 2]
+          if (line_num != null) {
+            if (current_block.first_line == null) {
+              current_block.first_line = line_num
+            }
+            current_block.last_line = line_num
+          }
+        }
+        pc = pc + 1
+      }
+      ii = ii + 1
+    }
+    if (current_block != null) {
+      blocks[] = current_block
+    }
+
+    // Build block index
+    bi = 0
+    while (bi < length(blocks)) {
+      pc_to_block[text(blocks[bi].start_pc)] = bi
+      if (blocks[bi].label != null) {
+        label_to_block[blocks[bi].label] = bi
+      }
+      bi = bi + 1
+    }
+
+    // Pass 4: compute edges
+    bi = 0
+    while (bi < length(blocks)) {
+      blk = blocks[bi]
+      if (length(blk.instrs) > 0) {
+        last_instr_data = blk.instrs[length(blk.instrs) - 1]
+        last_op = last_instr_data.instr[0]
+        n = length(last_instr_data.instr)
+
+        if (is_jump_op(last_op)) {
+          if (last_op == "jump") {
+            target_label = last_instr_data.instr[1]
+          } else {
+            target_label = last_instr_data.instr[2]
+          }
+
+          target_bi = label_to_block[target_label]
+          if (target_bi != null) {
+            edge_type = "jump"
+            if (target_bi <= bi) {
+              edge_type = "loop back-edge"
+            }
+            blk.edges[] = {target: target_bi, kind: edge_type}
+          }
+
+          if (is_conditional_jump(last_op)) {
+            if (bi + 1 < length(blocks)) {
+              blk.edges[] = {target: bi + 1, kind: "fallthrough"}
+            }
+          }
+        } else if (is_terminator(last_op)) {
+          blk.edges[] = {target: -1, kind: "EXIT (" + last_op + ")"}
+        } else {
+          if (bi + 1 < length(blocks)) {
+            blk.edges[] = {target: bi + 1, kind: "fallthrough"}
+          }
+        }
+      }
+      bi = bi + 1
+    }
+
+    return blocks
+  }
+
+  var print_cfg_text = function(blocks, name) {
+    var bi = 0
+    var blk = null
+    var header = null
+    var ii = 0
+    var idata = null
+    var instr = null
+    var op = null
+    var n = 0
+    var parts = null
+    var j = 0
+    var operands = null
+    var ei = 0
+    var edge = null
+    var target_label = null
+
+    log.compile(`\n=== ${name} ===`)
+
+    if (length(blocks) == 0) {
+      log.compile("  (empty)")
+      return null
+    }
+
+    bi = 0
+    while (bi < length(blocks)) {
+      blk = blocks[bi]
+      header = `  B${text(bi)}`
+      if (blk.label != null) {
+        header = header + ` "${blk.label}"`
+      }
+      header = header + ` [pc ${text(blk.start_pc)}-${text(blk.end_pc)}`
+      if (blk.first_line != null) {
+        if (blk.first_line == blk.last_line) {
+          header = header + `, line ${text(blk.first_line)}`
+        } else {
+          header = header + `, lines ${text(blk.first_line)}-${text(blk.last_line)}`
+        }
+      }
+      header = header + "]:"
+
+      log.compile(header)
+
+      ii = 0
+      while (ii < length(blk.instrs)) {
+        idata = blk.instrs[ii]
+        instr = idata.instr
+        op = instr[0]
+        n = length(instr)
+        parts = []
+        j = 1
+        while (j < n - 2) {
+          parts[] = fmt_val(instr[j])
+          j = j + 1
+        }
+        operands = text(parts, ", ")
+        log.compile(`    ${pad_right(text(idata.pc), 6)}${pad_right(op, 15)}${operands}`)
+        ii = ii + 1
+      }
+
+      ei = 0
+      while (ei < length(blk.edges)) {
+        edge = blk.edges[ei]
+        if (edge.target == -1) {
+          log.compile(`    -> ${edge.kind}`)
+        } else {
+          target_label = blocks[edge.target].label
+          if (target_label != null) {
+            log.compile(`    -> B${text(edge.target)} "${target_label}" (${edge.kind})`)
+          } else {
+            log.compile(`    -> B${text(edge.target)} (${edge.kind})`)
+          }
+        }
+        ei = ei + 1
+      }
+
+      log.compile("")
+      bi = bi + 1
+    }
+    return null
+  }
+
+  var print_cfg_dot = function(blocks, name) {
+    var safe_name = replace(replace(name, '"', '\\"'), ' ', '_')
+    var bi = 0
+    var blk = null
+    var label_text = null
+    var ii = 0
+    var idata = null
+    var instr = null
+    var op = null
+    var n = 0
+    var parts = null
+    var j = 0
+    var operands = null
+    var ei = 0
+    var edge = null
+    var style = null
+
+    log.compile(`digraph "${safe_name}" {`)
+    log.compile("  rankdir=TB;")
+    log.compile("  node [shape=record, fontname=monospace, fontsize=10];")
+
+    bi = 0
+    while (bi < length(blocks)) {
+      blk = blocks[bi]
+      label_text = "B" + text(bi)
+      if (blk.label != null) {
+        label_text = label_text + " (" + blk.label + ")"
+      }
+      label_text = label_text + "\\npc " + text(blk.start_pc) + "-" + text(blk.end_pc)
+      if (blk.first_line != null) {
+        label_text = label_text + "\\nline " + text(blk.first_line)
+      }
+      label_text = label_text + "|"
+
+      ii = 0
+      while (ii < length(blk.instrs)) {
+        idata = blk.instrs[ii]
+        instr = idata.instr
+        op = instr[0]
+        n = length(instr)
+        parts = []
+        j = 1
+        while (j < n - 2) {
+          parts[] = fmt_val(instr[j])
+          j = j + 1
+        }
+        operands = text(parts, ", ")
+        label_text = label_text + text(idata.pc) + " " + op + " " + replace(operands, '"', '\\"') + "\\l"
+        ii = ii + 1
+      }
+
+      log.compile("  B" + text(bi) + " [label=\"{" + label_text + "}\"];")
+      bi = bi + 1
+    }
+
+    // Edges
+    bi = 0
+    while (bi < length(blocks)) {
+      blk = blocks[bi]
+      ei = 0
+      while (ei < length(blk.edges)) {
+        edge = blk.edges[ei]
+        if (edge.target >= 0) {
+          style = ""
+          if (edge.kind == "loop back-edge") {
+            style = " [style=bold, color=red, label=\"loop\"]"
+          } else if (edge.kind == "fallthrough") {
+            style = " [style=dashed]"
+          }
+          log.compile(`  B${text(bi)} -> B${text(edge.target)}${style};`)
+        }
+        ei = ei + 1
+      }
+      bi = bi + 1
+    }
+
+    log.compile("}")
+    return null
+  }
+
+  var process_function = function(func, name, index) {
+    var blocks = build_cfg(func)
+    if (show_dot) {
+      print_cfg_dot(blocks, name)
+    } else {
+      print_cfg_text(blocks, name)
+    }
+    return null
+  }
+
+  // Process functions
+  main_name = compiled.name != null ? compiled.name : "<main>"
+
+  if (compiled.main != null) {
+    if (fn_matches(-1, main_name)) {
+      process_function(compiled.main, main_name, -1)
+    }
+  }
+
+  if (compiled.functions != null) {
+    fi = 0
+    while (fi < length(compiled.functions)) {
+      func = compiled.functions[fi]
+      fname = func.name != null ? func.name : "<anonymous>"
+      if (fn_matches(fi, fname)) {
+        process_function(func, `[${text(fi)}] ${fname}`, fi)
+      }
+      fi = fi + 1
+    }
+  }
+
+  return null
+}
+
+run()
+$stop()

clean.ce

@@ -1,26 +1,197 @@
-// cell clean - Remove build artifacts from global shop
+// cell clean [<scope>] - Remove cached material to force refetch/rebuild
+//
+// Usage:
+//   cell clean              Clean build outputs for current directory package
+//   cell clean .            Clean build outputs for current directory package
+//   cell clean <locator>    Clean build outputs for specific package
+//   cell clean shop         Clean entire shop
+//   cell clean world        Clean all world packages
+//
+// Options:
+//   --build      Remove build outputs only (default)
+//   --fetch      Remove fetched sources only
+//   --all        Remove both build outputs and fetched sources
+//   --deep       Apply to full dependency closure
+//   --dry-run    Show what would be deleted
 
-var fd = use('fd')
 var shop = use('internal/shop')
+var pkg = use('package')
+var fd = use('fd')
 
-var build_dir = shop.get_shop_path() + '/build'
+var scope = null
+var clean_build = false
+var clean_fetch = false
+var deep = false
+var dry_run = false
+var i = 0
+var deps = null
 
-if (!fd.is_dir(build_dir)) {
-  log.console("No build directory found at " + build_dir)
-  $stop()
-  return
+var run = function() {
+  for (i = 0; i < length(args); i++) {
+    if (args[i] == '--build') {
+      clean_build = true
+    } else if (args[i] == '--fetch') {
+      clean_fetch = true
+    } else if (args[i] == '--all') {
+      clean_build = true
+      clean_fetch = true
+    } else if (args[i] == '--deep') {
+      deep = true
+    } else if (args[i] == '--dry-run') {
+      dry_run = true
+    } else if (args[i] == '--help' || args[i] == '-h') {
+      log.console("Usage: cell clean [<scope>] [options]")
+      log.console("")
+      log.console("Remove cached material to force refetch/rebuild.")
+      log.console("")
+      log.console("Scopes:")
+      log.console("  <locator>  Clean specific package")
+      log.console("  shop       Clean entire shop")
+      log.console("  world      Clean all world packages")
+      log.console("")
+      log.console("Options:")
+      log.console("  --build    Remove build outputs only (default)")
+      log.console("  --fetch    Remove fetched sources only")
+      log.console("  --all      Remove both build outputs and fetched sources")
+      log.console("  --deep     Apply to full dependency closure")
+      log.console("  --dry-run  Show what would be deleted")
+      return
+    } else if (!starts_with(args[i], '-')) {
+      scope = args[i]
+    }
+  }
+
+// Default to --build if nothing specified
+if (!clean_build && !clean_fetch) {
+  clean_build = true
 }
 
-log.console("Cleaning build artifacts...")
-
-// Remove the build directory
-try {
-  fd.rm(build_dir)
-  log.console("Build directory removed: " + build_dir)
-} catch (e) {
-  log.error(e)
+// Default scope to current directory
+if (!scope) {
+  scope = '.'
 }
 
-log.console("Clean complete!")
+// Resolve local paths for single package scope
+var is_shop_scope = (scope == 'shop')
+var is_world_scope = (scope == 'world')
 
-$stop()
+if (!is_shop_scope && !is_world_scope) {
+  scope = shop.resolve_locator(scope)
+}
+
+var files_to_delete = []
+var dirs_to_delete = []
+
+// Gather packages to clean
+var packages_to_clean = []
+var _gather = null
+
+if (is_shop_scope) {
+  packages_to_clean = shop.list_packages()
+} else if (is_world_scope) {
+  // For now, world is the same as shop
+  packages_to_clean = shop.list_packages()
+} else {
+  // Single package
+  packages_to_clean[] = scope
+
+  if (deep) {
+    _gather = function() {
+      deps = pkg.gather_dependencies(scope)
+      arrfor(deps, function(dep) {
+        packages_to_clean[] = dep
+      })
+    } disruption {
+      // Skip if can't read dependencies
+    }
+    _gather()
+  }
+}
+
+// Gather files to clean
+var lib_dir = shop.get_lib_dir()
+var build_dir = shop.get_build_dir()
+var packages_dir = replace(shop.get_package_dir(''), /\/$/, '') // Get base packages dir
+
+if (clean_build) {
+  // Nuke entire build cache (content-addressed, per-package clean impractical)
+  if (fd.is_dir(build_dir)) {
+    dirs_to_delete[] = build_dir
+  }
+  // Clean orphaned lib/ directory if it exists (legacy)
+  if (fd.is_dir(lib_dir)) {
+    dirs_to_delete[] = lib_dir
+  }
+}
+
+if (clean_fetch) {
+  if (is_shop_scope) {
+    // Clean entire packages directory (dangerous!)
+    if (fd.is_dir(packages_dir)) {
+      dirs_to_delete[] = packages_dir
+    }
+  } else {
+    // Clean specific package directories
+    arrfor(packages_to_clean, function(p) {
+      if (p == 'core') return
+
+      var pkg_dir = shop.get_package_dir(p)
+      if (fd.is_dir(pkg_dir) || fd.is_link(pkg_dir)) {
+        dirs_to_delete[] = pkg_dir
+      }
+    })
+  }
+}
+
+// Execute or report
+var deleted_count = 0
+if (dry_run) {
+  log.console("Would delete:")
+  if (length(files_to_delete) == 0 && length(dirs_to_delete) == 0) {
+    log.console("  (nothing to clean)")
+  } else {
+    arrfor(files_to_delete, function(f) {
+      log.console("  [file] " + f)
+    })
+    arrfor(dirs_to_delete, function(d) {
+      log.console("  [dir]  " + d)
+    })
+  }
+} else {
+  arrfor(files_to_delete, function(f) {
+    var _del = function() {
+      fd.unlink(f)
+      log.console("Deleted: " + f)
+      deleted_count++
+    } disruption {
+      log.error("Failed to delete " + f)
+    }
+    _del()
+  })
+
+  arrfor(dirs_to_delete, function(d) {
+    var _del = function() {
+      if (fd.is_link(d)) {
+        fd.unlink(d)
+      } else {
+        fd.rmdir(d, 1) // recursive
+      }
+      log.console("Deleted: " + d)
+      deleted_count++
+    } disruption {
+      log.error("Failed to delete " + d)
+    }
+    _del()
+  })
+
+  if (deleted_count == 0) {
+    log.console("Nothing to clean.")
+  } else {
+    log.console("")
+    log.console("Clean complete: " + text(deleted_count) + " item(s) deleted.")
+  }
+}
+}
+run()
+
+$stop()

clone.ce

@@ -5,118 +5,67 @@ var shop = use('internal/shop')
 var link = use('link')
 var fd = use('fd')
 var http = use('http')
-var miniz = use('miniz')
 
-if (args.length < 2) {
-  log.console("Usage: cell clone <origin> <path>")
-  log.console("Clones a cell package to a local path and links it.")
-  $stop()
-  return
-}
+var run = function() {
+  if (length(args) < 2) {
+    log.console("Usage: cell clone <origin> <path>")
+    log.console("Clones a cell package to a local path and links it.")
+    return
+  }
 
 var origin = args[0]
 var target_path = args[1]
 
 // Resolve target path to absolute
-if (target_path == '.' || target_path.startsWith('./') || target_path.startsWith('../')) {
-  var resolved = fd.realpath(target_path)
-  if (resolved) {
-    target_path = resolved
-  } else {
-    // Path doesn't exist yet, resolve relative to cwd
-    var cwd = fd.realpath('.')
-    if (target_path == '.') {
-      target_path = cwd
-    } else if (target_path.startsWith('./')) {
-      target_path = cwd + target_path.substring(1)
-    } else if (target_path.startsWith('../')) {
-      // Go up one directory from cwd
-      var parent = cwd.substring(0, cwd.lastIndexOf('/'))
-      target_path = parent + target_path.substring(2)
-    }
-  }
-}
+target_path = shop.resolve_locator(target_path)
 
 // Check if target already exists
-if (fd.is_dir(target_path)) {
-  log.console("Error: " + target_path + " already exists")
-  $stop()
-  return
-}
+  if (fd.is_dir(target_path)) {
+    log.console("Error: " + target_path + " already exists")
+    return
+  }
 
 log.console("Cloning " + origin + " to " + target_path + "...")
 
 // Get the latest commit
 var info = shop.resolve_package_info(origin)
-if (!info || info == 'local') {
-  log.console("Error: " + origin + " is not a remote package")
-  $stop()
-  return
-}
+  if (!info || info == 'local') {
+    log.console("Error: " + origin + " is not a remote package")
+    return
+  }
 
 // Update to get the commit hash
 var update_result = shop.update(origin)
-if (!update_result) {
-  log.console("Error: Could not fetch " + origin)
-  $stop()
-  return
-}
+  if (!update_result) {
+    log.console("Error: Could not fetch " + origin)
+    return
+  }
 
 // Fetch and extract to the target path
 var lock = shop.load_lock()
 var entry = lock[origin]
-if (!entry || !entry.commit) {
-  log.console("Error: No commit found for " + origin)
-  $stop()
-  return
-}
+  if (!entry || !entry.commit) {
+    log.console("Error: No commit found for " + origin)
+    return
+  }
 
 var download_url = shop.get_download_url(origin, entry.commit)
 log.console("Downloading from " + download_url)
 
-try {
+var _clone = function() {
   var zip_blob = http.fetch(download_url)
-  
-  // Extract zip to target path
-  var zip = miniz.read(zip_blob)
-  if (!zip) {
-    log.console("Error: Failed to read zip archive")
-    $stop()
-    return
-  }
-  
-  // Create target directory
-  fd.mkdir(target_path)
-  
-  var count = zip.count()
-  for (var i = 0; i < count; i++) {
-    if (zip.is_directory(i)) continue
-    var filename = zip.get_filename(i)
-    var parts = filename.split('/')
-    if (parts.length <= 1) continue
-    
-    // Skip the first directory (repo-commit prefix)
-    parts.shift()
-    var rel_path = parts.join('/')
-    var full_path = target_path + '/' + rel_path
-    var dir_path = full_path.substring(0, full_path.lastIndexOf('/'))
-    
-    // Ensure directory exists
-    if (!fd.is_dir(dir_path)) {
-      fd.mkdir(dir_path)
-    }
-    fd.slurpwrite(full_path, zip.slurp(filename))
-  }
-  
+  shop.install_zip(zip_blob, target_path)
+
   log.console("Extracted to " + target_path)
-  
+
   // Link the origin to the cloned path
   link.add(origin, target_path, shop)
   log.console("Linked " + origin + " -> " + target_path)
-  
-} catch (e) {
-  log.console("Error: " + e.message)
-  if (e.stack) log.console(e.stack)
+} disruption {
+  log.console("Error during clone")
 }
+  _clone()
+}
+run()
 
 $stop()

compare_aot.ce

@@ -0,0 +1,130 @@
+// compare_aot.ce — compile a .ce/.cm file via both paths and compare results
+//
+// Usage:
+//   cell --dev compare_aot.ce <file.ce>
+
+var build = use('build')
+var fd_mod = use('fd')
+var os = use('internal/os')
+var json = use('json')
+var time = use('time')
+
+var show = function(v) {
+  if (v == null) return "null"
+  return json.encode(v)
+}
+
+if (length(args) < 1) {
+  log.compile('usage: cell --dev compare_aot.ce <file>')
+  return
+}
+
+var file = args[0]
+if (!fd_mod.is_file(file)) {
+  if (!ends_with(file, '.ce') && fd_mod.is_file(file + '.ce'))
+    file = file + '.ce'
+  else if (!ends_with(file, '.cm') && fd_mod.is_file(file + '.cm'))
+    file = file + '.cm'
+  else {
+    log.error('file not found: ' + file)
+    return
+  }
+}
+
+var abs = fd_mod.realpath(file)
+
+// Shared compilation front-end — uses raw modules for per-stage timing
+var tokenize = use('tokenize')
+var parse_mod = use('parse')
+var fold = use('fold')
+var mcode_mod = use('mcode')
+var streamline_mod = use('streamline')
+
+var t0 = time.number()
+var src = text(fd_mod.slurp(abs))
+var t1 = time.number()
+var tok = tokenize(src, abs)
+var t2 = time.number()
+var ast = parse_mod(tok.tokens, src, abs, tokenize)
+var t3 = time.number()
+var folded = fold(ast)
+var t4 = time.number()
+var compiled = mcode_mod(folded)
+var t5 = time.number()
+var optimized = streamline_mod(compiled)
+var t6 = time.number()
+
+log.compile('--- front-end timing ---')
+log.compile('  read:       ' + text(t1 - t0) + 's')
+log.compile('  tokenize:   ' + text(t2 - t1) + 's')
+log.compile('  parse:      ' + text(t3 - t2) + 's')
+log.compile('  fold:       ' + text(t4 - t3) + 's')
+log.compile('  mcode:      ' + text(t5 - t4) + 's')
+log.compile('  streamline: ' + text(t6 - t5) + 's')
+log.compile('  total:      ' + text(t6 - t0) + 's')
+
+// Shared env for both paths — only non-intrinsic runtime functions.
+// Intrinsics (starts_with, ends_with, logical, some, every, etc.) live on
+// the stoned global and are found via GETINTRINSIC/cell_rt_get_intrinsic.
+var env = stone({
+  log: log,
+  fallback: fallback,
+  parallel: parallel,
+  race: race,
+  sequence: sequence,
+  use
+})
+
+// --- Interpreted (mach VM) ---
+var result_interp = null
+var interp_ok = false
+var run_interp = function() {
+  log.compile('--- interpreted ---')
+  var mcode_json = json.encode(optimized)
+  var mach_blob = mach_compile_mcode_bin(abs, mcode_json)
+  result_interp = mach_load(mach_blob, env)
+  interp_ok = true
+  log.compile('result: ' + show(result_interp))
+} disruption {
+  interp_ok = true
+  log.compile('(disruption escaped from interpreted run)')
+}
+run_interp()
+
+// --- Native (AOT via QBE) ---
+var result_native = null
+var native_ok = false
+var run_native = function() {
+  log.compile('\n--- native ---')
+  var dylib_path = build.compile_native_ir(optimized, abs, null)
+  log.compile('dylib: ' + dylib_path)
+  var handle = os.dylib_open(dylib_path)
+  if (!handle) {
+    log.error('failed to open dylib')
+    return
+  }
+  result_native = os.native_module_load(handle, env)
+  native_ok = true
+  log.compile('result: ' + show(result_native))
+} disruption {
+  native_ok = true
+  log.compile('(disruption escaped from native run)')
+}
+run_native()
+
+// --- Comparison ---
+log.compile('\n--- comparison ---')
+var s_interp = show(result_interp)
+var s_native = show(result_native)
+if (interp_ok && native_ok) {
+  if (s_interp == s_native) {
+    log.compile('MATCH')
+  } else {
+    log.error('MISMATCH')
+    log.error('  interp: ' + s_interp)
+    log.error('  native: ' + s_native)
+  }
+} else {
+  if (!interp_ok) log.error('interpreted run failed')
+  if (!native_ok) log.error('native run failed')
+}

compile.ce

@@ -0,0 +1,27 @@
+// compile.ce — compile a .cm or .ce file to native .dylib via QBE
+//
+// Usage:
+//   cell compile <file.cm|file.ce>
+//
+// Installs the dylib to .cell/lib/<pkg>/<stem>.dylib
+
+var shop = use('internal/shop')
+var build = use('build')
+var fd = use('fd')
+
+if (length(args) < 1) {
+  log.compile('usage: cell compile <file.cm|file.ce>')
+  return
+}
+
+var file = args[0]
+if (!fd.is_file(file)) {
+  log.error('file not found: ' + file)
+  return
+}
+
+var abs = fd.realpath(file)
+var file_info = shop.file_info(abs)
+var pkg = file_info.package
+
+build.compile_native(abs, null, null, pkg)

compile_worker.ce

@@ -0,0 +1,40 @@
+// compile_worker - Worker actor that compiles a single module and replies
+//
+// Receives a message with:
+//   {type: 'script', path, package}       — bytecode compile
+//   {type: 'native_script', path, package} — native compile
+//   {type: 'c_package', package}           — C package build
+//   {type: 'c_file', package, file}        — single C module build
+//
+// Replies with {ok: true/false, path} and stops.
+
+var shop = use('internal/shop')
+var build = use('build')
+
+$receiver(function(msg) {
+  var name = msg.path || (msg.file ? msg.package + '/' + msg.file : msg.package)
+  var _work = function() {
+    if (msg.type == 'script') {
+      log.console('compile_worker: compiling ' + name)
+      shop.precompile(msg.path, msg.package)
+    } else if (msg.type == 'native_script') {
+      log.console('compile_worker: native compiling ' + name)
+      build.compile_native(msg.path, null, null, msg.package)
+    } else if (msg.type == 'c_package') {
+      log.console('compile_worker: building package ' + name)
+      build.build_dynamic(msg.package, null, null, null)
+    } else if (msg.type == 'c_file') {
+      log.console('compile_worker: building ' + name)
+      build.compile_c_module(msg.package, msg.file)
+    }
+    log.console('compile_worker: done ' + name)
+    send(msg, {ok: true, path: name})
+  } disruption {
+    log.error('compile_worker: failed ' + name)
+    send(msg, {ok: false, error: 'compile failed'})
+  }
+  _work()
+  $stop()
+})
+
+var _t = $delay($stop, 120)

config.ce

@@ -31,216 +31,192 @@ function print_help() {
 
 // Parse a dot-notation key into path segments
 function parse_key(key) {
-  return key.split('.')
+  return array(key, '.')
 }
 
 // Get a value from nested object using path
 function get_nested(obj, path) {
   var current = obj
-  for (var segment of path) {
-    if (!current || typeof current != 'object') return null
+  arrfor(path, function(segment) {
+    if (is_null(current) || !is_object(current)) return null
     current = current[segment]
-  }
+  })
   return current
 }
 
 // Set a value in nested object using path
 function set_nested(obj, path, value) {
   var current = obj
-  for (var i = 0; i < path.length - 1; i++) {
-    var segment = path[i]
-    if (!current[segment] || typeof current[segment] != 'object') {
+  var i = 0
+  var segment = null
+  for (i = 0; i < length(path) - 1; i++) {
+    segment = path[i]
+    if (is_null(current[segment]) || !is_object(current[segment])) {
       current[segment] = {}
     }
     current = current[segment]
   }
-  current[path[path.length - 1]] = value
+  current[path[length(path) - 1]] = value
 }
 
 // Parse value string into appropriate type
 function parse_value(str) {
+  var num_str = null
+  var n = null
   // Boolean
   if (str == 'true') return true
   if (str == 'false') return false
-  
-  // Number (including underscores)
-  var num_str = str.replace(/_/g, '')
-  if (/^-?\d+$/.test(num_str)) return parseInt(num_str)
-  if (/^-?\d*\.\d+$/.test(num_str)) return parseFloat(num_str)
-  
+
+  // Number
+  num_str = replace(str, /_/g, '')
+  n = number(num_str)
+  if (n != null) return n
+
   // String
   return str
 }
 
 // Format value for display
 function format_value(val) {
-  if (typeof val == 'string') return '"' + val + '"'
-  if (typeof val == 'number' && val >= 1000) {
-    // Add underscores to large numbers
-    return val.toString().replace(/\B(?=(\d{3})+(?!\d))/g, '_')
-  }
+  if (is_text(val)) return '"' + val + '"'
   return text(val)
 }
 
 // Print configuration tree recursively
-function print_config(obj, prefix = '') {
-  for (var key in obj) {
+function print_config(obj, pfx) {
+  var p = pfx || ''
+  arrfor(array(obj), function(key) {
     var val = obj[key]
-    var full_key = prefix ? prefix + '.' + key : key
-    
-    if (isa(val, object))
+    var full_key = p ? p + '.' + key : key
+
+    if (is_object(val))
       print_config(val, full_key)
-    else
+    else if (!is_null(val))
       log.console(full_key + ' = ' + format_value(val))
-  }
+  })
 }
 
 // Main command handling
-if (args.length == 0) {
+if (length(args) == 0) {
   print_help()
   $stop()
-  return
 }
 
 var config = pkg.load_config()
 if (!config) {
   log.error("Failed to load cell.toml")
   $stop()
-  return
 }
 
 var command = args[0]
+var key = null
+var path = null
+var value = null
+var value_str = null
+var valid_system_keys = null
+var actor_name = null
+var actor_cmd = null
 
-switch (command) {
-  case 'help':
-  case '-h':
-  case '--help':
-    print_help()
-    break
-    
-  case 'list':
-    log.console("# Cell Configuration")
-    log.console("")
-    print_config(config)
-    break
-    
-  case 'get':
-    if (args.length < 2) {
-      log.error("Usage: cell config get <key>")
+if (command == 'help' || command == '-h' || command == '--help') {
+  print_help()
+} else if (command == 'list') {
+  log.console("# Cell Configuration")
+  log.console("")
+  print_config(config)
+} else if (command == 'get') {
+  if (length(args) < 2) {
+    log.error("Usage: cell config get <key>")
+    $stop()
+  }
+  key = args[1]
+  path = parse_key(key)
+  value = get_nested(config, path)
+
+  if (value == null) {
+    log.error("Key not found: " + key)
+  } else if (is_object(value)) {
+    print_config(value, key)
+  } else {
+    log.console(key + ' = ' + format_value(value))
+  }
+} else if (command == 'set') {
+  if (length(args) < 3) {
+    log.error("Usage: cell config set <key> <value>")
+    $stop()
+  }
+  key = args[1]
+  value_str = args[2]
+  path = parse_key(key)
+  value = parse_value(value_str)
+
+  if (path[0] == 'system') {
+    valid_system_keys = [
+      'ar_timer', 'actor_memory', 'net_service',
+      'reply_timeout', 'actor_max', 'stack_max'
+    ]
+    if (find(valid_system_keys, path[1]) == null) {
+      log.error("Invalid system key. Valid keys: " + text(valid_system_keys, ', '))
       $stop()
-      return
     }
-    var key = args[1]
-    var path = parse_key(key)
-    var value = get_nested(config, path)
-    
-    if (value == null) {
-      log.error("Key not found: " + key)
-    } else if (isa(value, object)) {
-      // Print all nested values
-      print_config(value, key)
+  }
+
+  set_nested(config, path, value)
+  pkg.save_config(config)
+  log.console("Set " + key + " = " + format_value(value))
+} else if (command == 'actor') {
+  if (length(args) < 3) {
+    log.error("Usage: cell config actor <name> <command> [options]")
+    $stop()
+  }
+
+  actor_name = args[1]
+  actor_cmd = args[2]
+
+  config.actors = config.actors || {}
+  config.actors[actor_name] = config.actors[actor_name] || {}
+
+  if (actor_cmd == 'list') {
+    if (length(array(config.actors[actor_name])) == 0) {
+      log.console("No configuration for actor: " + actor_name)
     } else {
-      log.console(key + ' = ' + format_value(value))
+      log.console("# Configuration for actor: " + actor_name)
+      log.console("")
+      print_config(config.actors[actor_name], 'actors.' + actor_name)
     }
-    break
-    
-  case 'set':
-    if (args.length < 3) {
-      log.error("Usage: cell config set <key> <value>")
+  } else if (actor_cmd == 'get') {
+    if (length(args) < 4) {
+      log.error("Usage: cell config actor <name> get <key>")
       $stop()
-      return
     }
-    var key = args[1]
-    var value_str = args[2]
-    var path = parse_key(key)
-    var value = parse_value(value_str)
-    
-    // Validate system keys
-    if (path[0] == 'system') {
-      var valid_system_keys = [
-        'ar_timer', 'actor_memory', 'net_service', 
-        'reply_timeout', 'actor_max', 'stack_max'
-      ]
-      if (!valid_system_keys.includes(path[1])) {
-        log.error("Invalid system key. Valid keys: " + valid_system_keys.join(', '))
-        $stop()
-        return
-      }
+    key = args[3]
+    path = parse_key(key)
+    value = get_nested(config.actors[actor_name], path)
+
+    if (value == null) {
+      log.error("Key not found for actor " + actor_name + ": " + key)
+    } else {
+      log.console('actors.' + actor_name + '.' + key + ' = ' + format_value(value))
     }
-    
-    set_nested(config, path, value)
+  } else if (actor_cmd == 'set') {
+    if (length(args) < 5) {
+      log.error("Usage: cell config actor <name> set <key> <value>")
+      $stop()
+    }
+    key = args[3]
+    value_str = args[4]
+    path = parse_key(key)
+    value = parse_value(value_str)
+
+    set_nested(config.actors[actor_name], path, value)
     pkg.save_config(config)
-    log.console("Set " + key + " = " + format_value(value))
-    break
-    
-  case 'actor':
-    // Handle actor-specific configuration
-    if (args.length < 3) {
-      log.error("Usage: cell config actor <name> <command> [options]")
-      $stop()
-      return
-    }
-    
-    var actor_name = args[1]
-    var actor_cmd = args[2]
-    
-    // Initialize actors section if needed
-    config.actors = config.actors || {}
-    config.actors[actor_name] = config.actors[actor_name] || {}
-    
-    switch (actor_cmd) {
-      case 'list':
-        if (array(config.actors[actor_name]).length == 0) {
-          log.console("No configuration for actor: " + actor_name)
-        } else {
-          log.console("# Configuration for actor: " + actor_name)
-          log.console("")
-          print_config(config.actors[actor_name], 'actors.' + actor_name)
-        }
-        break
-        
-      case 'get':
-        if (args.length < 4) {
-          log.error("Usage: cell config actor <name> get <key>")
-          $stop()
-          return
-        }
-        var key = args[3]
-        var path = parse_key(key)
-        var value = get_nested(config.actors[actor_name], path)
-        
-        if (value == null) {
-          log.error("Key not found for actor " + actor_name + ": " + key)
-        } else {
-          log.console('actors.' + actor_name + '.' + key + ' = ' + format_value(value))
-        }
-        break
-        
-      case 'set':
-        if (args.length < 5) {
-          log.error("Usage: cell config actor <name> set <key> <value>")
-          $stop()
-          return
-        }
-        var key = args[3]
-        var value_str = args[4]
-        var path = parse_key(key)
-        var value = parse_value(value_str)
-        
-        set_nested(config.actors[actor_name], path, value)
-        pkg.save_config(config)
-        log.console("Set actors." + actor_name + "." + key + " = " + format_value(value))
-        break
-        
-      default:
-        log.error("Unknown actor command: " + actor_cmd)
-        log.console("Valid commands: list, get, set")
-    }
-    break
-    
-  default:
-    log.error("Unknown command: " + command)
-    print_help()
+    log.console("Set actors." + actor_name + "." + key + " = " + format_value(value))
+  } else {
+    log.error("Unknown actor command: " + actor_cmd)
+    log.console("Valid commands: list, get, set")
+  }
+} else {
+  log.error("Unknown command: " + command)
+  print_help()
 }
 
-$stop()
+$stop()

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),
@@ -33,8 +21,9 @@ static const JSCFunctionListEntry js_debug_funcs[] = {
   MIST_FUNC_DEF(debug, backtrace_fns,0),
 };
 
-JSValue js_debug_use(JSContext *js) {
-  JSValue mod = JS_NewObject(js);
-  JS_SetPropertyFunctionList(js,mod,js_debug_funcs,countof(js_debug_funcs));
-  return mod;
-}
+JSValue js_core_debug_use(JSContext *js) {
+  JS_FRAME(js);
+  JS_ROOT(mod, JS_NewObject(js));
+  JS_SetPropertyFunctionList(js, mod.val, js_debug_funcs, countof(js_debug_funcs));
+  JS_RETURN(mod.val);
+}

debug/js.c

@@ -1,111 +1,29 @@
 #include "cell.h"
+#include "pit_internal.h"
 
-JSC_CCALL(os_gc, JS_RunGC(JS_GetRuntime(js)) )
 JSC_CCALL(os_mem_limit, JS_SetMemoryLimit(JS_GetRuntime(js), js2number(js,argv[0])))
-JSC_CCALL(os_gc_threshold, JS_SetGCThreshold(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));
-  JS_SetPropertyStr(js,ret,"atom_count",number2js(js,mu.atom_count));
-  JS_SetPropertyStr(js,ret,"atom_size",number2js(js,mu.atom_size));
-  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.");
-  ret = JS_Eval(js,str2,strlen(str2),str, 0);
-)
-
-// 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_Eval(js, str2, strlen(str2), str, JS_EVAL_FLAG_COMPILE_ONLY | JS_EVAL_FLAG_BACKTRACE_BARRIER);
-)
-
-// Evaluate a function object in the current QuickJS context.
-JSC_CCALL(js_eval_compile,
-  JS_DupValue(js,argv[0]);
-  ret = JS_EvalFunction(js, argv[0]);
-)
-
-// 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, gc_threshold, 1),
   MIST_FUNC_DEF(os, max_stacksize, 1),
-  MIST_FUNC_DEF(os, gc, 0),
-  MIST_FUNC_DEF(os, eval, 2),
-  MIST_FUNC_DEF(js, compile, 2),
-  MIST_FUNC_DEF(js, eval_compile, 1),
-  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),
 };
 
-JSValue js_js_use(JSContext *js) {
-  JSValue mod = JS_NewObject(js);
-  JS_SetPropertyFunctionList(js,mod,js_js_funcs,countof(js_js_funcs));
-  return mod;
-}
+JSValue js_core_js_use(JSContext *js) {
+  JS_FRAME(js);
+  JS_ROOT(mod, JS_NewObject(js));
+  JS_SetPropertyFunctionList(js, mod.val, js_js_funcs, countof(js_js_funcs));
+  JS_RETURN(mod.val);
+}

diff.ce

@@ -0,0 +1,223 @@
+// 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 testlib = use('internal/testlib')
+
+var _args = args == null ? [] : args
+
+var analyze = use('internal/os').analyze
+var run_ast_fn = use('internal/os').run_ast_fn
+var run_ast_noopt_fn = use('internal/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]
+}
+
+var is_valid_package = testlib.is_valid_package
+
+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
+      }
+      test_files[] = f
+    }
+  }
+  return test_files
+}
+
+var values_equal = testlib.values_equal
+var describe = testlib.describe
+
+// 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 stone({
+      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 {
+    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) {
+    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
+    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) {
+          results.tests[] = {name: k, status: "failed"}
+          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)) {
+          results.tests[] = {name: k, status: "failed"}
+          results.errors[] = `${k}: result mismatch opt=${describe(opt_result)} noopt=${describe(noopt_result)}`
+          results.failed = results.failed + 1
+        } else {
+          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)) {
+      results.tests[] = {name: "<return>", status: "failed"}
+      results.errors[] = `return value mismatch: opt=${describe(mod_opt)} noopt=${describe(mod_noopt)}`
+      results.failed = results.failed + 1
+    } else {
+      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()

diff_ir.ce

@@ -0,0 +1,310 @@
+// diff_ir.ce — mcode vs streamline diff
+//
+// Usage:
+//   cell diff_ir <file>                Diff all functions
+//   cell diff_ir --fn <N|name> <file>  Diff only one function
+//   cell diff_ir --summary <file>      Counts only
+
+var fd = use("fd")
+var shop = use("internal/shop")
+
+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 text(v)
+  if (is_logical(v)) return v ? "true" : "false"
+  return text(v)
+}
+
+var run = function() {
+  var fn_filter = null
+  var show_summary = false
+  var filename = null
+  var i = 0
+  var mcode_ir = null
+  var opt_ir = null
+  var source_text = null
+  var source_lines = null
+  var main_name = null
+  var fi = 0
+  var func = null
+  var opt_func = null
+  var fname = null
+
+  while (i < length(args)) {
+    if (args[i] == '--fn') {
+      i = i + 1
+      fn_filter = args[i]
+    } else if (args[i] == '--summary') {
+      show_summary = true
+    } else if (args[i] == '--help' || args[i] == '-h') {
+      log.console("Usage: cell diff_ir [--fn <N|name>] [--summary] <file>")
+      log.console("")
+      log.console("  --fn <N|name>   Filter to function by index or name")
+      log.console("  --summary       Show counts only")
+      return null
+    } else if (!starts_with(args[i], '-')) {
+      filename = args[i]
+    }
+    i = i + 1
+  }
+
+  if (!filename) {
+    log.console("Usage: cell diff_ir [--fn <N|name>] [--summary] <file>")
+    return null
+  }
+
+  mcode_ir = shop.mcode_file(filename)
+  opt_ir = shop.compile_file(filename)
+
+  source_text = text(fd.slurp(filename))
+  source_lines = array(source_text, "\n")
+
+  var get_source_line = function(line_num) {
+    if (line_num < 1 || line_num > length(source_lines)) return null
+    return source_lines[line_num - 1]
+  }
+
+  var fn_matches = function(index, name) {
+    var match = null
+    if (fn_filter == null) return true
+    if (index >= 0 && fn_filter == text(index)) return true
+    if (name != null) {
+      match = search(name, fn_filter)
+      if (match != null && match >= 0) return true
+    }
+    return false
+  }
+
+  var fmt_instr = function(instr) {
+    var op = instr[0]
+    var n = length(instr)
+    var parts = []
+    var j = 1
+    var operands = null
+    var line_str = null
+    while (j < n - 2) {
+      parts[] = fmt_val(instr[j])
+      j = j + 1
+    }
+    operands = text(parts, ", ")
+    line_str = instr[n - 2] != null ? `:${text(instr[n - 2])}` : ""
+    return pad_right(`${pad_right(op, 15)}${operands}`, 45) + line_str
+  }
+
+  var classify = function(before, after) {
+    var bn = 0
+    var an = 0
+    var k = 0
+    if (is_text(after) && starts_with(after, "_nop_")) return "eliminated"
+    if (is_array(before) && is_array(after)) {
+      if (before[0] != after[0]) return "rewritten"
+      bn = length(before)
+      an = length(after)
+      if (bn != an) return "rewritten"
+      k = 1
+      while (k < bn - 2) {
+        if (before[k] != after[k]) return "rewritten"
+        k = k + 1
+      }
+      return "identical"
+    }
+    return "identical"
+  }
+
+  var total_eliminated = 0
+  var total_rewritten = 0
+  var total_funcs = 0
+
+  var diff_function = function(mcode_func, opt_func, name, index) {
+    var nr_args = mcode_func.nr_args != null ? mcode_func.nr_args : 0
+    var nr_slots = mcode_func.nr_slots != null ? mcode_func.nr_slots : 0
+    var m_instrs = mcode_func.instructions
+    var o_instrs = opt_func.instructions
+    var eliminated = 0
+    var rewritten = 0
+    var mi = 0
+    var oi = 0
+    var pc = 0
+    var m_instr = null
+    var o_instr = null
+    var kind = null
+    var last_line = null
+    var instr_line = null
+    var n = 0
+    var src = null
+    var annotation = null
+
+    if (m_instrs == null) m_instrs = []
+    if (o_instrs == null) o_instrs = []
+
+    // First pass: count changes
+    mi = 0
+    oi = 0
+    while (mi < length(m_instrs) && oi < length(o_instrs)) {
+      m_instr = m_instrs[mi]
+      o_instr = o_instrs[oi]
+
+      if (is_text(m_instr)) {
+        mi = mi + 1
+        oi = oi + 1
+        continue
+      }
+
+      if (is_text(o_instr) && starts_with(o_instr, "_nop_")) {
+        if (is_array(m_instr)) {
+          eliminated = eliminated + 1
+        }
+        mi = mi + 1
+        oi = oi + 1
+        continue
+      }
+
+      if (is_array(m_instr) && is_array(o_instr)) {
+        kind = classify(m_instr, o_instr)
+        if (kind == "rewritten") {
+          rewritten = rewritten + 1
+        }
+      }
+      mi = mi + 1
+      oi = oi + 1
+    }
+
+    total_eliminated = total_eliminated + eliminated
+    total_rewritten = total_rewritten + rewritten
+    total_funcs = total_funcs + 1
+
+    if (show_summary) {
+      if (eliminated == 0 && rewritten == 0) {
+        log.compile(`  ${pad_right(name + ":", 40)} 0 eliminated, 0 rewritten (unchanged)`)
+      } else {
+        log.compile(`  ${pad_right(name + ":", 40)} ${text(eliminated)} eliminated, ${text(rewritten)} rewritten`)
+      }
+      return null
+    }
+
+    if (eliminated == 0 && rewritten == 0) return null
+
+    log.compile(`\n=== ${name} (args=${text(nr_args)}, slots=${text(nr_slots)}) ===`)
+    log.compile(`  ${text(eliminated)} eliminated, ${text(rewritten)} rewritten`)
+
+    // Second pass: show diffs
+    mi = 0
+    oi = 0
+    pc = 0
+    last_line = null
+    while (mi < length(m_instrs) && oi < length(o_instrs)) {
+      m_instr = m_instrs[mi]
+      o_instr = o_instrs[oi]
+
+      if (is_text(m_instr) && !starts_with(m_instr, "_nop_")) {
+        mi = mi + 1
+        oi = oi + 1
+        continue
+      }
+
+      if (is_text(m_instr) && starts_with(m_instr, "_nop_")) {
+        mi = mi + 1
+        oi = oi + 1
+        continue
+      }
+
+      if (is_text(o_instr) && starts_with(o_instr, "_nop_")) {
+        if (is_array(m_instr)) {
+          n = length(m_instr)
+          instr_line = m_instr[n - 2]
+          if (instr_line != last_line && instr_line != null) {
+            src = get_source_line(instr_line)
+            if (src != null) src = trim(src)
+            if (last_line != null) log.compile("")
+            if (src != null && length(src) > 0) {
+              log.compile(`  --- line ${text(instr_line)}: ${src} ---`)
+            }
+            last_line = instr_line
+          }
+          log.compile(`  - ${pad_right(text(pc), 6)}${fmt_instr(m_instr)}`)
+          log.compile(`  + ${pad_right(text(pc), 6)}${pad_right(o_instr, 45)}      (eliminated)`)
+        }
+        mi = mi + 1
+        oi = oi + 1
+        pc = pc + 1
+        continue
+      }
+
+      if (is_array(m_instr) && is_array(o_instr)) {
+        kind = classify(m_instr, o_instr)
+        if (kind != "identical") {
+          n = length(m_instr)
+          instr_line = m_instr[n - 2]
+          if (instr_line != last_line && instr_line != null) {
+            src = get_source_line(instr_line)
+            if (src != null) src = trim(src)
+            if (last_line != null) log.compile("")
+            if (src != null && length(src) > 0) {
+              log.compile(`  --- line ${text(instr_line)}: ${src} ---`)
+            }
+            last_line = instr_line
+          }
+
+          annotation = ""
+          if (kind == "rewritten") {
+            if (o_instr[0] == "concat" && m_instr[0] != "concat") {
+              annotation = "(specialized)"
+            } else {
+              annotation = "(rewritten)"
+            }
+          }
+
+          log.compile(`  - ${pad_right(text(pc), 6)}${fmt_instr(m_instr)}`)
+          log.compile(`  + ${pad_right(text(pc), 6)}${fmt_instr(o_instr)}  ${annotation}`)
+        }
+        pc = pc + 1
+      }
+
+      mi = mi + 1
+      oi = oi + 1
+    }
+
+    return null
+  }
+
+  // Process functions
+  main_name = mcode_ir.name != null ? mcode_ir.name : "<main>"
+
+  if (mcode_ir.main != null && opt_ir.main != null) {
+    if (fn_matches(-1, main_name)) {
+      diff_function(mcode_ir.main, opt_ir.main, main_name, -1)
+    }
+  }
+
+  if (mcode_ir.functions != null && opt_ir.functions != null) {
+    fi = 0
+    while (fi < length(mcode_ir.functions) && fi < length(opt_ir.functions)) {
+      func = mcode_ir.functions[fi]
+      opt_func = opt_ir.functions[fi]
+      fname = func.name != null ? func.name : "<anonymous>"
+      if (fn_matches(fi, fname)) {
+        diff_function(func, opt_func, `[${text(fi)}] ${fname}`, fi)
+      }
+      fi = fi + 1
+    }
+  }
+
+  if (show_summary) {
+    log.compile(`\n  total: ${text(total_eliminated)} eliminated, ${text(total_rewritten)} rewritten across ${text(total_funcs)} functions`)
+  }
+
+  return null
+}
+
+run()
+$stop()

disasm.ce

@@ -0,0 +1,265 @@
+// disasm.ce — source-interleaved disassembly
+//
+// Usage:
+//   cell disasm <file>                  Disassemble all functions (mcode)
+//   cell disasm --optimized <file>      Disassemble optimized IR (streamline)
+//   cell disasm --fn <N|name> <file>    Show only function N or named function
+//   cell disasm --line <N> <file>       Show instructions from source line N
+
+var fd = use("fd")
+var shop = use("internal/shop")
+
+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 text(v)
+  if (is_logical(v)) return v ? "true" : "false"
+  return text(v)
+}
+
+var run = function() {
+  var use_optimized = false
+  var fn_filter = null
+  var line_filter = null
+  var filename = null
+  var i = 0
+  var compiled = null
+  var source_text = null
+  var source_lines = null
+  var main_name = null
+  var fi = 0
+  var func = null
+  var fname = null
+
+  while (i < length(args)) {
+    if (args[i] == '--optimized') {
+      use_optimized = true
+    } else if (args[i] == '--fn') {
+      i = i + 1
+      fn_filter = args[i]
+    } else if (args[i] == '--line') {
+      i = i + 1
+      line_filter = number(args[i])
+    } else if (args[i] == '--help' || args[i] == '-h') {
+      log.console("Usage: cell disasm [--optimized] [--fn <N|name>] [--line <N>] <file>")
+      log.console("")
+      log.console("  --optimized     Use optimized IR (streamline) instead of raw mcode")
+      log.console("  --fn <N|name>   Filter to function by index or name")
+      log.console("  --line <N>      Show only instructions from source line N")
+      return null
+    } else if (!starts_with(args[i], '-')) {
+      filename = args[i]
+    }
+    i = i + 1
+  }
+
+  if (!filename) {
+    log.console("Usage: cell disasm [--optimized] [--fn <N|name>] [--line <N>] <file>")
+    return null
+  }
+
+  // Compile
+
+  if (use_optimized) {
+    compiled = shop.compile_file(filename)
+  } else {
+    compiled = shop.mcode_file(filename)
+  }
+
+  // Read source file
+
+  source_text = text(fd.slurp(filename))
+  source_lines = array(source_text, "\n")
+
+  // Helpers
+
+  var get_source_line = function(line_num) {
+    if (line_num < 1 || line_num > length(source_lines)) return null
+    return source_lines[line_num - 1]
+  }
+
+  var first_instr_line = function(func) {
+    var instrs = func.instructions
+    var i = 0
+    var n = 0
+    if (instrs == null) return null
+    while (i < length(instrs)) {
+      if (is_array(instrs[i])) {
+        n = length(instrs[i])
+        return instrs[i][n - 2]
+      }
+      i = i + 1
+    }
+    return null
+  }
+
+  var func_has_line = function(func, target) {
+    var instrs = func.instructions
+    var i = 0
+    var n = 0
+    if (instrs == null) return false
+    while (i < length(instrs)) {
+      if (is_array(instrs[i])) {
+        n = length(instrs[i])
+        if (instrs[i][n - 2] == target) return true
+      }
+      i = i + 1
+    }
+    return false
+  }
+
+  var fn_matches = function(index, name) {
+    var match = null
+    if (fn_filter == null) return true
+    if (index >= 0 && fn_filter == text(index)) return true
+    if (name != null) {
+      match = search(name, fn_filter)
+      if (match != null && match >= 0) return true
+    }
+    return false
+  }
+
+  var func_name_by_index = function(fi) {
+    var f = null
+    if (compiled.functions == null) return null
+    if (fi < 0 || fi >= length(compiled.functions)) return null
+    f = compiled.functions[fi]
+    return f.name
+  }
+
+  var dump_function = function(func, name, index) {
+    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 start_line = first_instr_line(func)
+    var header = null
+    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 instr_line = null
+    var last_line = null
+    var src = null
+    var line_str = null
+    var instr_text = null
+    var target_name = null
+
+    header = `\n=== ${name} (args=${text(nr_args)}, slots=${text(nr_slots)}, closures=${text(nr_close)})`
+    if (start_line != null) {
+      header = header + ` [line ${text(start_line)}]`
+    }
+    header = header + " ==="
+    log.compile(header)
+
+    if (instrs == null || length(instrs) == 0) {
+      log.compile("  (empty)")
+      return null
+    }
+
+    while (i < length(instrs)) {
+      instr = instrs[i]
+      if (is_text(instr)) {
+        if (!starts_with(instr, "_nop_") && line_filter == null) {
+          log.compile(`      ${instr}:`)
+        }
+      } else if (is_array(instr)) {
+        op = instr[0]
+        n = length(instr)
+        instr_line = instr[n - 2]
+
+        if (line_filter != null && instr_line != line_filter) {
+          pc = pc + 1
+          i = i + 1
+          continue
+        }
+
+        if (instr_line != last_line && instr_line != null) {
+          src = get_source_line(instr_line)
+          if (src != null) {
+            src = trim(src)
+          }
+          if (last_line != null) {
+            log.compile("")
+          }
+          if (src != null && length(src) > 0) {
+            log.compile(`  --- line ${text(instr_line)}: ${src} ---`)
+          } else {
+            log.compile(`  --- line ${text(instr_line)} ---`)
+          }
+          last_line = instr_line
+        }
+
+        parts = []
+        j = 1
+        while (j < n - 2) {
+          parts[] = fmt_val(instr[j])
+          j = j + 1
+        }
+        operands = text(parts, ", ")
+        line_str = instr_line != null ? `:${text(instr_line)}` : ""
+        instr_text = `  ${pad_right(text(pc), 6)}${pad_right(op, 15)}${operands}`
+
+        // Cross-reference for function creation instructions
+        target_name = null
+        if (op == "function" && n >= 5) {
+          target_name = func_name_by_index(instr[2])
+        }
+        if (target_name != null) {
+          instr_text = pad_right(instr_text, 65) + line_str + `  ; -> [${text(instr[2])}] ${target_name}`
+        } else {
+          instr_text = pad_right(instr_text, 65) + line_str
+        }
+
+        log.compile(instr_text)
+        pc = pc + 1
+      }
+      i = i + 1
+    }
+    return null
+  }
+
+  // Process functions
+
+  main_name = compiled.name != null ? compiled.name : "<main>"
+
+  if (compiled.main != null) {
+    if (fn_matches(-1, main_name)) {
+      if (line_filter == null || func_has_line(compiled.main, line_filter)) {
+        dump_function(compiled.main, main_name, -1)
+      }
+    }
+  }
+
+  if (compiled.functions != null) {
+    fi = 0
+    while (fi < length(compiled.functions)) {
+      func = compiled.functions[fi]
+      fname = func.name != null ? func.name : "<anonymous>"
+      if (fn_matches(fi, fname)) {
+        if (line_filter == null || func_has_line(func, line_filter)) {
+          dump_function(func, `[${text(fi)}] ${fname}`, fi)
+        }
+      }
+      fi = fi + 1
+    }
+  }
+
+  return null
+}
+
+run()
+$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,94 @@
+---
+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
+- [**Shop Architecture**](/docs/shop/) — module resolution, compilation, and caching
+
+## 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
+- [**Semantic Index**](/docs/semantic-index/) — index and query symbols, references, and call sites
+- [**Testing**](/docs/testing/) — writing and running tests
+- [**Compiler Inspection**](/docs/compiler-tools/) — dump AST, mcode, and optimizer reports
+- [**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 `~/.cell/`.
+
+## 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)
-  // Process message...
-}
+$receiver(function(msg) {
+  print("Received:", msg)
+  send(msg, {status: "ok"})
+})
 ```
 
 **Key properties:**
@@ -78,110 +83,230 @@ $on_message = function(msg) {
 
 Actors have access to special functions prefixed with `$`:
 
-### $me
+### $self
 
-Reference to the current actor.
+Reference to the current actor. This is a stone (immutable) actor object.
 
 ```javascript
-log.console($me)  // actor reference
+print($self)            // actor reference
+print(is_actor($self))  // true
+```
+
+### $overling
+
+Reference to the parent actor that started this actor. `null` for the root actor. Child actors are automatically coupled to their overling — if the parent dies, the child dies too.
+
+```javascript
+if ($overling != null) {
+  send($overling, {status: "ready"})
+}
 ```
 
 ### $stop()
 
-Stop the current actor.
+Stop the current actor. When called with an actor argument, stops that underling (child) instead.
 
 ```javascript
-$stop()
+$stop()          // stop self
+$stop(child)     // stop a child actor
 ```
 
-### $send(actor, message, callback)
-
-Send a message to another actor.
+**Important:** `$stop()` does not halt execution immediately. Code after the call continues running in the current turn — it only prevents the actor from receiving future messages. Structure your code so that nothing runs after `$stop()`, or use `return` to exit the current function first.
 
 ```javascript
-$send(other_actor, {type: "ping", data: 42}, function(reply) {
-  log.console("Got reply:", reply)
-})
-```
+// Wrong — code after $stop() still runs
+if (done) $stop()
+do_more_work()  // this still executes!
 
-Messages are automatically **splatted** — flattened to plain data without prototypes.
+// Right — return after $stop()
+if (done) { $stop(); return }
+do_more_work()
+```
 
 ### $start(callback, program)
 
-Start a new actor from a script.
+Start a new child actor from a script. The callback receives lifecycle events:
+
+- `{type: "greet", actor: <ref>}` — child started successfully
+- `{type: "stop"}` — child stopped cleanly
+- `{type: "disrupt", reason: ...}` — child crashed
 
 ```javascript
-$start(function(new_actor) {
-  log.console("Started:", new_actor)
+$start(function(event) {
+  if (event.type == 'greet') {
+    print("Child started:", event.actor)
+    send(event.actor, {task: "work"})
+  }
+  if (event.type == 'stop') {
+    print("Child stopped")
+  }
+  if (event.type == 'disrupt') {
+    print("Child crashed:", event.reason)
+  }
 }, "worker")
 ```
 
 ### $delay(callback, seconds)
 
-Schedule a callback after a delay.
+Schedule a callback after a delay. Returns a cancel function that can be called to prevent the callback from firing.
 
 ```javascript
-$delay(function() {
-  log.console("5 seconds later")
+var cancel = $delay(function() {
+  print("5 seconds later")
 }, 5)
+
+// To cancel before it fires:
+cancel()
 ```
 
 ### $clock(callback)
 
-Get called every frame/tick.
+Get called every frame/tick. The callback receives the current time as a number.
 
 ```javascript
-$clock(function(dt) {
-  // Called each tick with delta time
+$clock(function(t) {
+  // called each tick with current time
 })
 ```
 
 ### $receiver(callback)
 
-Set up a message receiver.
+Set up a message receiver. The callback is called with the incoming message whenever another actor sends a message to this actor.
+
+To reply to a message, call `send(message, reply_data)` — the message object contains routing information that directs the reply back to the sender.
 
 ```javascript
-$receiver(function(message, reply) {
-  // Handle incoming message
-  reply({status: "ok"})
+$receiver(function(message) {
+  // handle incoming message
+  send(message, {status: "ok"})
 })
 ```
 
 ### $portal(callback, port)
 
-Open a network port.
+Open a network port to receive connections from remote actors.
 
 ```javascript
 $portal(function(connection) {
-  // Handle new connection
+  // handle new connection
 }, 8080)
 ```
 
 ### $contact(callback, record)
 
-Connect to a remote address.
+Connect to a remote actor at a given address.
 
 ```javascript
 $contact(function(connection) {
-  // Connected
+  // connected
 }, {host: "example.com", port: 80})
 ```
 
 ### $time_limit(requestor, seconds)
 
-Wrap a requestor with a timeout.
+Wrap a requestor with a timeout. Returns a new requestor that will cancel the original and call its callback with a failure if the time limit is exceeded. See [Requestors](/docs/requestors/) for details.
 
 ```javascript
-$time_limit(my_requestor, 10)  // 10 second timeout
+var timed = $time_limit(my_requestor, 10)
+
+timed(function(result, reason) {
+  // reason will explain timeout if it fires
+}, initial_value)
 ```
 
+### $couple(actor)
+
+Couple the current actor to another actor. When the coupled actor dies, the current actor also dies. Coupling is automatic between a child actor and its overling (parent).
+
+```javascript
+$couple(other_actor)
+```
+
+### $unneeded(callback, seconds)
+
+Schedule the actor for removal after a specified time. The callback fires when the time elapses.
+
+```javascript
+$unneeded(function() {
+  // cleanup before removal
+}, 30)
+```
+
+### $connection(callback, actor, config)
+
+Get information about the connection to another actor. For local actors, returns `{type: "local"}`. For remote actors, returns connection details including latency, bandwidth, and activity.
+
+```javascript
+$connection(function(info) {
+  if (info.type == "local") {
+    print("same machine")
+  } else {
+    print(info.latency)
+  }
+}, other_actor, {})
+```
+
+## Runtime Functions
+
+These functions are available in actors without the `$` prefix:
+
+### send(actor, message, callback)
+
+Send a message to another actor. The message must be an object record.
+
+The optional callback receives the reply when the recipient responds.
+
+```javascript
+send(other_actor, {type: "ping"}, function(reply) {
+  print("Got reply:", reply)
+})
+```
+
+To reply to a received message, pass the message itself as the first argument — it contains routing information:
+
+```javascript
+$receiver(function(message) {
+  send(message, {result: 42})
+})
+```
+
+Messages are automatically flattened to plain data.
+
+### is_actor(value)
+
+Returns `true` if the value is an actor reference.
+
+```javascript
+if (is_actor(some_value)) {
+  send(some_value, {ping: true})
+}
+```
+
+### log
+
+Channel-based logging. Any `log.X(value)` writes to channel `"X"`. Three channels are conventional: `log.console(msg)`, `log.error(msg)`, `log.system(msg)` — but any name works.
+
+Channels are routed to configurable **sinks** (console or file) defined in `.cell/log.toml`. See [Logging](/docs/logging/) for the full guide.
+
+### use(path)
+
+Import a module. See [Module Resolution](#module-resolution) below.
+
+### args
+
+Array of command-line arguments passed to the actor.
+
+### sequence(), parallel(), race(), fallback()
+
+Requestor composition functions. See [Requestors](/docs/requestors/) for details.
+
 ## 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
+3. **Core** — built-in ƿit modules
 
 ```javascript
 // From within package 'myapp':
@@ -191,7 +316,7 @@ use('json')            // core json module
 use('otherlib/foo')    // dependency 'otherlib', file foo.cm
 ```
 
-Files starting with underscore (`_helper.cm`) are private to the package.
+Files in the `internal/` directory are private to the package.
 
 ## Example: Simple Actor System
 
@@ -199,25 +324,32 @@ 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]})
+$start(function(event) {
+  if (event.type == 'greet') {
+    send(event.actor, {task: "process", data: [1, 2, 3]})
+  }
+  if (event.type == 'stop') {
+    print("Worker finished")
+    $stop()
+  }
 }, "worker")
 
 $delay(function() {
-  log.console("Shutting down")
+  print("Shutting down")
   $stop()
 }, 10)
 ```
 
 ```javascript
 // worker.ce - Worker actor
-$receiver(function(msg, reply) {
+$receiver(function(msg) {
   if (msg.task == "process") {
-    var result = array(msg.data, x => x * 2)
-    reply({result: result})
+    var result = array(msg.data, function(x) { return x * 2 })
+    send(msg, {result: result})
   }
+  $stop()
 })
 ```
 

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,20 @@ 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`
+- `mypackage/internal/helpers.c` -> `js_mypackage_internal_helpers_use`
+- `mypackage/game.ce` (AOT actor) -> `js_mypackage_game_program`
+
+Actor files (`.ce`) use the `_program` suffix instead of `_use`.
+
+Internal modules (in `internal/` subdirectories) follow the same convention — the `internal` directory name becomes part of the symbol. For example, `internal/os.c` in the core package has the symbol `js_core_internal_os_use`.
+
+**Note:** Having both a `.cm` and `.c` file with the same stem at the same scope is a build error.
 
 ## Required Headers
 
-Include `cell.h` for all Cell integration:
+Include `cell.h` for all ƿit integration:
 
 ```c
 #include "cell.h"
@@ -63,7 +76,7 @@ This provides:
 
 ## Conversion Functions
 
-### JavaScript ↔ C
+### JavaScript <-> C
 
 ```c
 // Numbers
@@ -177,10 +190,12 @@ JSC_CCALL(vector_normalize,
   double y = js2number(js, argv[1]);
   double len = sqrt(x*x + y*y);
   if (len > 0) {
-    JSValue result = JS_NewObject(js);
-    JS_SetPropertyStr(js, result, "x", number2js(js, x/len));
-    JS_SetPropertyStr(js, result, "y", number2js(js, y/len));
-    ret = result;
+    JS_FRAME(js);
+    JS_ROOT(result, JS_NewObject(js));
+    JS_SetPropertyStr(js, result.val, "x", number2js(js, x/len));
+    JS_SetPropertyStr(js, result.val, "y", number2js(js, y/len));
+    JS_RestoreFrame(_js_ctx, _js_gc_frame, _js_local_frame);
+    ret = result.val;
   }
 )
 
@@ -201,7 +216,7 @@ static const JSCFunctionListEntry js_funcs[] = {
 CELL_USE_FUNCS(js_funcs)
 ```
 
-Usage in Cell:
+Usage in ƿit:
 
 ```javascript
 var vector = use('vector')
@@ -211,44 +226,116 @@ 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
-
-A common pattern is to have a C file provide low-level functions and a `.cm` file provide a higher-level API:
-
-```c
-// _vector_native.c
-// ... raw C functions ...
-```
-
-```javascript
-// vector.cm
-var native = this  // C module passed as 'this'
-
-function Vector(x, y) {
-  return {x: x, y: y}
-}
-
-Vector.length = function(v) {
-  return native.length(v.x, v.y)
-}
-
-Vector.normalize = function(v) {
-  return native.normalize(v.x, v.y)
-}
-
-return Vector
-```
-
 ## Build Process
 
 C files are automatically compiled when you run:
 
 ```bash
-cell build
-cell update
+cell --dev build
 ```
 
-The resulting dynamic library is placed in `~/.cell/lib/`.
+Each C file is compiled into a per-file dynamic library at a content-addressed path in `~/.cell/build/<hash>`. A manifest is written for each package so the runtime can find dylibs without rerunning the build pipeline — see [Dylib Manifests](/docs/shop/#dylib-manifests).
+
+## Compilation Flags (cell.toml)
+
+Use the `[compilation]` section in `cell.toml` to pass compiler and linker flags:
+
+```toml
+[compilation]
+CFLAGS = "-Isrc -Ivendor/include"
+LDFLAGS = "-lz -lm"
+```
+
+### Include paths
+
+Relative `-I` paths are resolved from the package root:
+
+```toml
+CFLAGS = "-Isdk/public"
+```
+
+If your package is at `/path/to/mypkg`, this becomes `-I/path/to/mypkg/sdk/public`.
+
+Absolute paths are passed through unchanged.
+
+The build system also auto-discovers `include/` directories — if your package has an `include/` directory, it is automatically added to the include path. No need to add `-I$PACKAGE/include` in cell.toml.
+
+### Library paths
+
+Relative `-L` paths work the same way:
+
+```toml
+LDFLAGS = "-Lsdk/lib -lmylib"
+```
+
+### Target-specific flags
+
+Add sections named `[compilation.<target>]` for platform-specific flags:
+
+```toml
+[compilation]
+CFLAGS = "-Isdk/public"
+
+[compilation.macos_arm64]
+LDFLAGS = "-Lsdk/lib/osx -lmylib"
+
+[compilation.linux]
+LDFLAGS = "-Lsdk/lib/linux64 -lmylib"
+
+[compilation.windows]
+LDFLAGS = "-Lsdk/lib/win64 -lmylib64"
+```
+
+Available targets: `macos_arm64`, `macos_x86_64`, `linux`, `linux_arm64`, `windows`.
+
+### Sigils
+
+Use sigils in flags to refer to standard directories:
+
+- `$LOCAL` — absolute path to `.cell/local` (for prebuilt libraries)
+- `$PACKAGE` — absolute path to the package root
+
+```toml
+CFLAGS = "-I$PACKAGE/vendor/include"
+LDFLAGS = "-L$LOCAL -lmyprebuilt"
+```
+
+### Example: vendored SDK
+
+A package wrapping an external SDK with platform-specific shared libraries:
+
+```
+mypkg/
+├── cell.toml
+├── wrapper.cpp
+└── sdk/
+    ├── public/
+    │   └── mylib/
+    │       └── api.h
+    └── lib/
+        ├── osx/
+        │   └── libmylib.dylib
+        └── linux64/
+            └── libmylib.so
+```
+
+```toml
+[compilation]
+CFLAGS = "-Isdk/public"
+
+[compilation.macos_arm64]
+LDFLAGS = "-Lsdk/lib/osx -lmylib"
+
+[compilation.linux]
+LDFLAGS = "-Lsdk/lib/linux64 -lmylib"
+```
+
+```cpp
+// wrapper.cpp
+#include "cell.h"
+#include <mylib/api.h>
+// ...
+```
 
 ## Platform-Specific Code
 
@@ -260,7 +347,199 @@ 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.
+
+## Multi-File C Modules
+
+If your module wraps a C library, place the library's source files in a `src/` directory. Files in `src/` are compiled as support objects and linked into your module's dylib — they are not treated as standalone modules.
+
+```
+mypackage/
+  rtree.c       # module (exports js_mypackage_rtree_use)
+  src/
+    rtree.c      # support file (linked into rtree.dylib)
+    rtree.h      # header
+```
+
+The module file (`rtree.c`) includes the library header and uses `cell.h` as usual. The support files are plain C — they don't need any cell macros.
+
+## GC Safety
+
+ƿit uses a **Cheney copying garbage collector**. Any JS allocation — `JS_NewObject`, `JS_NewString`, `JS_NewInt32`, `JS_SetPropertyStr`, `js_new_blob_stoned_copy`, etc. — can trigger GC, which **moves** heap objects to new addresses. Bare C locals holding `JSValue` become **dangling pointers** after any allocating call. This is not a theoretical concern — it causes real crashes that are difficult to reproduce because they depend on heap pressure.
+
+### Checklist (apply to EVERY C function you write or modify)
+
+1. Count the `JS_New*`, `JS_SetProperty*`, and `js_new_blob*` calls in the function
+2. If there are **2 or more**, the function **MUST** use `JS_FRAME` / `JS_ROOT` / `JS_RETURN`
+3. Every `JSValue` held in a C local across an allocating call must be rooted
+
+### When you need rooting
+
+If a function creates **one** heap object and returns it immediately, no rooting is needed:
+
+```c
+JSC_CCALL(mymod_name,
+  ret = JS_NewString(js, "hello");
+)
+```
+
+If a function creates an object and then sets properties on it, you **must** root it — each `JS_SetPropertyStr` call is an allocating call that can trigger GC:
+
+```c
+// UNSAFE — will crash under GC pressure:
+JSValue obj = JS_NewObject(js);
+JS_SetPropertyStr(js, obj, "x", JS_NewInt32(js, 1));  // can GC → obj is stale
+JS_SetPropertyStr(js, obj, "y", JS_NewInt32(js, 2));  // obj may be garbage
+return obj;
+
+// SAFE:
+JS_FRAME(js);
+JS_ROOT(obj, JS_NewObject(js));
+JS_SetPropertyStr(js, obj.val, "x", JS_NewInt32(js, 1));
+JS_SetPropertyStr(js, obj.val, "y", JS_NewInt32(js, 2));
+JS_RETURN(obj.val);
+```
+
+### Patterns
+
+**Object with properties** — the most common pattern in this codebase:
+
+```c
+JS_FRAME(js);
+JS_ROOT(result, JS_NewObject(js));
+JS_SetPropertyStr(js, result.val, "width", JS_NewInt32(js, w));
+JS_SetPropertyStr(js, result.val, "height", JS_NewInt32(js, h));
+JS_SetPropertyStr(js, result.val, "pixels", js_new_blob_stoned_copy(js, data, len));
+JS_RETURN(result.val);
+```
+
+**Array with loop** — root the element variable *before* the loop, then reassign `.val` each iteration:
+
+```c
+JS_FRAME(js);
+JS_ROOT(arr, JS_NewArray(js));
+JS_ROOT(item, JS_NULL);
+for (int i = 0; i < count; i++) {
+  item.val = JS_NewObject(js);
+  JS_SetPropertyStr(js, item.val, "index", JS_NewInt32(js, i));
+  JS_SetPropertyStr(js, item.val, "data", js_new_blob_stoned_copy(js, ptr, sz));
+  JS_SetPropertyNumber(js, arr.val, i, item.val);
+}
+JS_RETURN(arr.val);
+```
+
+**WARNING — NEVER put `JS_ROOT` inside a loop.** `JS_ROOT` declares a `JSGCRef` local and calls `JS_PushGCRef(&name)`, which pushes its address onto a linked list. Inside a loop the compiler reuses the same stack address, so on iteration 2+ the list becomes self-referential (`ref->prev == ref`). When GC triggers it walks the chain and **hangs forever**. This bug is intermittent — it only manifests when GC happens to run during the loop — making it very hard to reproduce.
+
+**Nested objects** — root every object that persists across an allocating call:
+
+```c
+JS_FRAME(js);
+JS_ROOT(outer, JS_NewObject(js));
+JS_ROOT(inner, JS_NewArray(js));
+// ... populate inner ...
+JS_SetPropertyStr(js, outer.val, "items", inner.val);
+JS_RETURN(outer.val);
+```
+
+**Inside `JSC_CCALL`** — use `JS_RestoreFrame` and assign to `ret`:
+
+```c
+JSC_CCALL(mymod_make,
+  JS_FRAME(js);
+  JS_ROOT(obj, JS_NewObject(js));
+  JS_SetPropertyStr(js, obj.val, "x", number2js(js, 42));
+  JS_RestoreFrame(_js_ctx, _js_gc_frame, _js_local_frame);
+  ret = obj.val;
+)
+```
+
+### C Argument Evaluation Order (critical)
+
+In C, the **order of evaluation of function arguments is unspecified**. This interacts with the copying GC to create intermittent crashes that are extremely difficult to diagnose.
+
+```c
+// UNSAFE — crashes intermittently:
+JS_FRAME(js);
+JS_ROOT(obj, JS_NewObject(js));
+JS_SetPropertyStr(js, obj.val, "format", JS_NewString(js, "rgba32"));
+//                     ^^^^^^^ may be evaluated BEFORE JS_NewString runs
+// If JS_NewString triggers GC, the already-read obj.val is a dangling pointer.
+```
+
+The compiler is free to evaluate `obj.val` into a register, *then* call `JS_NewString`. If `JS_NewString` triggers GC, the object moves to a new address. The rooted `obj` is updated by GC, but the **register copy** is not — it still holds the old address. `JS_SetPropertyStr` then writes to freed memory.
+
+**Fix:** always separate the allocating call into a local variable:
+
+```c
+// SAFE:
+JS_FRAME(js);
+JS_ROOT(obj, JS_NewObject(js));
+JSValue fmt = JS_NewString(js, "rgba32");
+JS_SetPropertyStr(js, obj.val, "format", fmt);
+// obj.val is read AFTER JS_NewString completes — guaranteed correct.
+```
+
+This applies to **any** allocating function used as an argument when another argument references a rooted `.val`:
+
+```c
+// ALL of these are UNSAFE:
+JS_SetPropertyStr(js, obj.val, "pixels", js_new_blob_stoned_copy(js, data, len));
+JS_SetPropertyStr(js, obj.val, "x", JS_NewFloat64(js, 3.14));
+JS_SetPropertyStr(js, obj.val, "name", JS_NewString(js, name));
+
+// SAFE versions — separate the allocation:
+JSValue pixels = js_new_blob_stoned_copy(js, data, len);
+JS_SetPropertyStr(js, obj.val, "pixels", pixels);
+JSValue x = JS_NewFloat64(js, 3.14);
+JS_SetPropertyStr(js, obj.val, "x", x);
+JSValue s = JS_NewString(js, name);
+JS_SetPropertyStr(js, obj.val, "name", s);
+```
+
+**Functions that allocate** (must be separated): `JS_NewString`, `JS_NewFloat64`, `JS_NewInt64`, `JS_NewObject`, `JS_NewArray`, `JS_NewCFunction`, `js_new_blob_stoned_copy`
+
+**Functions that do NOT allocate** (safe inline): `JS_NewInt32`, `JS_NewUint32`, `JS_NewBool`, `JS_NULL`, `JS_TRUE`, `JS_FALSE`
+
+### Macros
+
+| Macro | Purpose |
+|-------|---------|
+| `JS_FRAME(js)` | Save the GC frame. Required before any `JS_ROOT`. |
+| `JS_ROOT(name, init)` | Declare a `JSGCRef` and root its value. Access via `name.val`. |
+| `JS_LOCAL(name, init)` | Declare a rooted `JSValue` (GC updates it through its address). |
+| `JS_RETURN(val)` | Restore the frame and return a value. |
+| `JS_RETURN_NULL()` | Restore the frame and return `JS_NULL`. |
+| `JS_RETURN_EX()` | Restore the frame and return `JS_EXCEPTION`. |
+| `JS_RestoreFrame(...)` | Manual frame restore (for `JSC_CCALL` bodies that use `ret =`). |
+
+### Error return rules
+
+- Error returns **before** `JS_FRAME` can use plain `return JS_ThrowTypeError(...)` etc.
+- Error returns **after** `JS_FRAME` must use `JS_RETURN_EX()` or `JS_RETURN_NULL()` — never plain `return`, which would leak the GC frame.
+
+### Migrating from gc_mark
+
+The old mark-and-sweep GC had a `gc_mark` callback in `JSClassDef` for C structs that held JSValue fields. This no longer exists. The copying GC needs to know the **address** of every pointer to update it when objects move.
+
+If your C struct holds a JSValue that must survive across GC points, root it for the duration it's alive:
+
+```c
+typedef struct {
+  JSValue callback;
+  JSLocalRef callback_lr;
+} MyWidget;
+
+// When storing:
+widget->callback = value;
+widget->callback_lr.ptr = &widget->callback;
+JS_PushLocalRef(js, &widget->callback_lr);
+
+// When done (before freeing the struct):
+// The local ref is cleaned up when the frame is restored,
+// or manage it manually.
+```
+
+In practice, most C wrappers hold only opaque C pointers (like `SDL_Window*`) and never store JSValues in the struct — these need no migration.
 
 ## Static Declarations
 
@@ -275,3 +554,32 @@ static int module_state = 0;
 ```
 
 This prevents symbol conflicts between packages.
+
+## Troubleshooting
+
+### Missing header / SDK not installed
+
+If a package wraps a third-party SDK that isn't installed on your system, the build will show:
+
+```
+module.c: fatal error: 'sdk/header.h' file not found (SDK not installed?)
+```
+
+Install the required SDK or skip that package. These warnings are harmless — other packages continue building normally.
+
+### CFLAGS not applied
+
+If your `cell.toml` has a `[compilation]` section but flags aren't being picked up, check:
+
+1. The TOML syntax is valid (strings must be quoted)
+2. The section header is exactly `[compilation]` (not `[compile]` etc.)
+3. Target-specific sections use valid target names: `macos_arm64`, `macos_x86_64`, `linux`, `linux_arm64`, `windows`
+
+### API changes from older versions
+
+If C modules fail with errors about function signatures:
+
+- `JS_IsArray` takes one argument (the value), not two — remove the context argument
+- Use `JS_GetPropertyNumber` / `JS_SetPropertyNumber` instead of `JS_GetPropertyUint32` / `JS_SetPropertyUint32`
+- Use `JS_NewString` instead of `JS_NewAtomString`
+- There is no `undefined` — use `JS_IsNull` and `JS_NULL` only

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
-isa(42, number)        // true
-isa("hi", text)        // true
-isa([1,2], array)      // true
-isa({}, 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/)
-text.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,549 @@
-# 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
+## General
 
-### cell version
+### pit version
 
-Display the Cell version.
+Display the ƿit version.
 
 ```bash
-cell version
+pit version
 # 0.1.0
 ```
 
-### cell install
-
-Install a package to the shop.
-
-```bash
-cell install gitea.pockle.world/john/prosperon
-cell install /Users/john/local/mypackage  # local path
-```
-
-### cell update
-
-Update packages from remote sources.
-
-```bash
-cell update              # update all packages
-cell update <package>    # update specific package
-```
-
-### cell remove
-
-Remove a package from the shop.
-
-```bash
-cell remove gitea.pockle.world/john/oldpackage
-```
-
-### cell list
-
-List installed packages.
-
-```bash
-cell list              # list all installed packages
-cell list <package>    # list dependencies of a package
-```
-
-### cell ls
-
-List modules and actors in a package.
-
-```bash
-cell ls              # list files in current project
-cell ls <package>    # list files in specified package
-```
-
-### cell build
-
-Build the current package.
-
-```bash
-cell build
-```
-
-### cell test
-
-Run tests.
-
-```bash
-cell test            # run tests in current package
-cell test all        # run all tests
-cell test <package>  # run tests in specific package
-```
-
-### cell 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
-```
-
-### cell fetch
-
-Fetch package sources without extracting.
-
-```bash
-cell fetch <package>
-```
-
-### cell upgrade
-
-Upgrade the Cell installation itself.
-
-```bash
-cell upgrade
-```
-
-### cell clean
-
-Clean build artifacts.
-
-```bash
-cell clean
-```
-
-### cell help
+### pit help
 
 Display help information.
 
 ```bash
-cell help
-cell help <command>
+pit help
+pit help <command>
 ```
 
-## Running Scripts
+## Package Commands
 
-Any `.ce` file in the Cell core can be run as a command:
+These commands operate on a package's `cell.toml`, source files, or build artifacts.
+
+### pit add
+
+Add a dependency to the current package. Installs the package to the shop, builds any C modules, and updates `cell.toml`.
 
 ```bash
-cell version    # runs version.ce
-cell build      # runs build.ce
-cell test       # runs test.ce
+pit add gitea.pockle.world/john/prosperon         # remote, default alias
+pit add gitea.pockle.world/john/prosperon myalias  # remote, custom alias
+pit add /Users/john/work/mylib                     # local path (symlinked)
+pit add .                                          # current directory
+pit add ../sibling-package                         # relative path
+```
+
+For local paths, the package is symlinked into the shop rather than copied. Changes to the source directory are immediately visible.
+
+### pit build
+
+Build C modules for a package. Compiles each C file into a per-file dynamic library stored in the content-addressed build cache at `~/.cell/build/<hash>`. A per-package manifest is written so the runtime can find dylibs by package name. C files in `src/` directories are compiled as support objects and linked into the module dylibs. Files that previously failed to compile are skipped automatically (cached failure markers); they are retried when the source or compiler flags change.
+
+```bash
+pit build                         # build all packages
+pit build <package>               # build specific package
+pit build /Users/john/work/mylib  # build local package
+pit build .                       # build current directory
+pit build -t macos_arm64          # cross-compile for target
+pit build -b debug                # build type: release (default), debug, minsize
+pit build --list-targets          # list available targets
+pit build --force                 # force rebuild
+pit build --dry-run               # show what would be built
+pit build --verbose               # print resolved flags, commands, cache status
+```
+
+### pit test
+
+Run tests. See [Testing](/docs/testing/) for the full guide.
+
+```bash
+pit test                                   # run tests in current package
+pit test suite                             # run specific test file
+pit test all                               # run all tests in current package
+pit test package <name>                    # run tests in a named package
+pit test package /Users/john/work/mylib    # run tests for a local package
+pit test package all                       # run tests from all packages
+pit test suite --verify --diff             # with IR verification and differential testing
+```
+
+### pit ls
+
+List modules and actors in a package.
+
+```bash
+pit ls              # list files in current project
+pit ls <package>    # list files in specified package
+```
+
+### pit audit
+
+Test-compile all `.ce` and `.cm` scripts in package(s). Continues past failures and reports all errors at the end.
+
+```bash
+pit audit               # audit all installed packages
+pit audit <package>     # audit specific package
+pit audit .             # audit current directory
+```
+
+### pit resolve
+
+Print the fully resolved dependency closure for a package.
+
+```bash
+pit resolve              # resolve current package
+pit resolve <package>    # resolve specific package
+pit resolve --locked     # show lock state without links
+```
+
+### pit graph
+
+Emit a dependency graph.
+
+```bash
+pit graph                      # tree of current package
+pit graph --format dot         # graphviz dot output
+pit graph --format json        # json output
+pit graph --world              # graph all installed packages
+pit graph --locked             # show lock view without links
+```
+
+### pit verify
+
+Verify integrity and consistency of packages, links, and builds.
+
+```bash
+pit verify              # verify current package
+pit verify shop         # verify entire shop
+pit verify --deep       # traverse full dependency closure
+pit verify --target <triple>
+```
+
+### pit pack
+
+Build a statically linked binary from a package and all its dependencies.
+
+```bash
+pit pack <package>              # build static binary (output: app)
+pit pack <package> -o myapp     # specify output name
+pit pack <package> -t <triple>  # cross-compile for target
+```
+
+### pit config
+
+Manage system and actor configuration values in `cell.toml`.
+
+```bash
+pit config list                          # list all config
+pit config get system.ar_timer           # get a value
+pit config set system.ar_timer 5.0       # set a value
+pit config actor <name> list             # list actor config
+pit config actor <name> get <key>        # get actor config
+pit config actor <name> set <key> <val>  # set actor config
+```
+
+### pit bench
+
+Run benchmarks with statistical analysis. Benchmark files are `.cm` modules in a package's `benches/` directory.
+
+```bash
+pit bench                          # run all benchmarks in current package
+pit bench all                      # same as above
+pit bench <suite>                  # run specific benchmark file
+pit bench package <name>           # benchmark a named package
+pit bench package <name> <suite>   # specific benchmark in a package
+pit bench package all              # benchmark all packages
+pit bench --bytecode <suite>       # force bytecode-only benchmark run
+pit bench --native <suite>         # force native-only benchmark run
+pit bench --compare <suite>        # run bytecode and native side-by-side
+```
+
+Output includes median, mean, standard deviation, and percentiles for each benchmark.
+
+## Shop Commands
+
+These commands operate on the global shop (`~/.cell/`) or system-level state.
+
+### pit install
+
+Install a package to the shop.
+
+```bash
+pit install gitea.pockle.world/john/prosperon
+pit install /Users/john/local/mypackage  # local path
+```
+
+### pit remove
+
+Remove a package from the shop. Removes the lock entry, the package directory (or symlink), and any built dylibs.
+
+```bash
+pit remove gitea.pockle.world/john/oldpackage
+pit remove /Users/john/work/mylib           # local path
+pit remove .                                # current directory
+pit remove mypackage --dry-run              # show what would be removed
+pit remove mypackage --prune                # also remove orphaned dependencies
+```
+
+Options:
+- `--prune` — also remove packages that are no longer needed by any remaining root
+- `--dry-run` — show what would be removed without removing anything
+
+### pit update
+
+Update packages from remote sources.
+
+```bash
+pit update              # update all packages
+pit update <package>    # update specific package
+```
+
+### pit list
+
+List installed packages.
+
+```bash
+pit list              # list all installed packages
+pit list <package>    # list dependencies of a package
+```
+
+### pit link
+
+Manage local package links for development.
+
+```bash
+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
+```
+
+### pit unlink
+
+Remove a link created by `pit link` or `pit clone` and restore the original package.
+
+```bash
+pit unlink gitea.pockle.world/john/prosperon
+```
+
+### pit clone
+
+Clone a package to a local path and link it for development.
+
+```bash
+pit clone gitea.pockle.world/john/prosperon ./prosperon
+```
+
+### pit fetch
+
+Fetch package sources without extracting.
+
+```bash
+pit fetch <package>
+```
+
+### pit search
+
+Search for packages, actors, or modules matching a query.
+
+```bash
+pit search math
+```
+
+### pit why
+
+Show which installed packages depend on a given package (reverse dependency lookup).
+
+```bash
+pit why gitea.pockle.world/john/prosperon
+```
+
+### pit upgrade
+
+Upgrade the ƿit installation itself.
+
+```bash
+pit upgrade
+```
+
+### pit clean
+
+Clean build artifacts.
+
+```bash
+pit clean
+```
+
+## Logging
+
+### pit log
+
+Manage log sinks and read log files. See [Logging](/docs/logging/) for the full guide.
+
+### pit log list
+
+List configured sinks.
+
+```bash
+pit log list
+```
+
+### pit log add
+
+Add a log sink.
+
+```bash
+pit log add <name> console [options]     # add a console sink
+pit log add <name> file <path> [options] # add a file sink
+```
+
+Options:
+
+- `--format=pretty|bare|json` — output format (default: `pretty` for console, `json` for file)
+- `--channels=ch1,ch2` — channels to subscribe (default: `console,error,system`). Use `'*'` for all channels (quote to prevent shell glob expansion).
+- `--exclude=ch1,ch2` — channels to exclude (useful with `'*'`)
+- `--stack=ch1,ch2` — channels that capture a full stack trace (default: `error`)
+
+```bash
+pit log add terminal console --format=bare --channels=console
+pit log add errors file .cell/logs/errors.jsonl --channels=error
+pit log add dump file .cell/logs/dump.jsonl '--channels=*' --exclude=console
+pit log add debug console --channels=error,debug --stack=error,debug
+```
+
+### pit log remove
+
+Remove a sink.
+
+```bash
+pit log remove <name>
+```
+
+### pit log read
+
+Read entries from a file sink.
+
+```bash
+pit log read <sink> [options]
+```
+
+Options:
+
+- `--lines=N` — show last N entries
+- `--channel=X` — filter by channel
+- `--since=timestamp` — only show entries after timestamp (seconds since epoch)
+
+```bash
+pit log read errors --lines=50
+pit log read dump --channel=debug --lines=10
+pit log read errors --since=1702656000
+```
+
+### pit log tail
+
+Follow a file sink in real time.
+
+```bash
+pit log tail <sink> [--lines=N]
+```
+
+`--lines=N` controls how many existing entries to show on start (default: 10).
+
+```bash
+pit log tail dump
+pit log tail errors --lines=20
+```
+
+## Developer Commands
+
+Compiler pipeline tools, analysis, and testing. These are primarily useful for developing the ƿit compiler and runtime.
+
+### Compiler Pipeline
+
+Each of these commands runs the compilation pipeline up to a specific stage and prints the intermediate output. They take a source file as input.
+
+### pit tokenize
+
+Tokenize a source file and output the token stream as JSON.
+
+```bash
+pit tokenize <file.cm>
+```
+
+### pit parse
+
+Parse a source file and output the AST as JSON.
+
+```bash
+pit parse <file.cm>
+```
+
+### pit fold
+
+Run constant folding and semantic analysis on a source file and output the simplified AST as JSON.
+
+```bash
+pit fold <file.cm>
+```
+
+### pit mcode
+
+Compile a source file to mcode (machine-independent intermediate representation) and output as JSON.
+
+```bash
+pit mcode <file.cm>
+```
+
+### pit streamline
+
+Apply the full optimization pipeline to a source file and output optimized mcode as JSON.
+
+```bash
+pit streamline <file.cm>                # full optimized IR as JSON (default)
+pit streamline --stats <file.cm>        # summary stats per function
+pit streamline --ir <file.cm>           # human-readable IR
+pit streamline --check <file.cm>        # warnings only (e.g. high slot count)
+```
+
+Flags can be combined. `--stats` output includes function name, args, slots, instruction counts by category, and nops eliminated. `--check` warns when `nr_slots > 200` (approaching the 255 limit).
+
+### pit qbe
+
+Compile a source file to QBE intermediate language (for native code generation).
+
+```bash
+pit qbe <file.cm>
+```
+
+### pit compile
+
+Compile a source file to a native dynamic library.
+
+```bash
+pit compile <file.cm>    # outputs .dylib to ~/.cell/build/
+pit compile <file.ce>
+```
+
+### pit run_native
+
+Compile a module natively and compare execution against interpreted mode, showing timing differences.
+
+```bash
+pit run_native <module>              # compare interpreted vs native
+pit run_native <module> <test_arg>   # pass argument to module function
+```
+
+### pit run_aot
+
+Ahead-of-time compile and execute a program natively.
+
+```bash
+pit run_aot <program.ce>
+```
+
+### pit seed
+
+Regenerate the boot seed files in `boot/`. Seeds are pre-compiled mcode IR (JSON) that bootstrap the compilation pipeline on cold start. They only need regenerating when the pipeline source changes in a way the existing seeds can't compile, or before distribution.
+
+```bash
+pit seed                # regenerate all boot seeds
+pit seed --clean        # also clear the build cache after
+```
+
+The engine recompiles pipeline modules automatically when source changes (via content-addressed cache). Seeds are a fallback for cold start when no cache exists.
+
+### Analysis
+
+### pit explain
+
+Query the semantic index for symbol information at a specific source location or by name.
+
+```bash
+pit explain --span <file:line:col>       # find symbol at position
+pit explain --symbol <name> [files...]   # find symbol by name
+pit explain --help                       # show usage
+```
+
+### pit index
+
+Build a semantic index for a source file and output symbol information as JSON.
+
+```bash
+pit index <file.cm>                # output to stdout
+pit index <file.cm> -o index.json  # output to file
+pit index --help                   # show usage
+```
+
+### pit ir_report
+
+Optimizer flight recorder — capture detailed information about IR transformations during optimization.
+
+```bash
+pit ir_report <file.cm>                  # per-pass JSON summaries (default)
+pit ir_report <file.cm> --events         # include rewrite events
+pit ir_report <file.cm> --types          # include type deltas
+pit ir_report <file.cm> --ir-before=PASS # print IR before specific pass
+pit ir_report <file.cm> --ir-after=PASS  # print IR after specific pass
+pit ir_report <file.cm> --ir-all         # print IR before/after every pass
+pit ir_report <file.cm> --full           # all options combined
+```
+
+Output is NDJSON (newline-delimited JSON).
+
+### Testing
+
+### pit diff
+
+Differential testing — run tests with and without optimizations and compare results.
+
+```bash
+pit diff                # diff all test files in current package
+pit diff <suite>        # diff specific test file
+pit diff tests/<path>   # diff by path
+```
+
+### pit fuzz
+
+Random program fuzzer — generates random programs and checks for optimization correctness by comparing optimized vs unoptimized execution.
+
+```bash
+pit fuzz                       # 100 iterations with random seed
+pit fuzz <iterations>          # specific number of iterations
+pit fuzz --seed <N>            # start at specific seed
+pit fuzz <iterations> --seed <N>
+```
+
+Failures are saved to `tests/fuzz_failures/`.
+
+### pit vm_suite
+
+Run the VM stability test suite (641 tests covering arithmetic, strings, control flow, closures, objects, and more).
+
+```bash
+pit vm_suite
+```
+
+### pit syntax_suite
+
+Run the syntax feature test suite (covers all literal types, operators, control flow, functions, prototypes, and more).
+
+```bash
+pit syntax_suite
 ```
 
 ## Package Locators
@@ -143,19 +554,18 @@ 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 `~/.cell/`:
 
 ```
 ~/.cell/
-├── packages/       # installed packages
-├── lib/            # compiled dynamic libraries
-├── build/          # build cache
+├── packages/       # installed package sources
+├── build/          # content-addressed cache (bytecode, dylibs, manifests)
 ├── cache/          # downloaded archives
 ├── lock.toml       # installed package versions
 └── link.toml       # local development links
@@ -163,7 +573,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,495 @@
+---
+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 CLI tool that lets you see its output.
+
+| Stage       | Tool                      | What it shows                          |
+|-------------|---------------------------|----------------------------------------|
+| tokenize    | `tokenize.ce`             | Token stream as JSON                   |
+| parse       | `parse.ce`                | Unfolded AST as JSON                   |
+| fold        | `fold.ce`                 | Folded AST as JSON                     |
+| mcode       | `mcode.ce`                | Raw mcode IR as JSON                   |
+| mcode       | `mcode.ce --pretty`       | Human-readable mcode IR               |
+| streamline  | `streamline.ce`           | Full optimized IR as JSON              |
+| streamline  | `streamline.ce --types`   | Optimized IR with type annotations     |
+| streamline  | `streamline.ce --stats`   | Per-function summary stats             |
+| streamline  | `streamline.ce --ir`      | Human-readable canonical IR            |
+| disasm      | `disasm.ce`               | Source-interleaved disassembly          |
+| disasm      | `disasm.ce --optimized`   | Optimized source-interleaved disassembly |
+| diff        | `diff_ir.ce`              | Mcode vs streamline instruction diff   |
+| xref        | `xref.ce`                 | Cross-reference / call creation graph  |
+| cfg         | `cfg.ce`                  | Control flow graph (basic blocks)      |
+| slots       | `slots.ce`                | Slot data flow / use-def chains        |
+| 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 (pretty-printed)
+cell mcode --pretty myfile.ce
+
+# source-interleaved disassembly
+cell disasm myfile.ce
+
+# see optimized IR with type annotations
+cell streamline --types myfile.ce
+
+# full optimizer report with events
+cell ir_report --full myfile.ce
+```
+
+## fold.ce
+
+Prints the folded AST as JSON. This is the output of the parser and constant folder, before mcode generation.
+
+```bash
+cell fold <file.ce|file.cm>
+```
+
+## mcode.ce
+
+Prints mcode IR. Default output is JSON; use `--pretty` for human-readable format with opcodes, operands, and program counter.
+
+```bash
+cell mcode <file.ce|file.cm>            # JSON (default)
+cell mcode --pretty <file.ce|file.cm>   # human-readable IR
+```
+
+## 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 streamline <file.ce|file.cm>                # full JSON (default)
+cell streamline --stats <file.ce|file.cm>        # summary stats per function
+cell streamline --ir <file.ce|file.cm>           # human-readable IR
+cell streamline --check <file.ce|file.cm>        # warnings only
+cell streamline --types <file.ce|file.cm>        # IR with type annotations
+cell streamline --diagnose <file.ce|file.cm>     # compile-time diagnostics
+```
+
+| Flag | Description |
+|------|-------------|
+| (none) | Full optimized IR as JSON (backward compatible) |
+| `--stats` | Per-function summary: args, slots, instruction counts by category, nops eliminated |
+| `--ir` | Human-readable canonical IR (same format as `ir_report.ce`) |
+| `--check` | Warnings only (e.g. `nr_slots > 200` approaching 255 limit) |
+| `--types` | Optimized IR with inferred type annotations per slot |
+| `--diagnose` | Run compile-time diagnostics (type errors and warnings) |
+
+Flags can be combined.
+
+## disasm.ce
+
+Source-interleaved disassembly. Shows mcode or optimized IR with source lines interleaved, making it easy to see which instructions were generated from which source code.
+
+```bash
+cell disasm <file>                         # disassemble all functions (mcode)
+cell disasm --optimized <file>             # disassemble optimized IR (streamline)
+cell disasm --fn 87 <file>                 # show only function 87
+cell disasm --fn my_func <file>            # show only functions named "my_func"
+cell disasm --line 235 <file>              # show instructions generated from line 235
+```
+
+| Flag | Description |
+|------|-------------|
+| (none) | Raw mcode IR with source interleaving (default) |
+| `--optimized` | Use optimized IR (streamline) instead of raw mcode |
+| `--fn <N\|name>` | Filter to specific function by index or name substring |
+| `--line <N>` | Show only instructions generated from a specific source line |
+
+### Output Format
+
+Functions are shown with a header including argument count, slot count, and the source line where the function begins. Instructions are grouped by source line, with the source text shown before each group:
+
+```
+=== [87] <anonymous> (args=0, slots=12, closures=0) [line 234] ===
+
+  --- line 235: var result = compute(x, y) ---
+  0     access         2, "compute"                           :235
+  1     get            3, 1, 0                                :235
+  2     get            4, 1, 1                                :235
+  3     invoke         3, 2, 2                                :235
+
+  --- line 236: if (result > 0) { ---
+  4     access         5, 0                                   :236
+  5     gt             6, 4, 5                                :236
+  6     jump_false     6, "else_1"                            :236
+```
+
+Each instruction line shows:
+- Program counter (left-aligned)
+- Opcode
+- Operands (comma-separated)
+- Source line number (`:N` suffix, right-aligned)
+
+Function creation instructions include a cross-reference annotation showing the target function's name:
+
+```
+  3     function       5, 12                                  :235  ; -> [12] helper_fn
+```
+
+## diff_ir.ce
+
+Compares mcode IR (before optimization) with streamline IR (after optimization), showing what the optimizer changed. Useful for understanding which instructions were eliminated, specialized, or rewritten.
+
+```bash
+cell diff_ir <file>                  # diff all functions
+cell diff_ir --fn <N|name> <file>    # diff only one function
+cell diff_ir --summary <file>        # counts only
+```
+
+| Flag | Description |
+|------|-------------|
+| (none) | Show all diffs with source interleaving |
+| `--fn <N\|name>` | Filter to specific function by index or name |
+| `--summary` | Show only eliminated/rewritten counts per function |
+
+### Output Format
+
+Changed instructions are shown in diff style with `-` (before) and `+` (after) lines:
+
+```
+=== [0] <anonymous> (args=1, slots=40) ===
+  17 eliminated, 51 rewritten
+
+  --- line 4: if (n <= 1) { ---
+  - 1     is_int         4, 1                          :4
+  + 1     is_int         3, 1                          :4  (specialized)
+  - 3     is_int         5, 2                          :4
+  + 3     _nop_tc_1                                         (eliminated)
+```
+
+Summary mode gives a quick overview:
+
+```
+  [0] <anonymous>:                       17 eliminated, 51 rewritten
+  [1] <anonymous>:                       65 eliminated, 181 rewritten
+  total: 86 eliminated, 250 rewritten across 4 functions
+```
+
+## xref.ce
+
+Cross-reference / call graph tool. Shows which functions create other functions (via `function` instructions), building a creation tree.
+
+```bash
+cell xref <file>                     # full creation tree
+cell xref --callers <N> <file>       # who creates function [N]?
+cell xref --callees <N> <file>       # what does [N] create/call?
+cell xref --dot <file>               # DOT graph for graphviz
+cell xref --optimized <file>         # use optimized IR
+```
+
+| Flag | Description |
+|------|-------------|
+| (none) | Indented creation tree from main |
+| `--callers <N>` | Show which functions create function [N] |
+| `--callees <N>` | Show what function [N] creates (use -1 for main) |
+| `--dot` | Output DOT format for graphviz |
+| `--optimized` | Use optimized IR instead of raw mcode |
+
+### Output Format
+
+Default tree view:
+
+```
+demo_disasm.cm
+  [0] <anonymous>
+  [1] <anonymous>
+  [2] <anonymous>
+```
+
+Caller/callee query:
+
+```
+Callers of [0] <anonymous>:
+  demo_disasm.cm at line 3
+```
+
+DOT output can be piped to graphviz: `cell xref --dot file.cm | dot -Tpng -o xref.png`
+
+## cfg.ce
+
+Control flow graph tool. Identifies basic blocks from labels and jumps, computes edges, and detects loop back-edges.
+
+```bash
+cell cfg --fn <N|name> <file>        # text CFG for function
+cell cfg --dot --fn <N|name> <file>  # DOT output for graphviz
+cell cfg <file>                      # text CFG for all functions
+cell cfg --optimized <file>          # use optimized IR
+```
+
+| Flag | Description |
+|------|-------------|
+| `--fn <N\|name>` | Filter to specific function by index or name |
+| `--dot` | Output DOT format for graphviz |
+| `--optimized` | Use optimized IR instead of raw mcode |
+
+### Output Format
+
+```
+=== [0] <anonymous> ===
+  B0 [pc 0-2, line 4]:
+    0     access         2, 1
+    1     is_int         4, 1
+    2     jump_false     4, "rel_ni_2"
+    -> B3 "rel_ni_2" (jump)
+    -> B1 (fallthrough)
+
+  B1 [pc 3-4, line 4]:
+    3     is_int         5, 2
+    4     jump_false     5, "rel_ni_2"
+    -> B3 "rel_ni_2" (jump)
+    -> B2 (fallthrough)
+```
+
+Each block shows its ID, PC range, source lines, instructions, and outgoing edges. Loop back-edges (target PC <= source PC) are annotated.
+
+## slots.ce
+
+Slot data flow analysis. Builds use-def chains for every slot in a function, showing where each slot is defined and used. Optionally captures type information from streamline.
+
+```bash
+cell slots --fn <N|name> <file>              # slot summary for function
+cell slots --slot <N> --fn <N|name> <file>   # trace slot N
+cell slots <file>                            # slot summary for all functions
+```
+
+| Flag | Description |
+|------|-------------|
+| `--fn <N\|name>` | Filter to specific function by index or name |
+| `--slot <N>` | Show chronological DEF/USE trace for a specific slot |
+
+### Output Format
+
+Summary shows each slot with its def count, use count, inferred type, and first definition. Dead slots (defined but never used) are flagged:
+
+```
+=== [0] <anonymous> (args=1, slots=40) ===
+  slot    defs    uses    type        first-def
+  s0      0       0       -           (this)
+  s1      0       10      -           (arg 0)
+  s2      1       6       -           pc 0: access
+  s10     1       0       -           pc 29: invoke  <- dead
+```
+
+Slot trace (`--slot N`) shows every DEF and USE in program order:
+
+```
+=== slot 3 in [0] <anonymous> ===
+  DEF  pc 5:     le_int         3, 1, 2                       :4
+  DEF  pc 11:    le_float       3, 1, 2                       :4
+  DEF  pc 17:    le_text        3, 1, 2                       :4
+  USE  pc 31:    jump_false     3, "if_else_0"                :4
+```
+
+## seed.ce
+
+Regenerates the boot seed files in `boot/`. These are pre-compiled mcode IR (JSON) files that bootstrap the compilation pipeline on cold start.
+
+```bash
+cell seed                # regenerate all boot seeds
+cell seed --clean        # also clear the build cache after
+```
+
+The script compiles each pipeline module (tokenize, parse, fold, mcode, streamline) and `internal/bootstrap.cm` through the current pipeline, encodes the output as JSON, and writes it to `boot/<name>.cm.mcode`.
+
+**When to regenerate seeds:**
+- Before a release or distribution
+- When the pipeline source changes in a way the existing seeds can't compile the new source (e.g. language-level changes)
+- Seeds do NOT need regenerating for normal development — the engine recompiles pipeline modules from source automatically via the content-addressed cache
+
+## 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 ir_report [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 ir_report --summary myfile.ce | jq 'select(.changed)'
+
+# list all rewrite rules that fired
+cell ir_report --events myfile.ce | jq 'select(.type == "event") | .rule'
+
+# diff IR before and after optimization
+cell ir_report --ir-all myfile.ce | jq -r 'select(.type == "ir") | .text'
+
+# full report for analysis
+cell ir_report --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/functions.md

@@ -0,0 +1,503 @@
+---
+title: "Built-in Functions"
+description: "Intrinsic constants and functions"
+weight: 60
+type: "docs"
+---
+
+The intrinsics are constants and functions that are built into the language. The `use` statement is not needed to access them.
+
+A programmer is not obliged to consult the list of intrinsics before naming a new variable or input. New intrinsics may be added to ƿit without breaking existing programs.
+
+## Constants
+
+### false
+
+The value of `1 == 0`. One of the two logical values.
+
+### true
+
+The value of `1 == 1`. One of the two logical values.
+
+### null
+
+The value of `1 / 0`. The null value is an empty immutable object. All attempts to obtain a value from null by refinement will produce null.
+
+Any attempt to modify null will disrupt. Any attempt to call null as a function will disrupt.
+
+null is the value of missing input values, missing fields in records, and invalid numbers.
+
+### pi
+
+An approximation of circumference / diameter: 3.1415926535897932.
+
+## Creator Functions
+
+The creator functions are **polymorphic** — they examine the types of their arguments to decide what to do. The first argument's type selects the behavior. All return null if their inputs are not suitable.
+
+### array
+
+The `array` function creates arrays from various inputs. Its behavior depends on the type of the first argument:
+
+**From a number** — create an array of that size:
+
+`array(number)` — All elements are initialized to null.
+
+`array(number, initial_value)` — All elements are initialized to initial_value. If initial_value is a function, it is called for each element. If the function has arity >= 1, it is passed the element number.
+
+```javascript
+array(3)              // [null, null, null]
+array(3, 0)           // [0, 0, 0]
+array(5, i => i * 2)  // [0, 2, 4, 6, 8]
+```
+
+**From an array** — copy, map, concat, or slice:
+
+`array(array)` — Copy. Make a mutable copy of the array.
+
+`array(array, function, reverse, exit)` — Map. Call the function with each element, collecting return values in a new array. The function is passed each element and its element number.
+
+```javascript
+array([1, 2, 3], x => x * 10)  // [10, 20, 30]
+```
+
+If reverse is true, starts with the last element and works backwards.
+
+If exit is not null, when the function returns the exit value, array returns early. The exit value is not stored into the new array.
+
+`array(array, another_array)` — Concat. Produce a new array concatenating both.
+
+```javascript
+array([1, 2], [3, 4])  // [1, 2, 3, 4]
+```
+
+`array(array, from, to)` — Slice. Make a mutable copy of part of an array. If from is negative, add length(array). If to is negative, add length(array).
+
+```javascript
+array([1, 2, 3, 4, 5], 1, 4)  // [2, 3, 4]
+array([1, 2, 3], -2)          // [2, 3]
+```
+
+**From a record** — get keys:
+
+`array(record)` — Keys. Make an array containing all text keys in the record.
+
+```javascript
+array({a: 1, b: 2})  // ["a", "b"]
+```
+
+**From text** — split into characters or substrings:
+
+`array(text)` — Split text into an array of individual characters (grapheme clusters). This is the standard way to iterate over characters.
+
+```javascript
+array("hello")  // ["h", "e", "l", "l", "o"]
+array("ƿit")    // ["ƿ", "i", "t"]
+```
+
+`array(text, separator)` — Split text by a separator string into an array of subtexts.
+
+```javascript
+array("a,b,c", ",")  // ["a", "b", "c"]
+```
+
+`array(text, length)` — Dice text into an array of subtexts of a given length.
+
+### logical
+
+```javascript
+logical(0)        // false
+logical(false)    // false
+logical("false")  // false
+logical(null)     // false
+logical(1)        // true
+logical(true)     // true
+logical("true")   // true
+```
+
+All other values return null.
+
+### number
+
+The `number` function converts values to numbers. Its behavior depends on the type of the first argument:
+
+`number(logical)` — Returns 1 or 0.
+
+`number(number)` — Returns the number.
+
+`number(text, radix)` — Convert text to number. Radix is 2 thru 37 (default: 10).
+
+`number(text, format)` — Parse formatted numbers:
+
+| Format | Radix | Separator | Decimal point |
+|--------|-------|-----------|---------------|
+| `""` | 10 | | .period |
+| `"n"` | 10 | | .period |
+| `"u"` | 10 | _underbar | .period |
+| `"d"` | 10 | ,comma | .period |
+| `"s"` | 10 | space | .period |
+| `"v"` | 10 | .period | ,comma |
+| `"l"` | 10 | locale | locale |
+| `"b"` | 2 | | |
+| `"o"` | 8 | | |
+| `"h"` | 16 | | |
+| `"j"` | auto | | |
+
+```javascript
+number("123,456,789.10", "d")  // 123456789.1
+number("123.456.789,10", "v")  // 123456789.1
+number("666", "o")             // 438
+number("666", "h")             // 1638
+```
+
+### text
+
+The `text` function converts values to text. Its behavior depends on the type of the first argument:
+
+**From an array** — join elements into text:
+
+`text(array, separator)` — Convert array to text. Elements are concatenated with the separator (default: empty text).
+
+```javascript
+text(["h", "e", "l", "l", "o"])        // "hello"
+text(["a", "b", "c"], ", ")            // "a, b, c"
+```
+
+**From a number** — format as text:
+
+`text(number, radix)` — Convert number to text. Radix is 2 thru 37 (default: 10).
+
+`text(number, format)` — Format a number as text:
+
+**Real styles:**
+
+| Style | Description | Separator | Decimal |
+|-------|-------------|-----------|---------|
+| `"e"` | Scientific | | .period |
+| `"n"` | Number | | .period |
+| `"s"` | Space | space | .period |
+| `"u"` | Underbar | _underbar | .period |
+| `"d"` | Decimal | ,comma | .period |
+| `"c"` | Comma | .period | ,comma |
+| `"l"` | Locale | locale | locale |
+
+**Integer styles:**
+
+| Style | Base | Separator |
+|-------|------|-----------|
+| `"i"` | 10 | _underbar |
+| `"b"` | 2 | _underbar |
+| `"o"` | 8 | _underbar |
+| `"h"` | 16 | _underbar |
+| `"t"` | 32 | _underbar |
+
+The format text is: `separation_digit` + `style_letter` + `places_digits`
+
+```javascript
+var data = 123456789.1
+text(data)             // "123456789.1"
+text(data, "3s4")      // "123 456 789.1000"
+text(data, "d2")       // "123,456,789.10"
+text(data, "e")        // "1.234567891e8"
+text(data, "i")        // "123456789"
+text(data, "8b")       // "111_01011011_11001101_00010101"
+text(data, "h")        // "75BCD15"
+text(12, "4b8")        // "0000_1100"
+```
+
+**From text** — extract a substring:
+
+`text(text, from, to)` — Extract a substring. If from/to are negative, add length(text).
+
+```javascript
+var my_text = "miskatonic"
+text(my_text, 0, 3)   // "mis"
+text(my_text, 5)       // "tonic"
+text(my_text, -3)      // "nic"
+```
+
+### record
+
+The `record` function creates and manipulates records (objects). Its behavior depends on the type of the first argument:
+
+**From a record** — copy, merge, or select:
+
+`record(record)` — Copy. Make a mutable copy.
+
+`record(record, another_record)` — Combine. Copy a record, then put all fields of another into the copy.
+
+`record(record, array_of_keys)` — Select. New record with only the named fields.
+
+**From an array of keys** — create a new record:
+
+`record(array_of_keys)` — Set. New record using array as keys, each value is true.
+
+`record(array_of_keys, value)` — Value Set. Each field value is value.
+
+`record(array_of_keys, function)` — Functional Value Set. The function is called for each key to produce field values.
+
+## Sensory Functions
+
+The sensory functions always return a logical value. In ƿit, they use the `is_` prefix:
+
+```javascript
+is_array([])         // true
+is_blob(blob.make()) // true
+is_function(x => x)  // true
+is_integer(42)       // true
+is_logical(true)     // true
+is_null(null)        // true
+is_number(3.14)      // true
+is_object({})        // true (records only)
+is_text("hello")     // true
+```
+
+Additional type checks: `is_character`, `is_data`, `is_digit`, `is_false`, `is_fit`, `is_letter`, `is_lower`, `is_pattern`, `is_stone`, `is_true`, `is_upper`, `is_whitespace`.
+
+## Standard Functions
+
+### abs(number)
+
+Absolute value. Returns null for non-numbers.
+
+### apply(function, array)
+
+Execute the function, passing the array elements as input values. If the array is longer than the function's arity, it disrupts.
+
+### ceiling(number, place)
+
+Round up. If place is 0 or null, round to the smallest integer >= number.
+
+```javascript
+ceiling(12.3775)        // 13
+ceiling(12.3775, -2)    // 12.38
+ceiling(-12.3775)       // -12
+```
+
+### character(value)
+
+If text, returns the first character. If a non-negative 32-bit integer, returns the character from that codepoint.
+
+### codepoint(text)
+
+Returns the codepoint number of the first character.
+
+### ends_with(text, suffix)
+
+Returns `true` if the text ends with the given suffix.
+
+```javascript
+ends_with("hello.ce", ".ce")   // true
+ends_with("hello.cm", ".ce")   // false
+```
+
+### every(array, function)
+
+Returns `true` if every element satisfies the predicate.
+
+```javascript
+every([2, 4, 6], x => x % 2 == 0)  // true
+every([2, 3, 6], x => x % 2 == 0)  // false
+```
+
+### extract(text, pattern, from, to)
+
+Match text to pattern. Returns a record of saved fields, or null if no match.
+
+### fallback(requestor_array)
+
+Returns a requestor that tries each requestor in order until one succeeds. Returns a cancel function. See [Requestors](/docs/requestors/) for usage.
+
+### filter(array, function)
+
+Call function for each element. When it returns true, the element is included in the new array.
+
+```javascript
+filter([0, 1.25, 2, 3.5, 4, 5.75], is_integer)  // [0, 2, 4]
+```
+
+### find(array, function, reverse, from)
+
+Call function for each element. If it returns true, return the element number. If the second argument is not a function, it is compared directly to elements. Returns null if not found.
+
+```javascript
+find([1, 2, 3], x => x > 1)  // 1
+find([1, 2, 3], 2)            // 1
+```
+
+### floor(number, place)
+
+Round down. If place is 0 or null, round to the greatest integer <= number.
+
+```javascript
+floor(12.3775)        // 12
+floor(12.3775, -2)    // 12.37
+floor(-12.3775)       // -13
+```
+
+### for(array, function, reverse, exit)
+
+Call function with each element and its element number. If exit is not null and the function returns the exit value, return early.
+
+### format(text, collection, transformer)
+
+Substitute `{key}` placeholders in text with values from a collection (array or record).
+
+```javascript
+format("{0} in {1}!", ["Malmborg", "Plano"])
+// "Malmborg in Plano!"
+```
+
+### fraction(number)
+
+Returns the fractional part of a number. See also `whole`.
+
+### length(value)
+
+| Value | Result |
+|-------|--------|
+| array | number of elements |
+| blob | number of bits |
+| text | number of codepoints |
+| function | number of named inputs (arity) |
+| record | record.length() |
+| other | null |
+
+### lower(text)
+
+Returns text with all uppercase characters converted to lowercase.
+
+### max(number, number)
+
+Returns the larger of two numbers. Returns null if either is not a number.
+
+### min(number, number)
+
+Returns the smaller of two numbers.
+
+### modulo(dividend, divisor)
+
+Result is `dividend - (divisor * floor(dividend / divisor))`. Result has the sign of the divisor.
+
+### neg(number)
+
+Negate. Reverse the sign of a number.
+
+### normalize(text)
+
+Unicode normalize.
+
+### not(logical)
+
+Returns the opposite logical. Returns null for non-logicals.
+
+### parallel(requestor_array, throttle, need)
+
+Returns a requestor that starts all requestors in the array. Results are collected into an array matching the input order. Optional throttle limits concurrent requestors. Optional need specifies the minimum number of successes required. See [Requestors](/docs/requestors/) for usage.
+
+### race(requestor_array, throttle, need)
+
+Like parallel, but returns as soon as the needed number of results are obtained. Default need is 1. Unfinished requestors are cancelled. See [Requestors](/docs/requestors/) for usage.
+
+### reduce(array, function, initial, reverse)
+
+Reduce an array to a single value by applying a function to pairs of elements.
+
+```javascript
+reduce([1, 2, 3, 4, 5, 6, 7, 8, 9], (a, b) => a + b)  // 45
+```
+
+### remainder(dividend, divisor)
+
+For fit integers: `dividend - ((dividend // divisor) * divisor)`.
+
+### replace(text, target, replacement, limit)
+
+Return text with target replaced by replacement. Target can be text or pattern. Replacement can be text or a function.
+
+### reverse(array)
+
+Returns a new array with elements in the opposite order.
+
+### round(number, place)
+
+Round to nearest.
+
+```javascript
+round(12.3775)        // 12
+round(12.3775, -2)    // 12.38
+```
+
+### search(text, target, from)
+
+Search text for target. Returns character position or null.
+
+### sequence(requestor_array)
+
+Returns a requestor that processes each requestor in order. Each result becomes the input to the next. The last result is the final result. See [Requestors](/docs/requestors/) for usage.
+
+### sign(number)
+
+Returns -1, 0, or 1.
+
+### some(array, function)
+
+Returns `true` if any element satisfies the predicate. Stops at the first match.
+
+```javascript
+some([1, 2, 3], x => x > 2)  // true
+some([1, 2, 3], x => x > 5)  // false
+```
+
+### sort(array, select)
+
+Returns a new sorted array. Sort keys must be all numbers or all texts. Sort is ascending and stable.
+
+| select type | Sort key | Description |
+|-------------|----------|-------------|
+| null | element itself | Simple sort |
+| text | element[select] | Sort by record field |
+| number | element[select] | Sort by array index |
+| array | select[index] | External sort keys |
+
+```javascript
+sort(["oats", "peas", "beans", "barley"])
+// ["barley", "beans", "oats", "peas"]
+
+sort([{n: 3}, {n: 1}], "n")
+// [{n: 1}, {n: 3}]
+```
+
+### starts_with(text, prefix)
+
+Returns `true` if the text starts with the given prefix.
+
+```javascript
+starts_with("hello world", "hello")  // true
+starts_with("hello world", "world")  // false
+```
+
+### stone(value)
+
+Petrify the value, making it permanently immutable. The operation is deep — all nested objects and arrays are also frozen. Returns the value.
+
+### trim(text, reject)
+
+Remove characters from both ends. Default removes whitespace.
+
+### trunc(number, place)
+
+Truncate toward zero.
+
+```javascript
+trunc(12.3775)        // 12
+trunc(-12.3775)       // -12
+```
+
+### upper(text)
+
+Returns text with all lowercase characters converted to uppercase.
+
+### whole(number)
+
+Returns the whole part of a number. See also `fraction`.

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 JavaScript-like syntax with the actor model of computation.
-
-## 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
-- [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,657 @@
+---
+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
+
+Functions can have at most **4 parameters**. Use a record to pass more values.
+
+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)
+
+// More than 4 parameters — use a record
+var draw = function(shape, opts) {
+  // opts.x, opts.y, opts.color, ...
+}
+```
+
+### 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 (records only)
+is_array([])            // true
+is_function(function(){})  // true
+is_null(null)           // true
+is_object([])           // false (arrays are not records)
+is_object("hello")      // false (text is not a record)
+is_array({})            // false (records are not arrays)
+```
+
+### 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 {
+  log.error("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.
 
@@ -10,10 +15,14 @@ var json = use('json')
 
 ### json.encode(value, space, replacer, whitelist)
 
-Convert a value to JSON text.
+Convert a value to JSON text. With no `space` argument, output is pretty-printed with 1-space indent. Pass `false` or `0` for compact single-line output.
 
 ```javascript
 json.encode({a: 1, b: 2})
+// '{ "a": 1, "b": 2 }'
+
+// Compact (no whitespace)
+json.encode({a: 1, b: 2}, false)
 // '{"a":1,"b":2}'
 
 // Pretty print with 2-space indent
@@ -27,7 +36,7 @@ json.encode({a: 1, b: 2}, 2)
 **Parameters:**
 
 - **value** — the value to encode
-- **space** — indentation (number of spaces or string)
+- **space** — indentation: number of spaces, string, or `false`/`0` for compact output. Default is pretty-printed.
 - **replacer** — function to transform values
 - **whitelist** — array of keys to include
 
@@ -86,5 +95,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
@@ -46,98 +51,98 @@ number("0xff", "j")     // 255
 
 ## Methods
 
-### number.abs(n)
+### abs(n)
 
 Absolute value.
 
 ```javascript
-number.abs(-5)   // 5
-number.abs(5)    // 5
+abs(-5)   // 5
+abs(5)    // 5
 ```
 
-### number.sign(n)
+### sign(n)
 
 Returns -1, 0, or 1.
 
 ```javascript
-number.sign(-5)  // -1
-number.sign(0)   // 0
-number.sign(5)   // 1
+sign(-5)  // -1
+sign(0)   // 0
+sign(5)   // 1
 ```
 
-### number.floor(n, place)
+### floor(n, place)
 
 Round down.
 
 ```javascript
-number.floor(4.9)      // 4
-number.floor(4.567, 2) // 4.56
+floor(4.9)      // 4
+floor(4.567, 2) // 4.56
 ```
 
-### number.ceiling(n, place)
+### ceiling(n, place)
 
 Round up.
 
 ```javascript
-number.ceiling(4.1)      // 5
-number.ceiling(4.123, 2) // 4.13
+ceiling(4.1)      // 5
+ceiling(4.123, 2) // 4.13
 ```
 
-### number.round(n, place)
+### round(n, place)
 
 Round to nearest.
 
 ```javascript
-number.round(4.5)      // 5
-number.round(4.567, 2) // 4.57
+round(4.5)      // 5
+round(4.567, 2) // 4.57
 ```
 
-### number.trunc(n, place)
+### trunc(n, place)
 
 Truncate toward zero.
 
 ```javascript
-number.trunc(4.9)   // 4
-number.trunc(-4.9)  // -4
+trunc(4.9)   // 4
+trunc(-4.9)  // -4
 ```
 
-### number.whole(n)
+### whole(n)
 
 Get the integer part.
 
 ```javascript
-number.whole(4.9)   // 4
-number.whole(-4.9)  // -4
+whole(4.9)   // 4
+whole(-4.9)  // -4
 ```
 
-### number.fraction(n)
+### fraction(n)
 
 Get the fractional part.
 
 ```javascript
-number.fraction(4.75)  // 0.75
+fraction(4.75)  // 0.75
 ```
 
-### number.min(...values)
+### min(a, b)
 
-Return the smallest value.
+Return the smaller of two numbers.
 
 ```javascript
-number.min(3, 1, 4, 1, 5)  // 1
+min(3, 5)  // 3
 ```
 
-### number.max(...values)
+### max(a, b)
 
-Return the largest value.
+Return the larger of two numbers.
 
 ```javascript
-number.max(3, 1, 4, 1, 5)  // 5
+max(3, 5)  // 5
 ```
 
-### number.remainder(dividend, divisor)
+### remainder(dividend, divisor)
 
 Compute remainder.
 
 ```javascript
-number.remainder(17, 5)  // 2
+remainder(17, 5)  // 2
 ```

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/probe.md

@@ -0,0 +1,233 @@
+---
+title: "probe"
+description: "Runtime observability for actors"
+weight: 90
+type: "docs"
+---
+
+Runtime observability for actors. Register named probe functions on any actor and query them over HTTP while the program runs.
+
+```javascript
+var probe = use('probe')
+```
+
+The probe server starts automatically on the first `register()` call, listening on `127.0.0.1:9000`.
+
+## Registering Probes
+
+### probe.register(target, probes)
+
+Register a group of probe functions under a target name. Each probe is a function that receives an `args` record and returns a value.
+
+```javascript
+var probe = use('probe')
+
+var world = {
+  entities: [
+    {id: 1, name: "player", x: 10, y: 20, hp: 100},
+    {id: 2, name: "goblin", x: 55, y: 30, hp: 40}
+  ],
+  tick: 0
+}
+
+probe.register("game", {
+  state: function(args) {
+    return world
+  },
+  entities: function(args) {
+    return world.entities
+  },
+  entity: function(args) {
+    return find(world.entities, function(e) {
+      return e.id == args.id
+    })
+  }
+})
+
+probe.register("render", {
+  info: function(args) {
+    return {fps: 60, draw_calls: 128, batches: 12}
+  }
+})
+```
+
+A target is just a namespace — group related probes under the same target name. Register as many targets as you like; the server starts once and serves them all.
+
+## HTTP Endpoints
+
+All responses are JSON with an `ok` field.
+
+### GET /discover
+
+Lists all registered targets and their probe names. Designed for tooling — an LLM or dashboard can call this first to learn what's available, then query specific probes.
+
+```
+$ curl http://127.0.0.1:9000/discover
+```
+
+```json
+{
+  "ok": true,
+  "targets": {
+    "game": ["state", "entities", "entity"],
+    "render": ["info"]
+  }
+}
+```
+
+### POST /probe
+
+Call a single probe function by target and name. Optionally pass arguments.
+
+```
+$ curl -X POST -H "Content-Type: application/json" \
+  -d '{"target":"game","name":"state"}' \
+  http://127.0.0.1:9000/probe
+```
+
+```json
+{
+  "ok": true,
+  "result": {
+    "entities": [
+      {"id": 1, "name": "player", "x": 10, "y": 20, "hp": 100},
+      {"id": 2, "name": "goblin", "x": 55, "y": 30, "hp": 40}
+    ],
+    "tick": 4821
+  }
+}
+```
+
+With arguments:
+
+```
+$ curl -X POST -H "Content-Type: application/json" \
+  -d '{"target":"game","name":"entity","args":{"id":1}}' \
+  http://127.0.0.1:9000/probe
+```
+
+```json
+{
+  "ok": true,
+  "result": {"id": 1, "name": "player", "x": 10, "y": 20, "hp": 100}
+}
+```
+
+### POST /snapshot
+
+Call multiple probes in one request. Returns all results keyed by `target/name`.
+
+```
+$ curl -X POST -H "Content-Type: application/json" \
+  -d '{"probes":[{"target":"game","name":"state"},{"target":"render","name":"info"}]}' \
+  http://127.0.0.1:9000/snapshot
+```
+
+```json
+{
+  "ok": true,
+  "results": {
+    "game/state": {
+      "entities": [
+        {"id": 1, "name": "player", "x": 10, "y": 20, "hp": 100},
+        {"id": 2, "name": "goblin", "x": 55, "y": 30, "hp": 40}
+      ],
+      "tick": 4821
+    },
+    "render/info": {
+      "fps": 60,
+      "draw_calls": 128,
+      "batches": 12
+    }
+  }
+}
+```
+
+### Errors
+
+Unknown paths return 404:
+
+```json
+{"ok": false, "error": "not found"}
+```
+
+Unknown targets or probe names:
+
+```json
+{"ok": false, "error": "unknown probe: game/nonexistent"}
+```
+
+If a probe function disrupts:
+
+```json
+{"ok": false, "error": "probe failed"}
+```
+
+## Example
+
+A game actor with a simulation loop and probe observability:
+
+```javascript
+// game.ce
+var probe = use('probe')
+
+var state = {
+  entities: [
+    {id: 1, name: "player", x: 0, y: 0, hp: 100},
+    {id: 2, name: "enemy", x: 50, y: 50, hp: 60}
+  ],
+  frame: 0,
+  paused: false
+}
+
+probe.register("game", {
+  state: function(args) {
+    return state
+  },
+  entities: function(args) {
+    return state.entities
+  },
+  entity: function(args) {
+    return find(state.entities, function(e) {
+      return e.id == args.id
+    })
+  }
+})
+
+// game loop
+def tick = function(_) {
+  if (!state.paused) {
+    state.frame = state.frame + 1
+    // ... update entities, physics, AI ...
+  }
+  $delay(tick, 0.016)
+}
+$delay(tick, 0.016)
+```
+
+While the game runs, query it from a terminal:
+
+```
+$ curl -s http://127.0.0.1:9000/discover | jq .targets
+{
+  "game": ["state", "entities", "entity"]
+}
+
+$ curl -s -X POST -d '{"target":"game","name":"state"}' \
+  -H "Content-Type: application/json" \
+  http://127.0.0.1:9000/probe | jq .result.frame
+7834
+
+$ curl -s -X POST -d '{"target":"game","name":"entity","args":{"id":1}}' \
+  -H "Content-Type: application/json" \
+  http://127.0.0.1:9000/probe | jq .result
+{
+  "id": 1,
+  "name": "player",
+  "x": 142,
+  "y": 87,
+  "hp": 100
+}
+```
+
+Probes run inside the actor's normal turn, so the values are always consistent — never a half-updated frame.

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
@@ -70,18 +82,18 @@ text.search("hello world", "xyz")       // null
 text.search("hello hello", "hello", 1)  // 6
 ```
 
-### text.replace(text, target, replacement, limit)
+### text.replace(text, target, replacement, cap)
 
-Replace occurrences of `target` with `replacement`.
+Replace occurrences of `target` with `replacement`. If `cap` is not specified, replaces all occurrences.
 
 ```javascript
-text.replace("hello", "l", "L")      // "heLLo"
-text.replace("hello", "l", "L", 1)   // "heLlo"
+text.replace("hello", "l", "L")      // "heLLo" (replaces all)
+text.replace("hello", "l", "L", 1)   // "heLlo" (replaces first only)
 
 // With function
 text.replace("hello", "l", function(match, pos) {
   return pos == 2 ? "L" : match
-})  // "heLlo"
+})  // "heLLo" (replaces all by default)
 ```
 
 ### text.format(text, collection, transformer)
@@ -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/logging.md

@@ -0,0 +1,269 @@
+---
+title: "Logging"
+description: "Configurable channel-based logging with sinks"
+weight: 25
+type: "docs"
+---
+
+Logging in ƿit is channel-based. Any `log.X(value)` call writes to channel `"X"`. Channels are routed to **sinks** — named destinations that format and deliver log output to the console or to files.
+
+## Channels
+
+These channels are conventional:
+
+| Channel | Usage |
+|---------|-------|
+| `log.console(msg)` | General output |
+| `log.error(msg)` | Errors |
+| `log.warn(msg)` | Compiler diagnostics and warnings |
+| `log.system(msg)` | Internal system messages |
+| `log.build(msg)` | Per-file compile/link output |
+| `log.shop(msg)` | Package management internals |
+
+Any name works. `log.debug(msg)` creates channel `"debug"`, `log.perf(msg)` creates `"perf"`, and so on.
+
+```javascript
+log.console("server started on port 8080")
+log.error("connection refused")
+log.debug({query: "SELECT *", rows: 42})
+```
+
+Non-text values are JSON-encoded automatically.
+
+## Default Behavior
+
+With no configuration, a default sink routes `console` and `error` to the terminal in clean format. The `error` channel includes a stack trace by default:
+
+```
+server started on port 8080
+error: connection refused
+    at handle_request (server.ce:42:3)
+    at main (main.ce:5:1)
+```
+
+Clean format prints messages without actor ID or channel prefix. Error messages are prefixed with `error:`. Other formats (`pretty`, `bare`) include actor IDs and are available for debugging. Stack traces are always on for errors unless you explicitly configure a sink without them.
+
+Channels like `warn`, `build`, and `shop` are not routed to the terminal by default. Enable them with `pit log enable <channel>`.
+
+## Configuration
+
+Logging is configured in `.cell/log.toml`. Each `[sink.NAME]` section defines a sink.
+
+```toml
+[sink.terminal]
+type = "console"
+format = "bare"
+channels = ["console"]
+
+[sink.errors]
+type = "file"
+path = ".cell/logs/errors.jsonl"
+channels = ["error"]
+
+[sink.everything]
+type = "file"
+path = ".cell/logs/all.jsonl"
+channels = ["*"]
+exclude = ["console"]
+```
+
+### Sink fields
+
+| Field | Values | Description |
+|-------|--------|-------------|
+| `type` | `"console"`, `"file"` | Where output goes |
+| `format` | `"clean"`, `"pretty"`, `"bare"`, `"json"` | How output is formatted |
+| `channels` | array of names, or `["*"]` | Which channels this sink receives. Quote `'*'` on the CLI to prevent shell glob expansion. |
+| `exclude` | array of names | Channels to skip (useful with `"*"`) |
+| `stack` | array of channel names | Channels that capture a stack trace |
+| `path` | file path | Output file (file sinks only) |
+
+### Formats
+
+**clean** — CLI-friendly. No actor ID or channel prefix. Error channel messages are prefixed with `error:`. This is the default format.
+
+```
+server started on port 8080
+error: connection refused
+```
+
+**pretty** — human-readable, one line per message. Includes actor ID, channel, source location, and message.
+
+```
+[a3f12] [console] main.ce:5 server started
+```
+
+**bare** — minimal. Actor ID and message only.
+
+```
+[a3f12] server started
+```
+
+**json** — structured JSONL (one JSON object per line). Used for file sinks and machine consumption.
+
+```json
+{"actor_id":"a3f12...","timestamp":1702656000.5,"channel":"console","event":"server started","source":{"file":"main.ce","line":5,"col":3,"fn":"init"}}
+```
+
+## Log Records
+
+Every log call produces a record:
+
+```javascript
+{
+  actor_id: "a3f12...",       // full actor GUID
+  timestamp: 1702656000.5,    // seconds since epoch
+  channel: "console",         // channel name
+  event: "the message",       // value passed to log
+  source: {
+    file: "main.ce",
+    line: 5,
+    col: 3,
+    fn: "init"
+  }
+}
+```
+
+File sinks write one JSON-encoded record per line. Console sinks format the record according to their format setting.
+
+## Stack Traces
+
+The `error` channel captures stack traces by default. To enable stack traces for other channels, add a `stack` field to a sink — an array of channel names that should include a call stack.
+
+Via the CLI:
+
+```bash
+pit log add terminal console --channels=console,error,debug --stack=error,debug
+```
+
+Or in `log.toml`:
+
+```toml
+[sink.terminal]
+type = "console"
+format = "bare"
+channels = ["console", "error", "debug"]
+stack = ["error", "debug"]
+```
+
+Only channels listed in `stack` get stack traces. Other channels on the same sink print without one:
+
+```
+[a3f12] server started
+[a3f12] connection failed
+    at handle_request (server.ce:42:3)
+    at process (router.ce:18:5)
+    at main (main.ce:5:1)
+```
+
+With JSON format, a `stack` array is added to the record for channels that have stack capture enabled:
+
+```json
+{"actor_id":"a3f12...","channel":"error","event":"connection failed","source":{"file":"server.ce","line":42,"col":3,"fn":"handle_request"},"stack":[{"fn":"handle_request","file":"server.ce","line":42,"col":3},{"fn":"process","file":"router.ce","line":18,"col":5},{"fn":"main","file":"main.ce","line":5,"col":1}]}
+```
+
+Channels without `stack` configuration produce no stack field. Capturing stacks adds overhead — enable it for debugging, not production.
+
+## CLI
+
+The `pit log` command manages sinks and reads log files. See [CLI — pit log](/docs/cli/#pit-log) for the full reference.
+
+```bash
+pit log list                                           # show sinks
+pit log channels                                       # list channels with enabled/disabled status
+pit log enable warn                                    # enable a channel on the terminal sink
+pit log disable warn                                   # disable a channel
+pit log add terminal console --format=clean --channels=console
+pit log add dump file .cell/logs/dump.jsonl '--channels=*' --exclude=console
+pit log add debug console --channels=error,debug --stack=error,debug
+pit log remove terminal
+pit log read dump --lines=20 --channel=error
+pit log tail dump
+```
+
+### Channel toggling
+
+The `enable` and `disable` commands modify the terminal sink's channel list without touching other sink configuration. This is the easiest way to opt in to extra output:
+
+```bash
+pit log enable warn      # see compiler warnings
+pit log enable build     # see per-file compile/link output
+pit log disable warn     # hide warnings again
+```
+
+## Examples
+
+### Development setup
+
+Route console output to the terminal with minimal formatting. Send everything else to a structured log file for debugging.
+
+```toml
+[sink.terminal]
+type = "console"
+format = "bare"
+channels = ["console"]
+
+[sink.debug]
+type = "file"
+path = ".cell/logs/debug.jsonl"
+channels = ["*"]
+exclude = ["console"]
+```
+
+```javascript
+log.console("listening on :8080")   // -> terminal: [a3f12] listening on :8080
+log.error("bad request")            // -> debug.jsonl only
+log.debug({latency: 0.042})         // -> debug.jsonl only
+```
+
+### Separate error log
+
+Keep a dedicated error log alongside a full dump.
+
+```toml
+[sink.terminal]
+type = "console"
+format = "pretty"
+channels = ["console", "error", "system"]
+
+[sink.errors]
+type = "file"
+path = ".cell/logs/errors.jsonl"
+channels = ["error"]
+
+[sink.all]
+type = "file"
+path = ".cell/logs/all.jsonl"
+channels = ["*"]
+```
+
+### JSON console
+
+Output structured JSON to the console for piping into other tools.
+
+```toml
+[sink.json_out]
+type = "console"
+format = "json"
+channels = ["console", "error"]
+```
+
+```bash
+pit run myapp.ce | jq '.event'
+```
+
+### Reading logs
+
+```bash
+# Last 50 error entries
+pit log read errors --lines=50
+
+# Errors since a timestamp
+pit log read errors --since=1702656000
+
+# Filter a wildcard sink to one channel
+pit log read all --channel=debug --lines=10
+
+# Follow a log file in real time
+pit log tail all
+```

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 is an internal module: `use('internal/nota')`.
+
+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,6 +1,11 @@
-# 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
 
@@ -8,13 +13,14 @@ A package is a directory containing a `cell.toml` manifest:
 
 ```
 mypackage/
-├── cell.toml        # package manifest
+├── cell.toml         # package manifest
 ├── main.ce          # entry point (optional)
 ├── utils.cm         # module
 ├── helper/
 │   └── math.cm      # nested module
 ├── render.c         # C extension
-└── _internal.cm     # private module (underscore prefix)
+└── internal/
+    └── helpers.cm   # private module (internal/ only)
 ```
 
 ## cell.toml
@@ -38,11 +44,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
+3. **Core** — built-in ƿit modules
 
 ```javascript
 // In package 'myapp' with dependency: renderer = "gitea.pockle.world/john/renderer"
@@ -55,12 +61,12 @@ use('json')            // core module
 
 ### Private Modules
 
-Files starting with underscore are private:
+Files in the `internal/` directory are private to their package:
 
 ```javascript
-// _internal.cm is only accessible within the same package
-use('internal')       // OK from same package
-use('myapp/internal') // Error from other packages
+// internal/helpers.cm is only accessible within the same package
+use('internal/helpers')       // OK from same package
+use('myapp/internal/helpers') // Error from other packages
 ```
 
 ## Package Locators
@@ -85,7 +91,7 @@ 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 `~/.cell/`:
 
 ```
 ~/.cell/
@@ -99,11 +105,8 @@ Cell stores all packages in the **shop** at `~/.cell/`:
 │       └── john/
 │           └── work/
 │               └── mylib -> /Users/john/work/mylib
-├── lib/
-│   ├── local.dylib
-│   └── gitea_pockle_world_john_prosperon.dylib
 ├── build/
-│   └── <content-addressed cache>
+│   └── <content-addressed cache (bytecode, dylibs, manifests)>
 ├── cache/
 │   └── <downloaded zips>
 ├── lock.toml
@@ -134,20 +137,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,28 +159,28 @@ 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
 
-C files in a package are compiled into a dynamic library:
+C files in a package are compiled into per-file dynamic libraries stored in the content-addressed build cache:
 
 ```
 mypackage/
 ├── cell.toml
-├── render.c      # compiled to mypackage.dylib
-└── render.cm     # optional Cell wrapper
+├── render.c      # compiled to ~/.cell/build/<hash>
+└── physics.c     # compiled to ~/.cell/build/<hash>
 ```
 
-The library is named after the package and placed in `~/.cell/lib/`.
+Each `.c` file gets its own `.dylib` at a content-addressed path in `~/.cell/build/`. A per-package manifest maps module names to their dylib paths so the runtime can find them — see [Dylib Manifests](/docs/shop/#dylib-manifests). A `.c` file and `.cm` file with the same stem at the same scope is a build error — use distinct names.
 
-See [Writing C Modules](c-modules.md) for details.
+See [Writing C Modules](/docs/c-modules/) for details.
 
 ## Platform-Specific Files
 
@@ -190,4 +193,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/semantic-index.md

@@ -0,0 +1,343 @@
+---
+title: "Semantic Index"
+description: "Index and query symbols, references, and call sites in source files"
+weight: 55
+type: "docs"
+---
+
+ƿit includes a semantic indexer that extracts symbols, references, call sites, and imports from source files. The index powers the LSP (find references, rename) and is available as a CLI tool for scripting and debugging.
+
+## Overview
+
+The indexer walks the parsed AST without modifying it. It produces a JSON structure that maps every declaration, every reference to that declaration, and every call site in a file.
+
+```
+source → tokenize → parse → fold → index
+                                      ↓
+                              symbols, references,
+                              call sites, imports,
+                              exports, reverse refs
+```
+
+Two CLI commands expose this:
+
+| Command | Purpose |
+|---------|---------|
+| `pit index <file>` | Produce the full semantic index as JSON |
+| `pit explain` | Query the index for a specific symbol or position |
+
+## pit index
+
+Index a source file and print the result as JSON.
+
+```bash
+pit index <file.ce|file.cm>
+pit index <file> -o output.json
+```
+
+### Output
+
+The index contains these sections:
+
+| Section | Description |
+|---------|-------------|
+| `imports` | All `use()` calls with local name, module path, resolved filesystem path, and span |
+| `symbols` | Every declaration: vars, defs, functions, params |
+| `references` | Every use of a name, classified as read, write, or call |
+| `call_sites` | Every function call with callee, args count, and enclosing function |
+| `exports` | For `.cm` modules, the keys of the top-level `return` record |
+| `reverse_refs` | Inverted index: name to list of reference spans |
+
+### Example
+
+Given a file `graph.ce` with functions `make_node`, `connect`, and `build_graph`:
+
+```bash
+pit index graph.ce
+```
+
+```json
+{
+  "version": 1,
+  "path": "graph.ce",
+  "is_actor": true,
+  "imports": [
+    {"local_name": "json", "module_path": "json", "resolved_path": ".cell/packages/core/json.cm", "span": {"from_row": 2, "from_col": 0, "to_row": 2, "to_col": 22}}
+  ],
+  "symbols": [
+    {
+      "symbol_id": "graph.ce:make_node:fn",
+      "name": "make_node",
+      "kind": "fn",
+      "params": ["name", "kind"],
+      "doc_comment": "// A node in the graph.",
+      "decl_span": {"from_row": 6, "from_col": 0, "to_row": 8, "to_col": 1},
+      "scope_fn_nr": 0
+    }
+  ],
+  "references": [
+    {"node_id": 20, "name": "make_node", "ref_kind": "call", "span": {"from_row": 17, "from_col": 13, "to_row": 17, "to_col": 22}}
+  ],
+  "call_sites": [
+    {"node_id": 20, "callee": "make_node", "args_count": 2, "span": {"from_row": 17, "from_col": 22, "to_row": 17, "to_col": 40}}
+  ],
+  "exports": [],
+  "reverse_refs": {
+    "make_node": [
+      {"node_id": 20, "ref_kind": "call", "span": {"from_row": 17, "from_col": 13, "to_row": 17, "to_col": 22}}
+    ]
+  }
+}
+```
+
+### Symbol Kinds
+
+| Kind | Description |
+|------|-------------|
+| `fn` | Function (var or def with function value) |
+| `var` | Mutable variable |
+| `def` | Constant |
+| `param` | Function parameter |
+
+Each symbol has a `symbol_id` in the format `filename:name:kind` and a `decl_span` with `from_row`, `from_col`, `to_row`, `to_col` (0-based).
+
+### Reference Kinds
+
+| Kind | Description |
+|------|-------------|
+| `read` | Value is read |
+| `write` | Value is assigned |
+| `call` | Used as a function call target |
+
+### Module Exports
+
+For `.cm` files, the indexer detects the top-level `return` statement. If it returns a record literal, each key becomes an export linked to its symbol:
+
+```javascript
+// math_utils.cm
+var add = function(a, b) { return a + b }
+var sub = function(a, b) { return a - b }
+return {add: add, sub: sub}
+```
+
+```bash
+pit index math_utils.cm
+```
+
+The `exports` section will contain:
+
+```json
+[
+  {"name": "add", "symbol_id": "math_utils.cm:add:fn"},
+  {"name": "sub", "symbol_id": "math_utils.cm:sub:fn"}
+]
+```
+
+## pit explain
+
+Query the semantic index for a specific symbol or cursor position. This is the targeted query interface — instead of dumping the full index, it answers a specific question.
+
+```bash
+pit explain --span <file>:<line>:<col>
+pit explain --symbol <name> <file>...
+```
+
+### --span: What is at this position?
+
+Point at a line and column (0-based) to find out what symbol or reference is there.
+
+```bash
+pit explain --span demo.ce:6:4
+```
+
+If the position lands on a declaration, that symbol is returned along with all its references and call sites. If it lands on a reference, the indexer traces back to the declaration and returns the same information.
+
+The result includes:
+
+| Field | Description |
+|-------|-------------|
+| `symbol` | The resolved declaration (name, kind, params, doc comment, span) |
+| `reference` | The reference at the cursor, if the cursor was on a reference |
+| `references` | All references to this symbol across the file |
+| `call_sites` | All call sites for this symbol |
+| `imports` | The file's imports (for context) |
+
+```json
+{
+  "symbol": {
+    "name": "build_graph",
+    "symbol_id": "demo.ce:build_graph:fn",
+    "kind": "fn",
+    "params": [],
+    "doc_comment": "// Build a sample graph and return it."
+  },
+  "references": [
+    {"node_id": 71, "ref_kind": "call", "span": {"from_row": 39, "from_col": 12, "to_row": 39, "to_col": 23}}
+  ],
+  "call_sites": []
+}
+```
+
+### --symbol: Find a symbol by name
+
+Look up a symbol by name. Pass one file for a focused result, or multiple files (including shell globs) to search across them all:
+
+```bash
+pit explain --symbol connect demo.ce
+pit explain --symbol connect *.ce *.cm
+```
+
+```json
+{
+  "symbols": [
+    {
+      "name": "connect",
+      "symbol_id": "demo.ce:connect:fn",
+      "kind": "fn",
+      "params": ["from", "to", "label"],
+      "doc_comment": "// Connect two nodes with a labeled edge."
+    }
+  ],
+  "references": [
+    {"node_id": 29, "ref_kind": "call", "span": {"from_row": 21, "from_col": 2, "to_row": 21, "to_col": 9}},
+    {"node_id": 33, "ref_kind": "call", "span": {"from_row": 22, "from_col": 2, "to_row": 22, "to_col": 9}},
+    {"node_id": 37, "ref_kind": "call", "span": {"from_row": 23, "from_col": 2, "to_row": 23, "to_col": 9}}
+  ],
+  "call_sites": [
+    {"callee": "connect", "args_count": 3, "span": {"from_row": 21, "from_col": 9, "to_row": 21, "to_col": 29}},
+    {"callee": "connect", "args_count": 3, "span": {"from_row": 22, "from_col": 9, "to_row": 22, "to_col": 31}},
+    {"callee": "connect", "args_count": 3, "span": {"from_row": 23, "from_col": 9, "to_row": 23, "to_col": 29}}
+  ]
+}
+```
+
+This tells you: `connect` is a function taking `(from, to, label)`, declared on line 11, and called 3 times inside `build_graph`.
+
+## Programmatic Use
+
+The index and explain modules can be used directly from ƿit scripts:
+
+### Via shop (recommended)
+
+```javascript
+var shop = use('internal/shop')
+var idx = shop.index_file(path)
+```
+
+`shop.index_file` runs the full pipeline (tokenize, parse, index, resolve imports) and caches the result.
+
+### index.cm (direct)
+
+If you already have a parsed AST and tokens, use `index_ast` directly:
+
+```javascript
+var index_mod = use('index')
+var idx = index_mod.index_ast(ast, tokens, filename)
+```
+
+### explain.cm
+
+```javascript
+var explain_mod = use('explain')
+var expl = explain_mod.make(idx)
+
+// What is at line 10, column 5?
+var result = expl.at_span(10, 5)
+
+// Find all symbols named "connect"
+var result = expl.by_symbol("connect")
+
+// Get callers and callees of a symbol
+var chain = expl.call_chain("demo.ce:connect:fn", 2)
+```
+
+For cross-file queries:
+
+```javascript
+var result = explain_mod.explain_across([idx1, idx2, idx3], "connect")
+```
+
+## LSP Integration
+
+The semantic index powers these LSP features:
+
+| Feature | LSP Method | Description |
+|---------|------------|-------------|
+| Find References | `textDocument/references` | All references to the symbol under the cursor |
+| Rename | `textDocument/rename` | Rename a symbol and all its references |
+| Prepare Rename | `textDocument/prepareRename` | Validate that the cursor is on a renameable symbol |
+| Go to Definition | `textDocument/definition` | Jump to a symbol's declaration (index-backed with AST fallback) |
+
+These work automatically in any editor with ƿit LSP support. The index is rebuilt on every file change.
+
+## LLM / AI Assistance
+
+The semantic index is designed to give LLMs the context they need to read and edit ƿit code accurately. ƿit is not in any training set, so an LLM cannot rely on memorized patterns — it needs structured information about names, scopes, and call relationships. The commands below are the recommended way to provide that.
+
+### Understand a file before editing
+
+Before modifying a file, index it to see its structure:
+
+```bash
+pit index file.ce
+```
+
+This gives the LLM every declaration, every reference, every call site, and the import list with resolved paths. Key things to extract:
+
+- **`symbols`** — what functions exist, their parameters, and their doc comments. This is enough to understand the file's API without reading every line.
+- **`imports`** with `resolved_path` — which modules are used, and where they live on disk. The LLM can follow these paths to read dependency source when it needs to understand a called function. Imports without a `resolved_path` are C built-ins (like `json`) with no script source to read.
+- **`exports`** — for `.cm` modules, what the public API is. This tells the LLM what names other files can access.
+
+### Investigate a specific symbol
+
+When the LLM needs to rename, refactor, or understand a specific function:
+
+```bash
+pit explain --symbol update analysis.cm
+```
+
+This returns the declaration (with doc comment and parameter list), every reference, and every call site. The LLM can use this to:
+
+- **Rename safely** — the references list has exact spans for every use of the name.
+- **Understand callers** — `call_sites` shows where and how the function is called, including argument counts.
+- **Read the doc comment** — often enough to understand intent without reading the function body.
+
+### Investigate a cursor position
+
+When the LLM is looking at a specific line and column (e.g., from an error message or a user selection):
+
+```bash
+pit explain --span file.ce:17:4
+```
+
+This resolves whatever is at that position — declaration or reference — back to the underlying symbol, then returns all references and call sites. Useful for "what is this name?" queries.
+
+### Search across files
+
+To find a symbol across multiple files, pass them all:
+
+```bash
+pit explain --symbol connect *.ce *.cm
+pit explain --symbol send server.ce client.ce protocol.cm
+```
+
+This indexes each file and searches across all of them. The result merges all matching declarations, references, and call sites. Use this when the LLM needs to understand cross-file usage before making a change that touches multiple files.
+
+### Import resolution
+
+Every import in the index includes the original `module_path` (the string passed to `use()`). For script modules, it also includes `resolved_path` — the filesystem path the module resolves to. This lets the LLM follow dependency chains:
+
+```json
+{"local_name": "fd", "module_path": "fd", "resolved_path": ".cell/packages/core/fd.cm"}
+{"local_name": "json", "module_path": "json"}
+```
+
+An import without `resolved_path` is a C built-in — no script source to read.
+
+### Recommended workflow
+
+1. **Start with `pit index`** on the file to edit. Scan imports and symbols for an overview.
+2. **Use `pit explain --symbol`** to drill into any function the LLM needs to understand or modify. The doc comment and parameter list are usually sufficient.
+3. **Follow `resolved_path`** on imports when the LLM needs to understand a dependency — index or read the resolved file.
+4. **Before renaming**, use `pit explain --symbol` (or `--span`) to get all reference spans, then apply edits to each span.
+5. **For cross-file changes**, pass all affected files to `pit explain --symbol` to see the full picture before editing.

docs/shop.md

@@ -0,0 +1,233 @@
+---
+title: "Shop Architecture"
+description: "How the shop resolves, compiles, caches, and loads modules"
+weight: 35
+type: "docs"
+---
+
+The shop is the module resolution and loading engine behind `use()`. It handles finding modules, compiling them, caching the results, and loading C extensions. The shop lives in `internal/shop.cm`.
+
+## Startup Pipeline
+
+When `pit` runs a program, startup takes one of two paths:
+
+### Fast path (warm cache)
+
+```
+C runtime → engine.cm (from cache) → shop.cm → user program
+```
+
+The C runtime hashes the source of `internal/engine.cm` with BLAKE2 and looks up the hash in the content-addressed cache (`~/.cell/build/<hash>`). On a cache hit, engine.cm loads directly — no bootstrap involved.
+
+### Cold path (first run or cache cleared)
+
+```
+C runtime → bootstrap.cm → (seeds cache) → engine.cm (from cache) → shop.cm → user program
+```
+
+On a cache miss, the C runtime loads `boot/bootstrap.cm.mcode` (a pre-compiled seed). Bootstrap compiles engine.cm and the pipeline modules (tokenize, parse, fold, mcode, streamline) from source and caches the results. The C runtime then retries the engine cache lookup, which now succeeds.
+
+### Engine
+
+**engine.cm** is self-sufficient. It loads its own compilation pipeline from the content-addressed cache, with fallback to the pre-compiled seeds in `boot/`. It defines `analyze()` (source to AST), `compile_to_blob()` (AST to binary blob), and `use_core()` for loading core modules. It creates the actor runtime and loads shop.cm via `use_core('internal/shop')`.
+
+### Shop
+
+**shop.cm** receives its dependencies through the module environment — `analyze`, `run_ast_fn`, `use_cache`, `shop_path`, `runtime_env`, `content_hash`, `cache_path`, and others. It defines `Shop.use()`, which is the function behind every `use()` call in user code.
+
+### Cache invalidation
+
+All caching is content-addressed by BLAKE2 hash of the source. When any source file changes, its hash changes and the old cache entry is simply never looked up again. No manual invalidation is needed. To force a full rebuild, delete `~/.cell/build/`.
+
+## Module Resolution
+
+When `use('path')` is called from a package context, the shop resolves the module through a multi-layer search. Both the `.cm` script file and C symbol are resolved independently, and the one with the narrowest scope wins.
+
+### Resolution Order
+
+For a call like `use('sprite')` from package `myapp`:
+
+1. **Own package** — `~/.cell/packages/myapp/sprite.cm` and C symbol `js_myapp_sprite_use`
+2. **Aliased dependencies** — if `myapp/cell.toml` has `renderer = "gitea.pockle.world/john/renderer"`, checks `renderer/sprite.cm` and its C symbols
+3. **Core** — built-in core modules and internal C symbols
+
+For calls without a package context (from core modules), only core is searched.
+
+### Private Modules
+
+Paths starting with `internal/` are private to their package:
+
+```javascript
+use('internal/helpers')  // OK from within the same package
+// Cannot be accessed from other packages
+```
+
+### Explicit Package Imports
+
+Paths containing a dot in the first component are treated as explicit package references:
+
+```javascript
+use('gitea.pockle.world/john/renderer/sprite')
+// Resolves directly to the renderer package's sprite.cm
+```
+
+## Compilation and Caching
+
+Every module goes through a content-addressed caching pipeline. Cache keys are based on the inputs that affect the output artifact, so changing any relevant input automatically invalidates the cache.
+
+### Cache Hierarchy
+
+When loading a module, the shop checks (in order):
+
+1. **In-memory cache** — `use_cache[key]`, checked first on every `use()` call
+2. **Build-cache dylib** — content-addressed `.dylib` in `~/.cell/build/<hash>`, found via manifest (see [Dylib Manifests](#dylib-manifests))
+3. **Cached bytecode** — content-addressed in `~/.cell/build/<hash>` (no extension)
+4. **Internal symbols** — statically linked into the `cell` binary (fat builds)
+5. **Source compilation** — full pipeline: analyze, mcode, streamline, serialize
+
+Dylib resolution wins over internal symbols, so a built dylib can hot-patch a fat binary. Results from compilation are cached back to the content-addressed store for future loads.
+
+Each loading method (except the in-memory cache) can be individually enabled or disabled via `shop.toml` policy flags — see [Shop Configuration](#shop-configuration) below.
+
+### Content-Addressed Store
+
+The build cache at `~/.cell/build/` stores all compiled artifacts named by the BLAKE2 hash of their inputs:
+
+```
+~/.cell/build/
+├── a1b2c3d4...          # cached bytecode blob, object file, dylib, or manifest (no extension)
+└── ...
+```
+
+Every artifact type uses a unique salt appended to the content before hashing, so collisions between different artifact types are impossible:
+
+| Salt | Artifact |
+|------|----------|
+| `obj` | compiled C object file |
+| `dylib` | linked dynamic library |
+| `native` | native-compiled .cm dylib |
+| `mach` | mach bytecode blob |
+| `mcode` | mcode IR (JSON) |
+| `deps` | cached `cc -MM` dependency list |
+| `fail` | cached compilation failure marker |
+| `manifest` | package dylib manifest (JSON) |
+
+This scheme provides automatic cache invalidation: when source changes, its hash changes, and the old cache entry is simply never looked up again.
+
+### Failure Caching
+
+When a C file fails to compile (missing SDK headers, syntax errors, etc.), the build system writes a failure marker to the cache using the `fail` salt. On subsequent builds, the failure marker is found and the file is skipped immediately — no time wasted retrying files that can't compile. The failure marker is keyed on the same content as the compilation (command string + source content), so if the source changes or compiler flags change, the failure is automatically invalidated and compilation is retried.
+
+### Dylib Manifests
+
+Dylibs live at content-addressed paths (`~/.cell/build/<hash>`) that can only be computed by running the full build pipeline. To allow the runtime to find pre-built dylibs without invoking the build module, `cell build` writes a **manifest** for each package. The manifest is a JSON file mapping each C module to its `{file, symbol, dylib}` entry. The manifest path is itself content-addressed (BLAKE2 hash of the package name + `manifest` salt), so the runtime can compute it from the package name alone.
+
+At runtime, when `use()` needs a C module from another package, the shop reads the manifest to find the dylib path. This means `cell build` must be run before C modules from packages can be loaded.
+
+For native `.cm` dylibs, the cache content includes source, target, native mode marker, and sanitize flags, then uses the `native` salt. Changing any of those inputs produces a new cache path automatically.
+
+### Core Module Caching
+
+Core modules loaded via `use_core()` in engine.cm follow the same content-addressed pattern. On first use, a module is compiled from source and cached by the BLAKE2 hash of its source content. Subsequent loads with unchanged source hit the cache directly.
+
+User scripts (`.ce` files) are also cached. The first run compiles and caches; subsequent runs with unchanged source load from cache.
+
+## C Extension Resolution
+
+C extensions are resolved alongside script modules. A C module is identified by a symbol name derived from the package and file name:
+
+```
+package: gitea.pockle.world/john/prosperon
+file:    sprite.c
+symbol:  js_gitea_pockle_world_john_prosperon_sprite_use
+```
+
+### C Resolution Sources
+
+1. **Build-cache dylibs** — content-addressed dylibs in `~/.cell/build/<hash>`, found via per-package manifests written by `cell build`
+2. **Internal symbols** — statically linked into the `cell` binary (fat builds)
+
+Dylibs are checked first at each resolution scope, so a built dylib always wins over a statically linked symbol. This enables hot-patching fat binaries.
+
+### Name Collisions
+
+Having both a `.cm` script and a `.c` file with the same stem at the same scope is a **build error**. For example, `render.cm` and `render.c` in the same directory will fail. Use distinct names — e.g., `render.c` for the C implementation and `render_utils.cm` for the script wrapper.
+
+## Environment Injection
+
+When a module is loaded, the shop builds an `env` object that becomes the module's set of free variables. This includes:
+
+- **Runtime functions** — `logical`, `some`, `every`, `starts_with`, `ends_with`, `is_actor`, `log`, `send`, `fallback`, `parallel`, `race`, `sequence`
+- **Capability injections** — actor intrinsics like `$self`, `$delay`, `$start`, `$receiver`, `$fd`, etc.
+- **`use` function** — scoped to the module's package context
+
+The set of injected capabilities is controlled by `script_inject_for()`, which can be tuned per package or file.
+
+## Shop Configuration
+
+The shop reads an optional `shop.toml` file from the shop root (`~/.cell/shop.toml`). This file controls which loading methods are permitted through policy flags.
+
+### Policy Flags
+
+All flags default to `true`. Set a flag to `false` to disable that loading method.
+
+```toml
+[policy]
+allow_dylib = true     # per-file .dylib loading (requires dlopen)
+allow_static = true    # statically linked C symbols (fat builds)
+allow_mach = true      # pre-compiled .mach bytecode (lib/ and build cache)
+allow_compile = true   # on-the-fly source compilation
+```
+
+### Example Configurations
+
+**Production lockdown** — only use pre-compiled artifacts, never compile from source:
+
+```toml
+[policy]
+allow_compile = false
+```
+
+**Pure-script mode** — bytecode only, no native code:
+
+```toml
+[policy]
+allow_dylib = false
+allow_static = false
+```
+
+**No dlopen platforms** — static linking and bytecode only:
+
+```toml
+[policy]
+allow_dylib = false
+```
+
+If `shop.toml` is missing or has no `[policy]` section, all methods are enabled (default behavior).
+
+## Shop Directory Layout
+
+```
+~/.cell/
+├── packages/         # installed packages (directories and symlinks)
+│   └── core -> ...   # symlink to the ƿit core
+├── build/            # content-addressed cache (safe to delete anytime)
+│   ├── <hash>        # cached bytecode, object file, dylib, or manifest
+│   └── ...
+├── cache/            # downloaded package zip archives
+├── lock.toml         # installed package versions and commit hashes
+├── link.toml         # local development link overrides
+└── shop.toml         # optional shop configuration and policy flags
+```
+
+## Key Files
+
+| File | Role |
+|------|------|
+| `internal/bootstrap.cm` | Minimal cache seeder (cold start only) |
+| `internal/engine.cm` | Self-sufficient entry point: compilation pipeline, actor runtime, `use_core()` |
+| `internal/shop.cm` | Module resolution, compilation, caching, C extension loading |
+| `internal/os.c` | OS intrinsics: dylib ops, internal symbol lookup, embedded modules |
+| `package.cm` | Package directory detection, alias resolution, file listing |
+| `link.cm` | Development link management (link.toml read/write) |
+| `boot/*.cm.mcode` | Pre-compiled pipeline seeds (tokenize, parse, fold, mcode, streamline, bootstrap) |

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 `pit_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
+```