update

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

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

.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

.gitignore

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

Makefile

@@ -9,6 +9,8 @@
 CELL_SHOP = $(HOME)/.cell
 CELL_CORE_PACKAGE = $(CELL_SHOP)/packages/core
 
+maker: install
+
 makecell:
 	cell pack core -o cell
 	cp cell /opt/homebrew/bin/
@@ -56,7 +58,7 @@ static:
 # 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 setup build_bootstrap -Dbuildtype=debug -Db_sanitize=address
 	meson compile -C build_bootstrap
 	cp build_bootstrap/cell .
 	cp build_bootstrap/libcell_runtime.dylib .

archive/miniz.c

@@ -8,14 +8,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 = {
@@ -101,7 +101,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)

debug/js.c

@@ -1,8 +1,6 @@
 #include "cell.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])))
 
 // Compute the approximate size of a single JS value in memory.
@@ -15,8 +13,7 @@ JSC_CCALL(os_calc_mem,
   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));
+  /* atom_count and atom_size removed - atoms are now just strings */
   JS_SetPropertyStr(js,ret,"str_count",number2js(js,mu.str_count));
   JS_SetPropertyStr(js,ret,"str_size",number2js(js,mu.str_size));
   JS_SetPropertyStr(js,ret,"obj_count",number2js(js,mu.obj_count));
@@ -42,20 +39,22 @@ JSC_CCALL(os_calc_mem,
 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);
+  JSValue bytecode = JS_Compile(js, str2, strlen(str2), str);
+  if (JS_IsException(bytecode)) return bytecode;
+  ret = JS_Integrate(js, bytecode, JS_NULL);
 )
 
 // Compile a string of JavaScript code into a function object.
 JSC_SSCALL(js_compile,
   if (!str2) return JS_ThrowReferenceError(js, "Second argument should be the script.");
   if (!str) return JS_ThrowReferenceError(js, "First argument should be the name of the script.");
-  ret = JS_Eval(js, str2, strlen(str2), str, JS_EVAL_FLAG_COMPILE_ONLY | JS_EVAL_FLAG_BACKTRACE_BARRIER);
+  ret = JS_Compile(js, str2, strlen(str2), str);
 )
 
-// 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]);
+// Link compiled bytecode with environment and execute.
+JSC_CCALL(js_integrate,
+  JSValue env = (argc > 1 && !JS_IsNull(argv[1])) ? argv[1] : JS_NULL;
+  ret = JS_Integrate(js, argv[0], env);
 )
 
 // Compile a function object into a bytecode blob.
@@ -92,12 +91,10 @@ JSC_CCALL(js_fn_info,
 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, integrate, 2),
   MIST_FUNC_DEF(js, compile_blob, 1),
   MIST_FUNC_DEF(js, compile_unblob, 1),
   MIST_FUNC_DEF(js, disassemble, 1),

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,74 @@
+---
+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
+log.console("Hello, ƿit!")
+$stop()
+```
+
+```bash
+pit hello
+```
+
+## Language
+
+- [**ƿit Language**](/docs/language/) — syntax, types, and built-in functions
+- [**Actors and Modules**](/docs/actors/) — the execution model
+- [**Packages**](/docs/packages/) — code organization and sharing
+- [**Command Line**](/docs/cli/) — the `pit` tool
+- [**Writing C Modules**](/docs/c-modules/) — native extensions
+
+## Reference
+
+- [**Built-in Functions**](/docs/functions/) — intrinsics reference
+
+## Standard Library
+
+- [text](/docs/library/text/) — string manipulation
+- [number](/docs/library/number/) — numeric operations (functions are global: `floor()`, `max()`, etc.)
+- [array](/docs/library/array/) — array utilities
+- [object](/docs/library/object/) — object utilities
+- [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
+
+## Architecture
+
+ƿit programs are organized into **packages**. Each package contains:
+
+- **Modules** (`.cm`) — return a value, cached and frozen
+- **Actors** (`.ce`) — run independently, communicate via messages
+- **C files** (`.c`) — compiled to native libraries
+
+Actors never share memory. They communicate by sending messages, which are automatically serialized. This makes concurrent programming safe and predictable.
+
+## Installation
+
+```bash
+# Clone and bootstrap
+git clone https://gitea.pockle.world/john/cell
+cd cell
+make bootstrap
+```
+
+The ƿit shop is stored at `~/.pit/`.

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
@@ -62,10 +67,10 @@ An actor is a script that **does not return a value**. It runs as an independent
 // worker.ce
 log.console("Worker started")
 
-$on_message = function(msg) {
+$receiver(function(msg, reply) {
   log.console("Received:", msg)
   // Process message...
-}
+})
 ```
 
 **Key properties:**
@@ -177,11 +182,11 @@ $time_limit(my_requestor, 10)  // 10 second timeout
 
 ## Module Resolution
 
-When you call `use('name')`, Cell searches:
+When you call `use('name')`, ƿit searches:
 
 1. **Current package** — files relative to package root
-2. **Dependencies** — packages declared in `cell.toml`
-3. **Core** — built-in Cell modules
+2. **Dependencies** — packages declared in `pit.toml`
+3. **Core** — built-in ƿit modules
 
 ```javascript
 // From within package 'myapp':

docs/c-modules.md

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

docs/cli.md

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

@@ -0,0 +1,427 @@
+---
+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 make new objects. Some can take various types. All return null if their inputs are not suitable.
+
+### array
+
+`array(number)` — Make an array. All elements are initialized to null.
+
+`array(number, initial_value)` — Make an array. 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]
+```
+
+`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]
+```
+
+`array(record)` — Keys. Make an array containing all text keys in the record.
+
+`array(text)` — Split text into grapheme clusters.
+
+```javascript
+array("hello")  // ["h", "e", "l", "l", "o"]
+```
+
+`array(text, separator)` — Split text into an array of subtexts.
+
+`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
+
+`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
+
+`text(array, separator)` — Convert array to text. Elements are concatenated with the separator (default: empty 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"
+```
+
+`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
+
+`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.
+
+`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
+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.
+
+### 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.
+
+### 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.
+
+### 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.
+
+### 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.
+
+### sign(number)
+
+Returns -1, 0, or 1.
+
+### 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}]
+```
+
+### 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 (functions are global: `floor()`, `max()`, etc.)
-- [array](library/array.md) — array utilities
-- [object](library/object.md) — object utilities
-- [blob](library/blob.md) — binary data
-- [time](library/time.md) — time and dates
-- [math](library/math.md) — trigonometry and math
-- [json](library/json.md) — JSON encoding/decoding
-- [random](library/random.md) — random numbers
-
-## Architecture
-
-Cell programs are organized into **packages**. Each package contains:
-
-- **Modules** (`.cm`) — return a value, cached and frozen
-- **Actors** (`.ce`) — run independently, communicate via messages
-- **C files** (`.c`) — compiled to native libraries
-
-Actors never share memory. They communicate by sending messages, which are automatically serialized. This makes concurrent programming safe and predictable.
-
-## Installation
-
-```bash
-# Clone and bootstrap
-git clone https://gitea.pockle.world/john/cell
-cd cell
-make bootstrap
-```
-
-The Cell shop is stored at `~/.cell/`.

docs/kim.md

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

docs/language.md

@@ -1,6 +1,11 @@
-# Cell Language
+---
+title: "ƿit Language"
+description: "Syntax, types, operators, and built-in functions"
+weight: 10
+type: "docs"
+---
 
-Cell is a scripting language for actor-based programming. It combines a familiar syntax with a prototype-based object system and strict immutability semantics.
+ƿ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
 
@@ -13,7 +18,7 @@ def PI = 3.14159  // constant (cannot be reassigned)
 
 ### Data Types
 
-Cell has six fundamental types:
+ƿit has six fundamental types:
 
 - **number** — DEC64 decimal floating point (no rounding errors)
 - **text** — Unicode strings
@@ -49,7 +54,7 @@ null
 ["a", "b", "c"]
 
 // Objects
-{name: "cell", version: 1}
+{name: "pit", version: 1}
 {x: 10, y: 20}
 ```
 
@@ -108,7 +113,7 @@ while (condition) {
 break
 continue
 return value
-throw "error message"
+disrupt
 ```
 
 ### Functions
@@ -266,7 +271,7 @@ log.error("problem")     // error output
 
 ## Pattern Matching
 
-Cell supports regex patterns in string functions, but not standalone regex objects.
+ƿit supports regex patterns in string functions, but not standalone regex objects.
 
 ```javascript
 text.search("hello world", /world/)
@@ -275,14 +280,32 @@ replace("hello", /l/g, "L")
 
 ## Error Handling
 
-```javascript
-try {
-  riskyOperation()
-} catch (e) {
-  log.error(e)
-}
+ƿit uses `disrupt` and `disruption` for error handling. A `disrupt` signals that something went wrong. The `disruption` block attached to a function catches it.
 
-throw "something went wrong"
+```javascript
+var safe_divide = function(a, b) {
+  if (b == 0) disrupt
+  return a / b
+} disruption {
+  log.error("something went wrong")
+}
 ```
 
-If an actor has an uncaught error, it crashes.
+`disrupt` is a bare keyword — it does not carry a value. The `disruption` block knows that something went wrong, but not what.
+
+To test whether an operation disrupts:
+
+```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.

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,22 @@
+---
+title: "Standard Library"
+description: "ƿit standard library modules"
+weight: 90
+type: "docs"
+---
+
+ƿit includes a standard library of modules loaded with `use()`.
+
+| Module | Description |
+|--------|-------------|
+| [text](/docs/library/text/) | String 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 and manipulation |
+| [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 |
+
+Most numeric functions (`floor`, `max`, `abs`, etc.) are global intrinsics and do not require `use`. See [Built-in Functions](/docs/functions/) for the full list.

docs/library/array.md

@@ -1,4 +1,9 @@
-# array
+---
+title: "array"
+description: "Array creation and manipulation"
+weight: 30
+type: "docs"
+---
 
 The `array` function and its methods handle array creation and manipulation.
 
@@ -60,7 +65,6 @@ Split text into grapheme clusters.
 
 ```javascript
 array("hello")  // ["h", "e", "l", "l", "o"]
-array("👨‍👩‍👧")          // ["👨‍👩‍👧"]
 ```
 
 ### array(text, separator)

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.
 

docs/library/math.md

@@ -1,6 +1,11 @@
-# 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
@@ -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)

docs/library/number.md

@@ -1,4 +1,9 @@
-# number
+---
+title: "number"
+description: "Numeric conversion and operations"
+weight: 20
+type: "docs"
+---
 
 The `number` function and its methods handle numeric conversion and operations.
 

docs/library/object.md

@@ -1,4 +1,9 @@
-# object
+---
+title: "object"
+description: "Object creation and manipulation"
+weight: 40
+type: "docs"
+---
 
 The `object` function and related utilities handle object creation and manipulation.
 

docs/library/random.md

@@ -1,4 +1,9 @@
-# random
+---
+title: "random"
+description: "Random number generation"
+weight: 90
+type: "docs"
+---
 
 Random number generation.
 

docs/library/text.md

@@ -1,4 +1,9 @@
-# text
+---
+title: "text"
+description: "String conversion and manipulation"
+weight: 10
+type: "docs"
+---
 
 The `text` function and its methods handle string conversion and manipulation.
 
@@ -101,7 +106,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)
@@ -110,7 +115,6 @@ Get the Unicode codepoint of the first character.
 
 ```javascript
 text.codepoint("A")  // 65
-text.codepoint("😀")    // 128512
 ```
 
 ### 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.
 

docs/nota.md

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

docs/packages.md

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

docs/requestors.md

@@ -0,0 +1,176 @@
+---
+title: "Requestors"
+description: "Asynchronous work with requestors"
+weight: 25
+type: "docs"
+---
+
+Requestors are functions that encapsulate asynchronous work. They provide a structured way to compose callbacks, manage cancellation, and coordinate concurrent operations between actors.
+
+## What is a Requestor
+
+A requestor is a function with this signature:
+
+```javascript
+function my_requestor(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
+function fetch_data(callback, url) {
+  $contact(function(connection) {
+    $send(connection, {get: url}, function(response) {
+      callback(response)
+    })
+  }, {host: url, port: 80})
+  return function cancel() {
+    // clean up if needed
+  }
+}
+```
+
+A requestor that always succeeds immediately:
+
+```javascript
+function constant(callback, value) {
+  callback(42)
+}
+```
+
+A requestor that always fails:
+
+```javascript
+function broken(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) {
+    log.error(reason)
+  } else {
+    log.console(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) {
+    log.error("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
+function ask_worker(callback, task) {
+  $send(worker, task, function(reply) {
+    callback(reply)
+  })
+}
+
+var pipeline = sequence([
+  ask_worker,
+  process_result,
+  store_result
+])
+
+pipeline(function(stored) {
+  log.console("done")
+  $stop()
+}, {type: "compute", data: [1, 2, 3]})
+```

docs/spec/bytecode.md

@@ -0,0 +1,118 @@
+---
+title: "Bytecode VM"
+description: "Stack-based virtual machine"
+---
+
+## Overview
+
+The bytecode VM is a stack-based virtual machine. Instructions operate on an implicit operand stack, pushing and popping values. This is the original execution backend for ƿit.
+
+## Compilation Pipeline
+
+```
+Source → Tokenize → Parse (AST) → Bytecode → Link → Execute
+```
+
+The compiler emits `JSFunctionBytecode` objects containing opcode sequences, constant pools, and debug information.
+
+## Instruction Categories
+
+### Value Loading
+
+| Opcode | Description |
+|--------|-------------|
+| `push_i32` | Push a 32-bit immediate integer |
+| `push_const` | Push a value from the constant pool |
+| `null` | Push null |
+| `push_false` | Push false |
+| `push_true` | Push true |
+
+### Stack Manipulation
+
+| Opcode | Description |
+|--------|-------------|
+| `drop` | Remove top of stack |
+| `dup` | Duplicate top of stack |
+| `dup1` / `dup2` / `dup3` | Duplicate item at depth |
+| `swap` | Swap top two items |
+| `rot3l` / `rot3r` | Rotate top three items |
+| `insert2` / `insert3` | Insert top item deeper |
+| `nip` | Remove second item |
+
+### Variable Access
+
+| Opcode | Description |
+|--------|-------------|
+| `get_var` | Load variable by name (pre-link) |
+| `put_var` | Store variable by name (pre-link) |
+| `get_loc` / `put_loc` | Access local variable by index |
+| `get_arg` / `put_arg` | Access function argument by index |
+| `get_env_slot` / `set_env_slot` | Access closure variable (post-link) |
+| `get_global_slot` / `set_global_slot` | Access global variable (post-link) |
+
+Variable access opcodes are patched during linking. `get_var` instructions are rewritten to `get_loc`, `get_env_slot`, or `get_global_slot` depending on where the variable is resolved.
+
+### Arithmetic
+
+| Opcode | Description |
+|--------|-------------|
+| `add` / `sub` / `mul` / `div` | Basic arithmetic |
+| `mod` / `pow` | Modulo and power |
+| `neg` / `inc` / `dec` | Unary operations |
+| `add_loc` / `inc_loc` / `dec_loc` | Optimized local variable update |
+
+### Comparison and Logic
+
+| Opcode | Description |
+|--------|-------------|
+| `strict_eq` / `strict_neq` | Equality (ƿit uses strict only) |
+| `lt` / `lte` / `gt` / `gte` | Ordered comparison |
+| `not` / `lnot` | Logical / bitwise not |
+| `and` / `or` / `xor` | Bitwise operations |
+
+### Control Flow
+
+| Opcode | Description |
+|--------|-------------|
+| `goto` | Unconditional jump |
+| `if_true` / `if_false` | Conditional jump |
+| `goto8` / `goto16` | Short jumps (size-optimized) |
+| `if_true8` / `if_false8` | Short conditional jumps |
+| `catch` | Set exception handler |
+
+### Function Calls
+
+| Opcode | Description |
+|--------|-------------|
+| `call` | Call function with N arguments |
+| `tail_call` | Tail-call optimization |
+| `call_method` | Call method on object |
+| `return` | Return value from function |
+| `return_undef` | Return null from function |
+| `throw` | Throw exception (disrupt) |
+
+### Property Access
+
+| Opcode | Description |
+|--------|-------------|
+| `get_field` | Get named property |
+| `put_field` | Set named property |
+| `get_array_el` | Get computed property |
+| `put_array_el` | Set computed property |
+| `define_field` | Define property during object literal |
+
+### Object Creation
+
+| Opcode | Description |
+|--------|-------------|
+| `object` | Create new empty object |
+| `array_from` | Create array from stack values |
+
+## Bytecode Patching
+
+During the link/integrate phase, symbolic variable references are resolved to concrete access instructions. This is a critical optimization — the interpreter does not perform name lookups at runtime.
+
+A `get_var "x"` instruction becomes:
+- `get_loc 3` — if x is local variable at index 3
+- `get_env_slot 1, 5` — if x is captured from outer scope (depth 1, slot 5)
+- `get_global_slot 7` — if x is a global

docs/spec/dec64.md

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

docs/spec/gc.md

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

docs/spec/mach.md

@@ -0,0 +1,156 @@
+---
+title: "Register VM"
+description: "Register-based virtual machine (Mach)"
+---
+
+## Overview
+
+The Mach VM is a register-based virtual machine using 32-bit instructions. It is modeled after Lua's register VM — operands are register indices rather than stack positions, reducing instruction count and improving performance.
+
+## Instruction Formats
+
+All instructions are 32 bits wide. Four encoding formats are used:
+
+### iABC — Three-Register
+
+```
+[op: 8][A: 8][B: 8][C: 8]
+```
+
+Used for operations on three registers: `R(A) = R(B) op R(C)`.
+
+### iABx — Register + Constant
+
+```
+[op: 8][A: 8][Bx: 16]
+```
+
+Used for loading constants: `R(A) = K(Bx)`.
+
+### iAsBx — Register + Signed Offset
+
+```
+[op: 8][A: 8][sBx: 16]
+```
+
+Used for conditional jumps: if `R(A)` then jump by `sBx`.
+
+### isJ — Signed Jump
+
+```
+[op: 8][sJ: 24]
+```
+
+Used for unconditional jumps with a 24-bit signed offset.
+
+## Registers
+
+Each function frame has a fixed number of register slots, determined at compile time. Registers hold:
+
+- **R(0)** — `this` binding
+- **R(1)..R(arity)** — function arguments
+- **R(arity+1)..** — local variables and temporaries
+
+## Instruction Set
+
+### Loading
+
+| Opcode | Format | Description |
+|--------|--------|-------------|
+| `LOADK` | iABx | `R(A) = K(Bx)` — load from constant pool |
+| `LOADI` | iAsBx | `R(A) = sBx` — load small integer |
+| `LOADNULL` | iA | `R(A) = null` |
+| `LOADTRUE` | iA | `R(A) = true` |
+| `LOADFALSE` | iA | `R(A) = false` |
+| `MOVE` | iABC | `R(A) = R(B)` — register copy |
+
+### Arithmetic
+
+| Opcode | Format | Description |
+|--------|--------|-------------|
+| `ADD` | iABC | `R(A) = R(B) + R(C)` |
+| `SUB` | iABC | `R(A) = R(B) - R(C)` |
+| `MUL` | iABC | `R(A) = R(B) * R(C)` |
+| `DIV` | iABC | `R(A) = R(B) / R(C)` |
+| `MOD` | iABC | `R(A) = R(B) % R(C)` |
+| `POW` | iABC | `R(A) = R(B) ^ R(C)` |
+| `NEG` | iABC | `R(A) = -R(B)` |
+| `INC` | iABC | `R(A) = R(B) + 1` |
+| `DEC` | iABC | `R(A) = R(B) - 1` |
+
+### Comparison
+
+| Opcode | Format | Description |
+|--------|--------|-------------|
+| `EQ` | iABC | `R(A) = R(B) == R(C)` |
+| `NEQ` | iABC | `R(A) = R(B) != R(C)` |
+| `LT` | iABC | `R(A) = R(B) < R(C)` |
+| `LE` | iABC | `R(A) = R(B) <= R(C)` |
+| `GT` | iABC | `R(A) = R(B) > R(C)` |
+| `GE` | iABC | `R(A) = R(B) >= R(C)` |
+
+### Property Access
+
+| Opcode | Format | Description |
+|--------|--------|-------------|
+| `GETFIELD` | iABC | `R(A) = R(B)[K(C)]` — named property |
+| `SETFIELD` | iABC | `R(A)[K(B)] = R(C)` — set named property |
+| `GETINDEX` | iABC | `R(A) = R(B)[R(C)]` — computed property |
+| `SETINDEX` | iABC | `R(A)[R(B)] = R(C)` — set computed property |
+
+### Variable Resolution
+
+| Opcode | Format | Description |
+|--------|--------|-------------|
+| `GETNAME` | iABx | Unresolved variable (compiler placeholder) |
+| `GETINTRINSIC` | iABx | Global intrinsic / built-in |
+| `GETENV` | iABx | Module environment variable |
+| `GETUP` | iABC | `R(A) = UpFrame(B).slots[C]` — closure upvalue |
+| `SETUP` | iABC | `UpFrame(A).slots[B] = R(C)` — set closure upvalue |
+
+### Control Flow
+
+| Opcode | Format | Description |
+|--------|--------|-------------|
+| `JMP` | isJ | Unconditional jump |
+| `JMPTRUE` | iAsBx | Jump if `R(A)` is true |
+| `JMPFALSE` | iAsBx | Jump if `R(A)` is false |
+| `JMPNULL` | iAsBx | Jump if `R(A)` is null |
+
+### Function Calls
+
+| Opcode | Format | Description |
+|--------|--------|-------------|
+| `CALL` | iABC | Call `R(A)` with `B` args starting at `R(A+1)`, `C`=keep result |
+| `RETURN` | iA | Return `R(A)` |
+| `RETNIL` | — | Return null |
+| `CLOSURE` | iABx | Create closure from function pool entry `Bx` |
+
+### Object / Array
+
+| Opcode | Format | Description |
+|--------|--------|-------------|
+| `NEWOBJECT` | iA | `R(A) = {}` |
+| `NEWARRAY` | iABC | `R(A) = array(B)` |
+| `PUSH` | iABC | Push `R(B)` to array `R(A)` |
+
+## JSCodeRegister
+
+The compiled output for a function:
+
+```c
+struct JSCodeRegister {
+  uint16_t arity;           // argument count
+  uint16_t nr_slots;        // total register count
+  uint32_t cpool_count;     // constant pool size
+  JSValue *cpool;           // constant pool
+  uint32_t instr_count;     // instruction count
+  MachInstr32 *instructions; // 32-bit instruction array
+  uint32_t func_count;      // nested function count
+  JSCodeRegister **functions; // nested function table
+  JSValue name;             // function name
+  uint16_t disruption_pc;   // exception handler offset
+};
+```
+
+The constant pool holds all non-immediate values referenced by `LOADK` instructions: strings, large numbers, and other constants.

docs/spec/mcode.md

@@ -0,0 +1,90 @@
+---
+title: "Mcode IR"
+description: "JSON-based intermediate representation"
+---
+
+## Overview
+
+Mcode is a JSON-based intermediate representation that can be interpreted directly. It represents the same operations as the Mach register VM but uses string-based instruction dispatch rather than binary opcodes. Mcode is intended as an intermediate step toward native code compilation.
+
+## Pipeline
+
+```
+Source → Tokenize → Parse (AST) → Mcode (JSON) → Interpret
+                                                → Compile to Mach (planned)
+                                                → Compile to native (planned)
+```
+
+Mcode is produced by the `JS_Mcode` compiler pass, which emits a cJSON tree. The mcode interpreter walks this tree directly, dispatching on instruction name strings.
+
+## JSMCode Structure
+
+```c
+struct JSMCode {
+  uint16_t nr_args;        // argument count
+  uint16_t nr_slots;       // register count
+  cJSON **instrs;          // pre-flattened instruction array
+  uint32_t instr_count;    // number of instructions
+
+  struct {
+    const char *name;      // label name
+    uint32_t index;        // instruction index
+  } *labels;
+  uint32_t label_count;
+
+  struct JSMCode **functions; // nested functions
+  uint32_t func_count;
+
+  cJSON *json_root;        // keeps JSON alive
+  const char *name;        // function name
+  const char *filename;    // source file
+  uint16_t disruption_pc;  // exception handler offset
+};
+```
+
+## Instruction Format
+
+Each instruction is a JSON array. The first element is the instruction name (string), followed by operands:
+
+```json
+["LOADK", 0, 42]
+["ADD", 2, 0, 1]
+["JMPFALSE", 3, "else_label"]
+["CALL", 0, 2, 1]
+```
+
+The instruction set mirrors the Mach VM opcodes — same operations, same register semantics, but with string dispatch instead of numeric opcodes.
+
+## Labels
+
+Control flow uses named labels instead of numeric offsets:
+
+```json
+["LABEL", "loop_start"]
+["ADD", 1, 1, 2]
+["JMPFALSE", 3, "loop_end"]
+["JMP", "loop_start"]
+["LABEL", "loop_end"]
+```
+
+Labels are collected into a name-to-index map during loading, enabling O(1) jump resolution.
+
+## Differences from Mach
+
+| Property | Mcode | Mach |
+|----------|-------|------|
+| Instructions | cJSON arrays | 32-bit binary |
+| Dispatch | String comparison | Switch on opcode byte |
+| Constants | Inline in JSON | Separate constant pool |
+| Jump targets | Named labels | Numeric offsets |
+| Memory | Heap (cJSON nodes) | Off-heap (malloc) |
+
+## Purpose
+
+Mcode serves as an inspectable, debuggable intermediate format:
+
+- **Human-readable** — the JSON representation can be printed and examined
+- **Language-independent** — any tool that produces the correct JSON can target the ƿit runtime
+- **Compilation target** — the Mach compiler can consume mcode as input, and future native code generators can work from the same representation
+
+The cost of string-based dispatch makes mcode slower than the binary Mach VM, so it is primarily useful during development and as a compilation intermediate rather than for production execution.

docs/spec/objects.md

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

docs/spec/stone.md

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

docs/spec/values.md

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

docs/wota.md

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

fash.c

@@ -0,0 +1,93 @@
+/*
+  Fash64: Douglas Crockford (2017-02-02)
+  64-bit hash that uses the high 64 bits of a 128-bit product for feedback.
+
+  Notes:
+  - Requires a way to get the high half of a 64x64->128 multiply.
+  - Uses __uint128_t when available; otherwise uses MSVC _umul128.
+*/
+
+#include <stdint.h>
+#include <stddef.h>
+
+typedef struct fash64_state {
+  uint64_t result;
+  uint64_t sum;
+} fash64_state;
+
+enum {
+  FASH64_PRIME_11 = 11111111111111111027ull,
+  FASH64_PRIME_8  = 8888888888888888881ull,
+  FASH64_PRIME_3  = 3333333333333333271ull
+};
+
+static inline void fash64_mul_hi_lo(uint64_t a, uint64_t b, uint64_t *hi, uint64_t *lo)
+{
+#if defined(__SIZEOF_INT128__)
+  __uint128_t p = (__uint128_t)a * (__uint128_t)b;
+  *lo = (uint64_t)p;
+  *hi = (uint64_t)(p >> 64);
+#elif defined(_MSC_VER) && defined(_M_X64)
+  *lo = _umul128(a, b, hi);
+#else
+  /* Portable fallback (no 128-bit type, no _umul128). */
+  uint64_t a0 = (uint32_t)a;
+  uint64_t a1 = a >> 32;
+  uint64_t b0 = (uint32_t)b;
+  uint64_t b1 = b >> 32;
+
+  uint64_t p00 = a0 * b0;
+  uint64_t p01 = a0 * b1;
+  uint64_t p10 = a1 * b0;
+  uint64_t p11 = a1 * b1;
+
+  uint64_t mid = (p00 >> 32) + (uint32_t)p01 + (uint32_t)p10;
+  *lo = (p00 & 0xffffffffull) | (mid << 32);
+  *hi = p11 + (p01 >> 32) + (p10 >> 32) + (mid >> 32);
+#endif
+}
+
+static inline void fash64_begin(fash64_state *s)
+{
+  s->result = (uint64_t)FASH64_PRIME_8;
+  s->sum = (uint64_t)FASH64_PRIME_3;
+}
+
+static inline void fash64_word(fash64_state *s, uint64_t word)
+{
+  uint64_t high, low;
+  uint64_t mixed = s->result ^ word;
+
+  fash64_mul_hi_lo(mixed, (uint64_t)FASH64_PRIME_11, &high, &low);
+
+  s->sum += high;
+  s->result = low ^ s->sum;
+}
+
+static inline void fash64_block(fash64_state *s, const uint64_t *block, size_t word_count)
+{
+  for (size_t i = 0; i < word_count; i++) fash64_word(s, block[i]);
+}
+
+static inline uint64_t fash64_end(const fash64_state *s)
+{
+  return s->result;
+}
+
+/* Convenience one-shot helper */
+static inline uint64_t fash64_hash_words(const uint64_t *words, size_t word_count, uint64_t extra_word)
+{
+  fash64_state s;
+  fash64_begin(&s);
+  fash64_block(&s, words, word_count);
+  fash64_word(&s, extra_word);
+  return fash64_end(&s);
+}
+
+static inline uint64_t fash64_hash_one(uint64_t word)
+{
+  uint64_t high, low;
+  uint64_t mixed = (uint64_t)FASH64_PRIME_8 ^ word;
+  fash64_mul_hi_lo(mixed, (uint64_t)FASH64_PRIME_11, &high, &low);
+  return low ^ ((uint64_t)FASH64_PRIME_3 + high);
+}

fd.c

@@ -50,7 +50,7 @@ JSC_SCALL(fd_open,
     mode_t mode = 0644;
     
     // Parse optional flags argument
-    if (argc > 1 && JS_IsString(argv[1])) {
+    if (argc > 1 && JS_IsText(argv[1])) {
         const char *flag_str = JS_ToCString(js, argv[1]);
         flags = 0;
         
@@ -78,7 +78,7 @@ JSC_CCALL(fd_write,
     
     size_t len;
     ssize_t wrote;
-    if (JS_IsString(argv[1])) {
+    if (JS_IsText(argv[1])) {
         const char *data = JS_ToCStringLen(js, &len, argv[1]);
         if (!data) return JS_EXCEPTION;
         wrote = write(fd, data, len);
@@ -276,7 +276,7 @@ JSC_SCALL(fd_mkdir,
 JSC_SCALL(fd_mv,
     if (argc < 2)
         ret = JS_ThrowTypeError(js, "fd.mv requires 2 arguments: old path and new path");
-    else if (!JS_IsString(argv[1]))
+    else if (!JS_IsText(argv[1]))
         ret = JS_ThrowTypeError(js, "second argument must be a string (new path)");
     else {
         const char *new_path = JS_ToCString(js, argv[1]);
@@ -289,7 +289,7 @@ JSC_SCALL(fd_mv,
 JSC_SCALL(fd_symlink,
     if (argc < 2)
         ret = JS_ThrowTypeError(js, "fd.symlink requires 2 arguments: target and link path");
-    else if (!JS_IsString(argv[1]))
+    else if (!JS_IsText(argv[1]))
         ret = JS_ThrowTypeError(js, "second argument must be a string (link path)");
     else {
         const char *link_path = JS_ToCString(js, argv[1]);

fd_playdate.c

@@ -39,7 +39,7 @@ JSC_SCALL(fd_open,
     FileOptions flags = kFileRead;
     
     // Parse optional flags argument
-    if (argc > 1 && JS_IsString(argv[1])) {
+    if (argc > 1 && JS_IsText(argv[1])) {
         const char *flag_str = JS_ToCString(js, argv[1]);
         flags = 0;
         
@@ -70,7 +70,7 @@ JSC_CCALL(fd_write,
     
     size_t len;
     int wrote;
-    if (JS_IsString(argv[1])) {
+    if (JS_IsText(argv[1])) {
         const char *data = JS_ToCStringLen(js, &len, argv[1]);
         if (!data) return JS_EXCEPTION;
         wrote = pd_file->write(fd, data, (unsigned int)len);
@@ -202,7 +202,7 @@ JSC_SCALL(fd_mkdir,
 JSC_SCALL(fd_mv,
     if (argc < 2)
         ret = JS_ThrowTypeError(js, "fd.mv requires 2 arguments: old path and new path");
-    else if (!JS_IsString(argv[1]))
+    else if (!JS_IsText(argv[1]))
         ret = JS_ThrowTypeError(js, "second argument must be a string (new path)");
     else {
         const char *new_path = JS_ToCString(js, argv[1]);
@@ -216,7 +216,7 @@ JSC_SCALL(fd_mv,
 
 JSC_SCALL(fd_symlink,
     // Not supported
-    if (argc >= 2 && JS_IsString(argv[1])) {
+    if (argc >= 2 && JS_IsText(argv[1])) {
         // consume arg
         JS_FreeCString(js, JS_ToCString(js, argv[1])); 
     }

gc_plan.md

@@ -0,0 +1,403 @@
+# Plan: Complete Copying GC Implementation
+
+## Overview
+
+Remove reference counting (DupValue/FreeValue) entirely and complete the Cheney copying garbage collector. Each JSContext will use bump allocation from a heap block, and when out of memory, request a new heap from JSRuntime's buddy allocator and copy live objects to the new heap.
+
+## Target Architecture (from docs/memory.md)
+
+### Object Types (simplified from current):
+
+**Type 0 - Array**: `{ header, length, elements[] }`
+**Type 1 - Blob**: `{ header, length, bits[] }`
+**Type 2 - Text**: `{ header, length_or_hash, packed_chars[] }`
+**Type 3 - Record**: `{ header, prototype, length, key_value_pairs[] }`
+**Type 4 - Function**: `{ header, code_ptr, outer_frame_ptr }` - 3 words only, always stone
+**Type 5 - Frame**: `{ header, function_ptr, caller_ptr, ret_addr, args[], closure_vars[], local_vars[], temps[] }`
+**Type 6 - Code**: Lives in immutable memory only, never copied
+**Type 7 - Forward**: Object has moved; cap56 contains new address
+
+### Key Design Points:
+- **JSFunction** is just a pointer to code and a pointer to the frame that created it (3 words)
+- **Closure variables live in frames** - when a function returns, its frame is "reduced" to just the closure variables
+- **Code objects are immutable** - stored in stone memory, never copied during GC
+- **Frame reduction**: When a function returns, `caller` is set to zero, signaling the frame can be shrunk
+
+## Current State (needs refactoring)
+
+1. **Partial Cheney GC exists** at `source/quickjs.c:1844-2030`: `ctx_gc`, `gc_copy_value`, `gc_scan_object`
+2. **744 calls to JS_DupValue/JS_FreeValue** scattered throughout (currently undefined, causing compilation errors)
+3. **Current JSFunction** is bloated (has kind, name, union of cfunc/bytecode/bound) - needs simplification
+4. **Current JSVarRef** is a separate object - should be eliminated, closures live in frames
+5. **Bump allocator** in `js_malloc` (line 1495) with `heap_base`/`heap_free`/`heap_end`
+6. **Buddy allocator** for memory blocks (lines 1727-1837)
+7. **Header offset inconsistency** - some structs have header at offset 0, some at offset 8
+
+## Implementation Steps
+
+### Phase 1: Define No-Op DupValue/FreeValue (To Enable Compilation)
+
+Add these near line 100 in `source/quickjs.c`:
+
+```c
+/* Copying GC - no reference counting needed */
+#define JS_DupValue(ctx, v) (v)
+#define JS_FreeValue(ctx, v) ((void)0)
+#define JS_DupValueRT(rt, v) (v)
+#define JS_FreeValueRT(rt, v) ((void)0)
+```
+
+This makes the code compile while keeping existing call sites (they become no-ops).
+
+### Phase 2: Standardize Object Headers (offset 0)
+
+Remove `JSGCObjectHeader` (ref counting remnant) and put `objhdr_t` at offset 0:
+
+```c
+typedef struct JSArray {
+  objhdr_t hdr;      // offset 0
+  word_t length;
+  JSValue values[];
+} JSArray;
+
+typedef struct JSRecord {
+  objhdr_t hdr;      // offset 0
+  JSRecord *proto;
+  word_t length;
+  slot slots[];
+} JSRecord;
+
+typedef struct JSText {
+  objhdr_t hdr;      // offset 0
+  word_t length;     // pretext: length, text: hash
+  word_t packed[];
+} JSText;
+
+typedef struct JSBlob {
+  objhdr_t hdr;      // offset 0
+  word_t length;
+  uint8_t bits[];
+} JSBlob;
+
+/* Simplified JSFunction per memory.md - 3 words */
+typedef struct JSFunction {
+  objhdr_t hdr;           // offset 0, always stone
+  JSCode *code;           // pointer to immutable code object
+  struct JSFrame *outer;  // frame that created this function
+} JSFunction;
+
+/* JSFrame per memory.md */
+typedef struct JSFrame {
+  objhdr_t hdr;           // offset 0
+  JSFunction *function;   // function being executed
+  struct JSFrame *caller; // calling frame (NULL = reduced/returned)
+  word_t ret_addr;        // return instruction address
+  JSValue slots[];        // args, closure vars, locals, temps
+} JSFrame;
+
+/* JSCode - always in immutable (stone) memory */
+typedef struct JSCode {
+  objhdr_t hdr;           // offset 0, always stone
+  word_t arity;           // max number of inputs
+  word_t frame_size;      // capacity of activation frame
+  word_t closure_size;    // reduced capacity for returned frames
+  word_t entry_point;     // address to begin execution
+  word_t disruption_point;// address of disruption clause
+  uint8_t bytecode[];     // actual bytecode
+} JSCode;
+```
+
+### Phase 3: Complete gc_object_size for All Types
+
+Update `gc_object_size` (line 1850) to read header at offset 0:
+
+```c
+static size_t gc_object_size(void *ptr) {
+  objhdr_t hdr = *(objhdr_t*)ptr;  // Header at offset 0
+  uint8_t type = objhdr_type(hdr);
+  uint64_t cap = objhdr_cap56(hdr);
+
+  switch (type) {
+  case OBJ_ARRAY:
+    return sizeof(JSArray) + cap * sizeof(JSValue);
+  case OBJ_BLOB:
+    return sizeof(JSBlob) + (cap + 7) / 8;  // cap is bits
+  case OBJ_TEXT:
+    return sizeof(JSText) + ((cap + 1) / 2) * sizeof(uint64_t);
+  case OBJ_RECORD:
+    return sizeof(JSRecord) + (cap + 1) * sizeof(slot);  // cap is mask
+  case OBJ_FUNCTION:
+    return sizeof(JSFunction);  // 3 words
+  case OBJ_FRAME:
+    return sizeof(JSFrame) + cap * sizeof(JSValue);  // cap is slot count
+  case OBJ_CODE:
+    return 0;  // Code is never copied (immutable)
+  default:
+    return 64;  // Conservative fallback
+  }
+}
+```
+
+### Phase 4: Complete gc_scan_object for All Types
+
+Update `gc_scan_object` (line 1924):
+
+```c
+static void gc_scan_object(JSContext *ctx, void *ptr, uint8_t **to_free, uint8_t *to_end) {
+  objhdr_t hdr = *(objhdr_t*)ptr;
+  uint8_t type = objhdr_type(hdr);
+
+  switch (type) {
+  case OBJ_ARRAY: {
+    JSArray *arr = (JSArray*)ptr;
+    for (uint32_t i = 0; i < arr->length; i++) {
+      arr->values[i] = gc_copy_value(ctx, arr->values[i], to_free, to_end);
+    }
+    break;
+  }
+  case OBJ_RECORD: {
+    JSRecord *rec = (JSRecord*)ptr;
+    // Copy prototype
+    if (rec->proto) {
+      JSValue proto_val = JS_MKPTR(rec->proto);
+      proto_val = gc_copy_value(ctx, proto_val, to_free, to_end);
+      rec->proto = (JSRecord*)JS_VALUE_GET_PTR(proto_val);
+    }
+    // Copy table entries
+    uint32_t mask = objhdr_cap56(rec->hdr);
+    for (uint32_t i = 1; i <= mask; i++) {  // Skip slot 0
+      JSValue k = rec->slots[i].key;
+      if (!rec_key_is_empty(k) && !rec_key_is_tomb(k)) {
+        rec->slots[i].key = gc_copy_value(ctx, k, to_free, to_end);
+        rec->slots[i].value = gc_copy_value(ctx, rec->slots[i].value, to_free, to_end);
+      }
+    }
+    break;
+  }
+  case OBJ_FUNCTION: {
+    JSFunction *func = (JSFunction*)ptr;
+    // Code is immutable, don't copy - but outer frame needs copying
+    if (func->outer) {
+      JSValue outer_val = JS_MKPTR(func->outer);
+      outer_val = gc_copy_value(ctx, outer_val, to_free, to_end);
+      func->outer = (JSFrame*)JS_VALUE_GET_PTR(outer_val);
+    }
+    break;
+  }
+  case OBJ_FRAME: {
+    JSFrame *frame = (JSFrame*)ptr;
+    // Copy function pointer
+    if (frame->function) {
+      JSValue func_val = JS_MKPTR(frame->function);
+      func_val = gc_copy_value(ctx, func_val, to_free, to_end);
+      frame->function = (JSFunction*)JS_VALUE_GET_PTR(func_val);
+    }
+    // Copy caller (unless NULL = reduced frame)
+    if (frame->caller) {
+      JSValue caller_val = JS_MKPTR(frame->caller);
+      caller_val = gc_copy_value(ctx, caller_val, to_free, to_end);
+      frame->caller = (JSFrame*)JS_VALUE_GET_PTR(caller_val);
+    }
+    // Copy all slots (args, closure vars, locals, temps)
+    uint32_t slot_count = objhdr_cap56(frame->hdr);
+    for (uint32_t i = 0; i < slot_count; i++) {
+      frame->slots[i] = gc_copy_value(ctx, frame->slots[i], to_free, to_end);
+    }
+    break;
+  }
+  case OBJ_TEXT:
+  case OBJ_BLOB:
+  case OBJ_CODE:
+    // No internal references to scan
+    break;
+  }
+}
+```
+
+### Phase 5: Fix gc_copy_value Forwarding
+
+Update `gc_copy_value` (line 1883) for offset 0 headers:
+
+```c
+static JSValue gc_copy_value(JSContext *ctx, JSValue v, uint8_t **to_free, uint8_t *to_end) {
+  if (!JS_IsPtr(v)) return v;  // Immediate value
+
+  void *ptr = JS_VALUE_GET_PTR(v);
+
+  // Stone memory - don't copy (includes Code objects)
+  objhdr_t hdr = *(objhdr_t*)ptr;
+  if (objhdr_s(hdr)) return v;
+
+  // Check if in current heap
+  if ((uint8_t*)ptr < ctx->heap_base || (uint8_t*)ptr >= ctx->heap_end)
+    return v;  // External allocation
+
+  // Already forwarded?
+  if (objhdr_type(hdr) == OBJ_FORWARD) {
+    void *new_ptr = (void*)(uintptr_t)objhdr_cap56(hdr);
+    return JS_MKPTR(new_ptr);
+  }
+
+  // Copy object to new space
+  size_t size = gc_object_size(ptr);
+  void *new_ptr = *to_free;
+  *to_free += size;
+  memcpy(new_ptr, ptr, size);
+
+  // Leave forwarding pointer in old location
+  *(objhdr_t*)ptr = objhdr_make((uint64_t)(uintptr_t)new_ptr, OBJ_FORWARD, 0, 0, 0, 0);
+
+  return JS_MKPTR(new_ptr);
+}
+```
+
+### Phase 6: Complete GC Root Tracing
+
+Update `ctx_gc` (line 1966) to trace all roots including JSGCRef:
+
+```c
+static int ctx_gc(JSContext *ctx) {
+  // ... existing setup code ...
+
+  // Copy roots: global object, class prototypes, etc. (existing)
+  ctx->global_obj = gc_copy_value(ctx, ctx->global_obj, &to_free, to_end);
+  ctx->global_var_obj = gc_copy_value(ctx, ctx->global_var_obj, &to_free, to_end);
+  // ... other existing root copying ...
+
+  // Copy GC root stack (JS_PUSH_VALUE/JS_POP_VALUE)
+  for (JSGCRef *ref = ctx->top_gc_ref; ref; ref = ref->prev) {
+    ref->val = gc_copy_value(ctx, ref->val, &to_free, to_end);
+  }
+
+  // Copy GC root list (JS_AddGCRef/JS_DeleteGCRef)
+  for (JSGCRef *ref = ctx->last_gc_ref; ref; ref = ref->prev) {
+    ref->val = gc_copy_value(ctx, ref->val, &to_free, to_end);
+  }
+
+  // Copy current exception
+  ctx->current_exception = gc_copy_value(ctx, ctx->current_exception, &to_free, to_end);
+
+  // Cheney scan (existing)
+  // ...
+}
+```
+
+### Phase 7: Trigger GC on Allocation Failure
+
+Update `js_malloc` (line 1495):
+
+```c
+void *js_malloc(JSContext *ctx, size_t size) {
+  size = (size + 7) & ~7;  // Align to 8 bytes
+
+  if ((uint8_t*)ctx->heap_free + size > (uint8_t*)ctx->heap_end) {
+    if (ctx_gc(ctx) < 0) {
+      JS_ThrowOutOfMemory(ctx);
+      return NULL;
+    }
+    // Retry after GC
+    if ((uint8_t*)ctx->heap_free + size > (uint8_t*)ctx->heap_end) {
+      JS_ThrowOutOfMemory(ctx);
+      return NULL;
+    }
+  }
+
+  void *ptr = ctx->heap_free;
+  ctx->heap_free = (uint8_t*)ctx->heap_free + size;
+  return ptr;
+}
+```
+
+### Phase 8: Frame Reduction (for closures)
+
+When a function returns, "reduce" its frame to just closure variables:
+
+```c
+static void reduce_frame(JSContext *ctx, JSFrame *frame) {
+  if (frame->caller == NULL) return;  // Already reduced
+
+  JSCode *code = frame->function->code;
+  uint32_t closure_size = code->closure_size;
+
+  // Shrink capacity to just closure variables
+  frame->hdr = objhdr_make(closure_size, OBJ_FRAME, 0, 0, 0, 0);
+  frame->caller = NULL;  // Signal: frame is reduced
+}
+```
+
+### Phase 9: Remove Unused Reference Counting Code
+
+Delete:
+- `gc_decref`, `gc_decref_child` functions
+- `gc_scan_incref_child`, `gc_scan_incref_child2` functions
+- `JS_GCPhaseEnum`, `gc_phase` fields
+- `JSGCObjectHeader` struct (merge into objhdr_t)
+- `ref_count` fields from any remaining structs
+- `mark_function_children_decref` function
+- All `free_*` functions that rely on ref counting
+
+## Files to Modify
+
+1. **source/quickjs.c** - Main implementation:
+   - Add DupValue/FreeValue no-op macros (~line 100)
+   - Restructure JSArray, JSBlob, JSText, JSRecord (lines 468-499)
+   - Simplify JSFunction to 3-word struct (line 1205)
+   - Add JSFrame as heap object (new)
+   - Restructure JSCode/JSFunctionBytecode (line 1293)
+   - Fix gc_object_size (line 1850)
+   - Fix gc_copy_value (line 1883)
+   - Complete gc_scan_object (line 1924)
+   - Update ctx_gc for all roots (line 1966)
+   - Update js_malloc to trigger GC (line 1495)
+   - Delete ref counting code throughout
+
+2. **source/quickjs.h** - Public API:
+   - Remove JSGCObjectHeader
+   - Update JSValue type checks if needed
+   - Ensure JS_IsStone works with offset 0 headers
+
+## Execution Order
+
+1. **First**: Add DupValue/FreeValue macros (enables compilation)
+2. **Second**: Standardize struct layouts (header at offset 0)
+3. **Third**: Fix gc_object_size and gc_copy_value
+4. **Fourth**: Complete gc_scan_object for all types
+5. **Fifth**: Update ctx_gc with complete root tracing
+6. **Sixth**: Wire js_malloc to trigger GC
+7. **Seventh**: Add frame reduction for closures
+8. **Finally**: Remove ref counting dead code
+
+## Verification
+
+1. **Compile test**: `make` should succeed without errors
+2. **Basic test**: Run simple scripts:
+   ```js
+   var a = [1, 2, 3]
+   log.console(a[1])
+   ```
+3. **Stress test**: Allocate many objects to trigger GC:
+   ```js
+   for (var i = 0; i < 100000; i++) {
+     var x = { value: i }
+   }
+   log.console("done")
+   ```
+4. **Closure test**: Test functions with closures survive GC:
+   ```js
+   fn make_counter() {
+     var count = 0
+     fn inc() { count = count + 1; return count }
+     return inc
+   }
+   var c = make_counter()
+   log.console(c())  // 1
+   log.console(c())  // 2
+   ```
+5. **GC stress with closures**: Create many closures, trigger GC, verify they still work
+
+## Key Design Decisions (Resolved)
+
+1. **JSCode storage**: Lives in stone (immutable) memory, never copied during GC ✓
+2. **Header offset**: Standardized to offset 0 for all heap objects ✓
+3. **Closure variables**: Live in JSFrame objects; frames are "reduced" when functions return ✓
+4. **JSVarRef**: Eliminated - closures reference their outer frame directly ✓

internal/engine.cm

@@ -1,19 +1,12 @@
 (function engine() {
-var _cell = globalThis.cell
-delete globalThis.cell
-var ACTORDATA = _cell.hidden.actorsym
+// Hidden vars (os, actorsym, init, core_path) come from env
+var ACTORDATA = actorsym
 var SYSYM = '__SYSTEM__'
 
-var hidden = _cell.hidden
-
-var os = hidden.os;
-
-_cell.os = null
+var _cell = {}
 
 var dylib_ext
 
-_cell.id ??= "newguy"
-
 switch(os.platform()) {
   case 'Windows': dylib_ext = '.dll'; break;
   case 'macOS': dylib_ext = '.dylib'; break;
@@ -28,8 +21,7 @@ function use_embed(name) {
   return load_internal("js_" + name + "_use")
 }
 
-globalThis.logical = function(val1)
-{
+function logical(val1) {
   if (val1 == 0 || val1 == false || val1 == "false" || val1 == null)
     return false;
   if (val1 == 1 || val1 == true || val1 == "true")
@@ -37,19 +29,19 @@ globalThis.logical = function(val1)
   return null;
 }
 
-globalThis.some = function(arr, pred) {
+function some(arr, pred) {
   return find(arr, pred) != null
 }
 
-globalThis.every = function(arr, pred) {
+function every(arr, pred) {
   return find(arr, x => not(pred(x))) == null
 }
 
-globalThis.starts_with = function(str, prefix) {
+function starts_with(str, prefix) {
   return search(str, prefix) == 0
 }
 
-globalThis.ends_with = function(str, suffix) {
+function ends_with(str, suffix) {
   return search(str, suffix, -length(suffix)) != null
 }
 
@@ -99,8 +91,7 @@ function use_core(path) {
 
 var blob = use_core('blob')
 
-globalThis.actor = function()
-{
+function actor() {
 
 }
 
@@ -108,7 +99,7 @@ var actor_mod = use_core('actor')
 var wota = use_core('wota')
 var nota = use_core('nota')
 
-globalThis.is_actor = function(value) {
+function is_actor(value) {
   return is_object(value) && value[ACTORDATA]
 }
 
@@ -138,7 +129,7 @@ function console_rec(line, file, msg) {
   // time: [${time.text("mb d yyyy h:nn:ss")}]
 }
 
-globalThis.log = function(name, args) {
+function log(name, args) {
   var caller = caller_data(1)
   var msg = args[0]
 
@@ -201,9 +192,8 @@ function disrupt(err)
 
 actor_mod.on_exception(disrupt)
 
-_cell.args = _cell.hidden.init
-_cell.args ??= {}
-_cell.id ??= "newguy"
+_cell.args = init ?? {}
+_cell.id = "newguy"
 
 function create_actor(desc = {id:guid()}) {
   var actor = {}
@@ -224,10 +214,30 @@ var json = use_core('json')
 var time = use_core('time')
 
 var pronto = use_core('pronto')
-globalThis.fallback = pronto.fallback
-globalThis.parallel = pronto.parallel
-globalThis.race = pronto.race
-globalThis.sequence = pronto.sequence
+var fallback = pronto.fallback
+var parallel = pronto.parallel
+var race = pronto.race
+var sequence = pronto.sequence
+
+// Create runtime environment for modules
+var runtime_env = {
+  logical: logical,
+  some: some,
+  every: every,
+  starts_with: starts_with,
+  ends_with: ends_with,
+  actor: actor,
+  is_actor: is_actor,
+  log: log,
+  send: send,
+  fallback: fallback,
+  parallel: parallel,
+  race: race,
+  sequence: sequence
+}
+
+// Pass to os for shop to access
+os.runtime_env = runtime_env
 
 $_.time_limit = function(requestor, seconds)
 {
@@ -597,13 +607,13 @@ var need_stop = false
 
 var replies = {}
 
-globalThis.send = function send(actor, message, reply) {
+function send(actor, message, reply) {
   if (!is_object(actor))
     throw Error(`Must send to an actor object. Provided: ${actor}`);
 
   if (!is_object(message))
     throw Error('Message must be an object')
-  var send = {type:"user", data: message}
+  var send_msg = {type:"user", data: message}
 
   if (actor[HEADER] && actor[HEADER].replycc) {
     var header = actor[HEADER]
@@ -611,7 +621,7 @@ globalThis.send = function send(actor, message, reply) {
       throw Error(`Supplied actor had a return, but it's not a valid actor! ${actor[HEADER]}`)
 
     actor = header.replycc
-    send.return = header.reply
+    send_msg.return = header.reply
   }
 
   if (reply) {
@@ -623,12 +633,12 @@ globalThis.send = function send(actor, message, reply) {
         delete replies[id]
       }
     }, REPLYTIMEOUT)
-    send.reply = id
-    send.replycc = $_.self 
+    send_msg.reply = id
+    send_msg.replycc = $_.self
   }
 
   // Instead of sending immediately, queue it
-  actor_prep(actor,send);
+  actor_prep(actor, send_msg);
 }
 
 stone(send)
@@ -647,7 +657,6 @@ function turn(msg)
 }
 
 //log.console(`FIXME: need to get main from config, not just set to true`)
-//log.console(`FIXME: add freeze/unfreeze at this level, so we can do it (but scripts cannot)`)
 actor_mod.register_actor(_cell.id, turn, true, config.ar_timer)
 
 if (config.actor_memory)
@@ -786,8 +795,6 @@ if (!locator) {
 if (!locator)
   throw Error(`Main program ${_cell.args.program} could not be found`)
 
-stone(globalThis)
-
 $_.clock(_ => {
   // Get capabilities for the main program
   var file_info = shop.file_info ? shop.file_info(locator.path) : null

internal/nota.c

@@ -1,386 +0,0 @@
-#include "cell.h"
-#include "cell_internal.h"
-
-#define NOTA_IMPLEMENTATION
-#include "nota.h"
-
-typedef struct NotaEncodeContext {
-  JSContext *ctx;
-  JSValue visitedStack;
-  NotaBuffer nb;
-  int cycle;
-  JSValue replacer;
-} NotaEncodeContext;
-
-static void nota_stack_push(NotaEncodeContext *enc, JSValueConst val)
-{
-  JSContext *ctx = enc->ctx;
-  int len = JS_ArrayLength(ctx, enc->visitedStack);
-  JS_SetPropertyInt64(ctx, enc->visitedStack, len, JS_DupValue(ctx, val));
-}
-
-static void nota_stack_pop(NotaEncodeContext *enc)
-{
-  JSContext *ctx = enc->ctx;
-  int len = JS_ArrayLength(ctx, enc->visitedStack);
-  JS_SetPropertyStr(ctx, enc->visitedStack, "length", JS_NewUint32(ctx, len - 1));
-}
-
-static int nota_stack_has(NotaEncodeContext *enc, JSValueConst val)
-{
-  JSContext *ctx = enc->ctx;
-  int len = JS_ArrayLength(ctx, enc->visitedStack);
-  for (int i = 0; i < len; i++) {
-    JSValue elem = JS_GetPropertyUint32(ctx, enc->visitedStack, i);
-    if (JS_IsObject(elem) && JS_IsObject(val)) {
-      if (JS_StrictEq(ctx, elem, val)) {
-        JS_FreeValue(ctx, elem);
-        return 1;
-      }
-    }
-    JS_FreeValue(ctx, elem);
-  }
-  return 0;
-}
-
-static JSValue apply_replacer(NotaEncodeContext *enc, JSValueConst holder, JSValueConst key, JSValueConst val) {
-  if (JS_IsNull(enc->replacer)) return JS_DupValue(enc->ctx, val);
-
-  JSValue args[2] = { JS_DupValue(enc->ctx, key), JS_DupValue(enc->ctx, val) };
-  JSValue result = JS_Call(enc->ctx, enc->replacer, holder, 2, args);
-  JS_FreeValue(enc->ctx, args[0]);
-  JS_FreeValue(enc->ctx, args[1]);
-  
-  if (JS_IsException(result)) return JS_DupValue(enc->ctx, val);
-  return result;
-}
-
-char *js_do_nota_decode(JSContext *js, JSValue *tmp, char *nota, JSValue holder, JSValue key, JSValue reviver) {
-  int type = nota_type(nota);
-  JSValue ret2;
-  long long n;
-  double d;
-  int b;
-  char *str;
-  uint8_t *blob;
-
-  switch(type) {
-    case NOTA_BLOB:
-      nota = nota_read_blob(&n, (char**)&blob, nota);
-      *tmp = js_new_blob_stoned_copy(js, blob, n);
-      free(blob);
-      break;
-    case NOTA_TEXT:
-      nota = nota_read_text(&str, nota);
-      *tmp = JS_NewString(js, str);
-      free(str);
-      break;
-    case NOTA_ARR:
-      nota = nota_read_array(&n, nota);
-      *tmp = JS_NewArray(js);
-      for (int i = 0; i < n; i++) {
-        nota = js_do_nota_decode(js, &ret2, nota, *tmp, JS_NewInt32(js, i), reviver);
-        JS_SetPropertyInt64(js, *tmp, i, ret2);
-      }
-      break;
-    case NOTA_REC:
-      nota = nota_read_record(&n, nota);
-      *tmp = JS_NewObject(js);
-      for (int i = 0; i < n; i++) {
-        nota = nota_read_text(&str, nota);
-        JSValue prop_key = JS_NewString(js, str);
-        nota = js_do_nota_decode(js, &ret2, nota, *tmp, prop_key, reviver);
-        JS_SetPropertyStr(js, *tmp, str, ret2);
-        JS_FreeValue(js, prop_key);
-        free(str);
-      }
-      break;
-    case NOTA_INT:
-      nota = nota_read_int(&n, nota);
-      *tmp = JS_NewInt64(js, n);
-      break;
-    case NOTA_SYM:
-      nota = nota_read_sym(&b, nota);
-      if (b == NOTA_PRIVATE) {
-        JSValue inner;
-        nota = js_do_nota_decode(js, &inner, nota, holder, JS_NULL, reviver);
-        JSValue obj = JS_NewObject(js);
-        cell_rt *crt = JS_GetContextOpaque(js);
-//        JS_SetProperty(js, obj, crt->actor_sym, inner);
-        *tmp = obj;
-      } else {
-        switch(b) {
-          case NOTA_NULL: *tmp = JS_NULL; break;
-          case NOTA_FALSE: *tmp = JS_NewBool(js, 0); break;
-          case NOTA_TRUE: *tmp = JS_NewBool(js, 1); break;
-          default: *tmp = JS_NULL; break;
-        }
-      }
-      break;
-    default:
-    case NOTA_FLOAT:
-      nota = nota_read_float(&d, nota);
-      *tmp = JS_NewFloat64(js, d);
-      break;
-  }
-
-  if (!JS_IsNull(reviver)) {
-    JSValue args[2] = { JS_DupValue(js, key), JS_DupValue(js, *tmp) };
-    JSValue revived = JS_Call(js, reviver, holder, 2, args);
-    JS_FreeValue(js, args[0]);
-    JS_FreeValue(js, args[1]);
-    if (!JS_IsException(revived)) {
-      JS_FreeValue(js, *tmp);
-      *tmp = revived;
-    } else {
-      JS_FreeValue(js, revived);
-    }
-  }
-
-  return nota;
-}
-
-static void nota_encode_value(NotaEncodeContext *enc, JSValueConst val, JSValueConst holder, JSValueConst key) {
-  JSContext *ctx = enc->ctx;
-  JSValue replaced = apply_replacer(enc, holder, key, val);
-  int tag = JS_VALUE_GET_TAG(replaced);
-
-  switch (tag) {
-    case JS_TAG_INT: 
-    case JS_TAG_FLOAT64: {
-      double d;
-      JS_ToFloat64(ctx, &d, replaced);
-      nota_write_number(&enc->nb, d);
-      break;
-    }
-    case JS_TAG_STRING: {
-      const char *str = JS_ToCString(ctx, replaced);
-      nota_write_text(&enc->nb, str);
-      JS_FreeCString(ctx, str);
-      break;
-    }
-    case JS_TAG_BOOL:
-      if (JS_VALUE_GET_BOOL(replaced)) nota_write_sym(&enc->nb, NOTA_TRUE);
-      else nota_write_sym(&enc->nb, NOTA_FALSE);
-      break;
-    case JS_TAG_NULL:
-      nota_write_sym(&enc->nb, NOTA_NULL);
-      break;
-    case JS_TAG_OBJECT: {
-      if (js_is_blob(ctx, replaced)) {
-        size_t buf_len;
-        void *buf_data = js_get_blob_data(ctx, &buf_len, replaced);
-        if (buf_data == -1) {
-          JS_FreeValue(ctx, replaced);
-          return; // JS_EXCEPTION will be handled by caller
-        }
-        nota_write_blob(&enc->nb, (unsigned long long)buf_len * 8, (const char*)buf_data);
-        break;
-      }
-
-      if (JS_IsArray(ctx, replaced)) {
-        if (nota_stack_has(enc, replaced)) {
-          enc->cycle = 1;
-          break;
-        }
-        nota_stack_push(enc, replaced);
-        int arr_len = JS_ArrayLength(ctx, replaced);
-        nota_write_array(&enc->nb, arr_len);
-        for (int i = 0; i < arr_len; i++) {
-          JSValue elem_val = JS_GetPropertyUint32(ctx, replaced, i);
-          JSValue elem_key = JS_NewInt32(ctx, i);
-          nota_encode_value(enc, elem_val, replaced, elem_key);
-          JS_FreeValue(ctx, elem_val);
-          JS_FreeValue(ctx, elem_key);
-        }
-        nota_stack_pop(enc);
-        break;
-      }
-
-      cell_rt *crt = JS_GetContextOpaque(ctx);
-//      JSValue adata = JS_GetProperty(ctx, replaced, crt->actor_sym);
-      JSValue adata = JS_NULL;
-      if (!JS_IsNull(adata)) {
-        nota_write_sym(&enc->nb, NOTA_PRIVATE);
-        nota_encode_value(enc, adata, replaced, JS_NULL);
-        JS_FreeValue(ctx, adata);
-        break;
-      }
-      JS_FreeValue(ctx, adata);
-      if (nota_stack_has(enc, replaced)) {
-        enc->cycle = 1;
-        break;
-      }
-      nota_stack_push(enc, replaced);
-
-      JSValue to_json = JS_GetPropertyStr(ctx, replaced, "toJSON");
-      if (JS_IsFunction(to_json)) {
-        JSValue result = JS_Call(ctx, to_json, replaced, 0, NULL);
-        JS_FreeValue(ctx, to_json);
-        if (!JS_IsException(result)) {
-          nota_encode_value(enc, result, holder, key);
-          JS_FreeValue(ctx, result);
-        } else {
-          nota_write_sym(&enc->nb, NOTA_NULL);
-        }
-        nota_stack_pop(enc);
-        break;
-      }
-      JS_FreeValue(ctx, to_json);
-
-      JSPropertyEnum *ptab;
-      uint32_t plen;
-      if (JS_GetOwnPropertyNames(ctx, &ptab, &plen, replaced, JS_GPN_ENUM_ONLY | JS_GPN_STRING_MASK) < 0) {
-        nota_write_sym(&enc->nb, NOTA_NULL);
-        nota_stack_pop(enc);
-        break;
-      }
-
-      uint32_t non_function_count = 0;
-      for (uint32_t i = 0; i < plen; i++) {
-        JSValue prop_val = JS_GetProperty(ctx, replaced, ptab[i].atom);
-        if (!JS_IsFunction(prop_val)) non_function_count++;
-        JS_FreeValue(ctx, prop_val);
-      }
-
-      nota_write_record(&enc->nb, non_function_count);
-      for (uint32_t i = 0; i < plen; i++) {
-        JSValue prop_val = JS_GetProperty(ctx, replaced, ptab[i].atom);
-        if (!JS_IsFunction(prop_val)) {
-          const char *prop_name = JS_AtomToCString(ctx, ptab[i].atom);
-          JSValue prop_key = JS_AtomToValue(ctx, ptab[i].atom);
-          nota_write_text(&enc->nb, prop_name);
-          nota_encode_value(enc, prop_val, replaced, prop_key);
-          JS_FreeCString(ctx, prop_name);
-          JS_FreeValue(ctx, prop_key);
-        }
-        JS_FreeValue(ctx, prop_val);
-        JS_FreeAtom(ctx, ptab[i].atom);
-      }
-      js_free(ctx, ptab);
-      nota_stack_pop(enc);
-      break;
-    }
-    default:
-      nota_write_sym(&enc->nb, NOTA_NULL);
-      break;
-  }
-  JS_FreeValue(ctx, replaced);
-}
-
-void *value2nota(JSContext *ctx, JSValue v) {
-  NotaEncodeContext enc_s, *enc = &enc_s;
-  enc->ctx = ctx;
-  enc->visitedStack = JS_NewArray(ctx);
-  enc->cycle = 0;
-  enc->replacer = JS_NULL;
-
-  nota_buffer_init(&enc->nb, 128);
-  nota_encode_value(enc, v, JS_NULL, JS_NewString(ctx, ""));
-
-  if (enc->cycle) {
-    JS_FreeValue(ctx, enc->visitedStack);
-    nota_buffer_free(&enc->nb);
-    return NULL;
-  }
-
-  JS_FreeValue(ctx, enc->visitedStack);
-  void *data_ptr = enc->nb.data;
-  enc->nb.data = NULL;
-  nota_buffer_free(&enc->nb);
-  return data_ptr;
-}
-
-JSValue nota2value(JSContext *js, void *nota) {
-  if (!nota) return JS_NULL;
-  JSValue ret;
-  JSValue holder = JS_NewObject(js);
-  js_do_nota_decode(js, &ret, nota, holder, JS_NewString(js, ""), JS_NULL);
-  JS_FreeValue(js, holder);
-  return ret;
-}
-
-static JSValue js_nota_tostring(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
-  size_t len;
-  void *nota = js_get_blob_data(ctx, &len, this_val);
-  if (nota == (void*)-1) return JS_EXCEPTION;
-  if (!nota) return JS_NULL;
-  
-  JSValue decoded;
-  JSValue holder = JS_NewObject(ctx);
-  js_do_nota_decode(ctx, &decoded, (char*)nota, holder, JS_NewString(ctx, ""), JS_NULL);
-  JS_FreeValue(ctx, holder);
-  
-  JSValue global = JS_GetGlobalObject(ctx);
-  JSValue json = JS_GetPropertyStr(ctx, global, "JSON");
-  JSValue stringify = JS_GetPropertyStr(ctx, json, "stringify");
-  
-  JSValue args[3];
-  args[0] = decoded;
-  args[1] = JS_NULL;
-  args[2] = JS_NewInt32(ctx, 1);
-  
-  JSValue result = JS_Call(ctx, stringify, json, 3, args);
-  
-  JS_FreeValue(ctx, stringify);
-  JS_FreeValue(ctx, json);
-  JS_FreeValue(ctx, global);
-  JS_FreeValue(ctx, decoded);
-  JS_FreeValue(ctx, args[2]);
-  
-  return result;
-}
-
-static JSValue js_nota_encode(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
-  if (argc < 1) return JS_ThrowTypeError(ctx, "nota.encode requires at least 1 argument");
-
-  NotaEncodeContext enc_s, *enc = &enc_s;
-  enc->ctx = ctx;
-  enc->visitedStack = JS_NewArray(ctx);
-  enc->cycle = 0;
-  enc->replacer = (argc > 1 && JS_IsFunction(argv[1])) ? argv[1] : JS_NULL;
-
-  nota_buffer_init(&enc->nb, 128);
-  nota_encode_value(enc, argv[0], JS_NULL, JS_NewString(ctx, ""));
-
-  if (enc->cycle) {
-    JS_FreeValue(ctx, enc->visitedStack);
-    nota_buffer_free(&enc->nb);
-    return JS_ThrowReferenceError(ctx, "Tried to encode something to nota with a cycle.");
-  }
-
-  JS_FreeValue(ctx, enc->visitedStack);
-  size_t total_len = enc->nb.size;
-  void *data_ptr = enc->nb.data;
-  JSValue ret = js_new_blob_stoned_copy(ctx, (uint8_t*)data_ptr, total_len);
-
-  nota_buffer_free(&enc->nb);
-  return ret;
-}
-
-static JSValue js_nota_decode(JSContext *js, JSValueConst self, int argc, JSValueConst *argv) {
-  if (argc < 1) return JS_NULL;
-
-  size_t len;
-  unsigned char *nota = js_get_blob_data(js, &len, argv[0]);
-  if (nota == -1) return JS_EXCEPTION;
-  if (!nota) return JS_NULL;
-
-  JSValue reviver = (argc > 1 && JS_IsFunction(argv[1])) ? argv[1] : JS_NULL;
-  JSValue ret;
-  JSValue holder = JS_NewObject(js);
-  js_do_nota_decode(js, &ret, (char*)nota, holder, JS_NewString(js, ""), reviver);
-  JS_FreeValue(js, holder);
-  return ret;
-}
-
-static const JSCFunctionListEntry js_nota_funcs[] = {
-  JS_CFUNC_DEF("encode", 1, js_nota_encode),
-  JS_CFUNC_DEF("decode", 1, js_nota_decode),
-};
-
-JSValue js_nota_use(JSContext *js) {
-  JSValue export = JS_NewObject(js);
-  JS_SetPropertyFunctionList(js, export, js_nota_funcs, sizeof(js_nota_funcs)/sizeof(JSCFunctionListEntry));
-  return export;
-}

internal/shop.cm

@@ -379,7 +379,16 @@ Shop.get_script_capabilities = function(path) {
 }
 
 function inject_env(inject) {
+  // Start with runtime functions from engine
   var env = {}
+  var rt = my$_.os ? my$_.os.runtime_env : null
+  if (rt) {
+    for (var k in rt) {
+      env[k] = rt[k]
+    }
+  }
+
+  // Add capability injections
   for (var i = 0; i < length(inject); i++) {
     var inj = inject[i]
     var key = trim(inj, '$')
@@ -391,6 +400,17 @@ function inject_env(inject) {
 
 function inject_bindings_code(inject) {
   var lines = []
+
+  // Runtime function bindings
+  var runtime_fns = ['logical', 'some', 'every', 'starts_with', 'ends_with',
+                     'actor', 'is_actor', 'log', 'send',
+                     'fallback', 'parallel', 'race', 'sequence']
+  for (var i = 0; i < length(runtime_fns); i++) {
+    var fn = runtime_fns[i]
+    push(lines, `var ${fn} = env["${fn}"];`)
+  }
+
+  // Capability bindings ($delay, $start, etc.)
   for (var i = 0; i < length(inject); i++) {
     var inj = inject[i]
     var key = trim(inj, '$')
@@ -432,18 +452,17 @@ function resolve_mod_fn(path, pkg) {
   var obj = pull_from_cache(stone(blob(script)))
   if (obj) {
     var fn = js.compile_unblob(obj)
-    return js.eval_compile(fn)
+    return js.integrate(fn, null)
   }
 
   // Compile name is just for debug/stack traces
-//  var compile_name = pkg ? pkg + ':' + path : 'local:' + path
   var compile_name = path
 
   var fn = js.compile(compile_name, script)
 
   put_into_cache(stone(blob(script)), js.compile_blob(fn))
 
-  return js.eval_compile(fn)
+  return js.integrate(fn, null)
 }
 
 // given a path and a package context

meson.build

@@ -40,9 +40,9 @@ sources = []
 src += [        # core
   'monocypher.c',
   'cell.c',
+  'suite.c',
   'wildmatch.c',
   'qjs_actor.c',
-  'qjs_wota.c',
   'miniz.c',
   'quickjs.c',
   'libregexp.c', 'libunicode.c', 'cutils.c', 'dtoa.c'
@@ -51,7 +51,6 @@ src += [        # core
 src += ['scheduler.c']
 
 scripts = [
-  'internal/nota.c',
   'debug/js.c',
   'qop.c',
   'wildstar.c',
@@ -59,7 +58,6 @@ scripts = [
   'crypto.c',
   'internal/kim.c',
   'time.c',
-  'internal/nota.c',
   'debug/debug.c',
   'internal/os.c',
   'fd.c',
@@ -67,6 +65,7 @@ scripts = [
   'net/enet.c',
   'wildstar.c',
   'archive/miniz.c',
+  'source/cJSON.c'
 ]
 
 foreach file: scripts

net/enet.c

@@ -70,7 +70,7 @@ static JSValue js_enet_host_create(JSContext *ctx, JSValueConst this_val, int ar
 
   JSValue config_obj = argv[0];
   JSValue addr_val = JS_GetPropertyStr(ctx, config_obj, "address");
-  const char *addr_str = JS_IsString(addr_val) ? JS_ToCString(ctx, addr_val) : NULL;
+  const char *addr_str = JS_IsText(addr_val) ? JS_ToCString(ctx, addr_val) : NULL;
   JS_FreeValue(ctx, addr_val);
 
   if (!addr_str)
@@ -245,7 +245,7 @@ static JSValue js_enet_host_broadcast(JSContext *ctx, JSValueConst this_val, int
   size_t data_len = 0;
   uint8_t *buf = NULL;
 
-  if (JS_IsString(argv[0])) {
+  if (JS_IsText(argv[0])) {
     data_str = JS_ToCStringLen(ctx, &data_len, argv[0]);
     if (!data_str) return JS_EXCEPTION;
   } else if (js_is_blob(ctx,argv[0])) {
@@ -310,7 +310,7 @@ static JSValue js_enet_peer_send(JSContext *ctx, JSValueConst this_val, int argc
   size_t data_len = 0;
   uint8_t *buf = NULL;
 
-  if (JS_IsString(argv[0])) {
+  if (JS_IsText(argv[0])) {
     data_str = JS_ToCStringLen(ctx, &data_len, argv[0]);
     if (!data_str) return JS_EXCEPTION;
   } else if (js_is_blob(ctx,argv[0])) {

net/http.c

@@ -293,7 +293,7 @@ static int par_easycurl_to_memory(char const *url, par_byte **data, int *nbytes)
 // Performs a blocking HTTP GET and returns a QuickJS Blob of the body
 static JSValue js_fetch_picoparser(JSContext *ctx, JSValueConst this_val,
                                    int argc, JSValueConst *argv) {
-  if (argc < 1 || !JS_IsString(argv[0]))
+  if (argc < 1 || !JS_IsText(argv[0]))
     return JS_ThrowTypeError(ctx, "fetch: URL string required");
 
   const char *url = JS_ToCString(ctx, argv[0]);

net/http_playdate.c

@@ -135,7 +135,7 @@ static int parse_url(const char *url, char **host, int *port, char **path, int *
 // Performs a blocking HTTP GET and returns a QuickJS Blob of the body
 static JSValue js_fetch_playdate(JSContext *ctx, JSValueConst this_val,
                                   int argc, JSValueConst *argv) {
-    if (argc < 1 || !JS_IsString(argv[0]))
+    if (argc < 1 || !JS_IsText(argv[0]))
         return JS_ThrowTypeError(ctx, "fetch: URL string required");
     
     if (!pd_network || !pd_network->http) {

net/socket.c

@@ -144,7 +144,7 @@ JSC_CCALL(socket_socket,
     int protocol = 0;
     
     // Parse domain
-    if (JS_IsString(argv[0])) {
+    if (JS_IsText(argv[0])) {
         const char *domain_str = JS_ToCString(js, argv[0]);
         if (strcmp(domain_str, "AF_INET") == 0) domain = AF_INET;
         else if (strcmp(domain_str, "AF_INET6") == 0) domain = AF_INET6;
@@ -156,7 +156,7 @@ JSC_CCALL(socket_socket,
     
     // Parse type
     if (argc > 1) {
-        if (JS_IsString(argv[1])) {
+        if (JS_IsText(argv[1])) {
             const char *type_str = JS_ToCString(js, argv[1]);
             if (strcmp(type_str, "SOCK_STREAM") == 0) type = SOCK_STREAM;
             else if (strcmp(type_str, "SOCK_DGRAM") == 0) type = SOCK_DGRAM;
@@ -297,7 +297,7 @@ JSC_CCALL(socket_send,
         flags = js2number(js, argv[2]);
     }
     
-    if (JS_IsString(argv[1])) {
+    if (JS_IsText(argv[1])) {
         const char *data = JS_ToCStringLen(js, &len, argv[1]);
         sent = send(sockfd, data, len, flags);
         JS_FreeCString(js, data);
@@ -385,7 +385,7 @@ JSC_CCALL(socket_sendto,
         to_len = sizeof(addr);
     }
     
-    if (JS_IsString(argv[1])) {
+    if (JS_IsText(argv[1])) {
         const char *data = JS_ToCStringLen(js, &len, argv[1]);
         sent = sendto(sockfd, data, len, flags, to_addr, to_len);
         JS_FreeCString(js, data);
@@ -525,7 +525,7 @@ JSC_CCALL(socket_setsockopt,
     int optname = 0;
     
     // Parse level
-    if (JS_IsString(argv[1])) {
+    if (JS_IsText(argv[1])) {
         const char *level_str = JS_ToCString(js, argv[1]);
         if (strcmp(level_str, "SOL_SOCKET") == 0) level = SOL_SOCKET;
         else if (strcmp(level_str, "IPPROTO_TCP") == 0) level = IPPROTO_TCP;
@@ -537,7 +537,7 @@ JSC_CCALL(socket_setsockopt,
     }
     
     // Parse option name
-    if (JS_IsString(argv[2])) {
+    if (JS_IsText(argv[2])) {
         const char *opt_str = JS_ToCString(js, argv[2]);
         if (strcmp(opt_str, "SO_REUSEADDR") == 0) optname = SO_REUSEADDR;
         else if (strcmp(opt_str, "SO_KEEPALIVE") == 0) optname = SO_KEEPALIVE;

plan.md

@@ -0,0 +1,338 @@
+# Cell/QuickJS Refactoring Plan: Remove Atoms, Shapes, and Dual-Encoding
+
+## Overview
+
+Refactor `source/quickjs.c` to match `docs/memory.md` specification:
+- Remove JSAtom system (171 references → ~41 remaining)
+- Remove JSShape system (94 references) ✓
+- Remove IC caches (shape-based inline caches) ✓
+- Remove `is_wide_char` dual-encoding (18 locations) ✓
+- Use JSValue texts directly as property keys
+- Reference: `mquickjs.c` shows the target pattern
+
+## Completed Phases
+
+### Phase 1: Remove is_wide_char Remnants ✓
+### Phase 2: Remove IC Caches ✓
+### Phase 3: Remove JSShape System ✓
+### Phase 4: Complete Property Access with JSValue Keys ✓
+
+Completed:
+- Removed JS_GC_OBJ_TYPE_JS_OBJECT fallbacks from OP_get_field
+- Removed JS_GC_OBJ_TYPE_JS_OBJECT fallbacks from OP_put_field
+- Removed JS_GC_OBJ_TYPE_JS_OBJECT fallbacks from OP_define_field
+- Created emit_key() function that adds JSValue to cpool and emits index
+
+---
+
+## Phase 5: Convert JSAtom to JSValue Text (IN PROGRESS)
+
+This is the core transformation. All identifier handling moves from atoms to JSValue.
+
+### Completed Items
+
+**Token and Parser Infrastructure:**
+- [x] Change JSToken.u.ident.atom to JSToken.u.ident.str (JSValue)
+- [x] Change parse_ident() to return JSValue
+- [x] Create emit_key() function (cpool-based)
+- [x] Create JS_KEY_* macros for common names (lines ~279-335 in quickjs.c)
+- [x] Update all token.u.ident.atom references to .str
+- [x] Create keyword lookup table (js_keywords[]) with string comparison
+- [x] Rewrite update_token_ident() to use js_keyword_lookup()
+- [x] Rewrite is_strict_future_keyword() to use JSValue
+- [x] Update token_is_pseudo_keyword() to use JSValue and js_key_equal()
+
+**Function Declaration Parsing:**
+- [x] Update js_parse_function_decl() signature to use JSValue func_name
+- [x] Update js_parse_function_decl2() to use JSValue func_name throughout
+- [x] Update js_parse_function_check_names() to use JSValue
+- [x] Convert JS_DupAtom/JS_FreeAtom to JS_DupValue/JS_FreeValue in function parsing
+
+**Variable Definition and Lookup:**
+- [x] Update find_global_var() to use JSValue and js_key_equal()
+- [x] Update find_lexical_global_var() to use JSValue
+- [x] Update find_lexical_decl() to use JSValue and js_key_equal()
+- [x] Update js_define_var() to use JSValue
+- [x] Update js_parse_check_duplicate_parameter() to use JSValue and js_key_equal()
+- [x] Update js_parse_destructuring_var() to return JSValue
+- [x] Update js_parse_var() to use JSValue for variable names
+
+**Comparison Helpers:**
+- [x] Create js_key_equal_str() for comparing JSValue with C string literals
+- [x] Update is_var_in_arg_scope() to use js_key_equal/js_key_equal_str
+- [x] Update has_with_scope() to use js_key_equal_str
+- [x] Update closure variable comparisons (cv->var_name) to use js_key_equal_str
+
+**Property Access:**
+- [x] Fix JS_GetPropertyStr to create proper JSValue keys
+- [x] Fix JS_SetPropertyInternal callers to use JS_KEY_* instead of JS_ATOM_*
+
+### JS_KEY_* Macros Added
+
+Compile-time immediate ASCII string constants (≤7 chars):
+```c
+JS_KEY_empty, JS_KEY_name, JS_KEY_message, JS_KEY_stack,
+JS_KEY_errors, JS_KEY_Error, JS_KEY_cause, JS_KEY_length,
+JS_KEY_value, JS_KEY_get, JS_KEY_set, JS_KEY_raw,
+JS_KEY_flags, JS_KEY_source, JS_KEY_exec, JS_KEY_toJSON,
+JS_KEY_eval, JS_KEY_this, JS_KEY_true, JS_KEY_false,
+JS_KEY_null, JS_KEY_NaN, JS_KEY_default, JS_KEY_index,
+JS_KEY_input, JS_KEY_groups, JS_KEY_indices, JS_KEY_let,
+JS_KEY_var, JS_KEY_new, JS_KEY_of, JS_KEY_yield,
+JS_KEY_async, JS_KEY_target, JS_KEY_from, JS_KEY_meta,
+JS_KEY_as, JS_KEY_with
+```
+
+Runtime macro for strings >7 chars:
+```c
+#define JS_KEY_STR(ctx, str) JS_NewStringLen((ctx), (str), sizeof(str) - 1)
+```
+
+Helper function for comparing JSValue with C string literals:
+```c
+static JS_BOOL js_key_equal_str(JSValue a, const char *str);
+```
+
+### Remaining Work
+
+#### 5.3 Update js_parse_property_name() ✓
+- [x] Change return type from JSAtom* to JSValue*
+- [x] Update all callers (js_parse_object_literal, etc.)
+- [x] Updated get_lvalue(), put_lvalue(), js_parse_destructuring_element()
+
+#### 5.4 Replace remaining emit_atom() calls with emit_key() ✓
+- [x] Removed emit_atom wrapper function
+- [x] Changed last emit_atom(JS_ATOM_this) to emit_key(JS_KEY_this)
+
+#### 5.5 Update Variable Opcode Format in quickjs-opcode.h
+- [ ] Change `atom` format opcodes to `key` format
+- [ ] Change `atom_u8` and `atom_u16` to `key_u8` and `key_u16`
+
+#### 5.6 Update VM Opcode Handlers ✓
+These now read cpool indices and look up JSValue:
+- [x] OP_check_var, OP_get_var_undef, OP_get_var
+- [x] OP_put_var, OP_put_var_init, OP_put_var_strict
+- [x] OP_set_name, OP_make_var_ref, OP_delete_var
+- [x] OP_define_var, OP_define_func, OP_throw_error
+- [x] OP_make_loc_ref, OP_make_arg_ref
+- [x] OP_define_method, OP_define_method_computed
+
+#### 5.7 Update resolve_scope_var() ✓
+- [x] Changed signature to use JSValue var_name
+- [x] Updated all comparisons to use js_key_equal()/js_key_equal_str()
+- [x] Updated var_object_test() to use JSValue
+- [x] Updated optimize_scope_make_global_ref() to use JSValue
+- [x] Updated resolve_variables() callers to read from cpool
+
+#### 5.8 Convert Remaining JS_ATOM_* Usages
+Categories remaining:
+- Some debug/print functions still use JSAtom
+- Some function signatures not yet converted
+- Will be addressed in Phase 7 cleanup
+
+---
+
+## Phase 6: Update Bytecode Serialization ✓
+
+### 6.1 JS_WriteObjectTag Changes ✓
+- [x] Changed JS_WriteObjectTag to use bc_put_key() directly for property keys
+- [x] Removed JS_ValueToAtom/bc_put_atom path (was broken anyway)
+- [x] cpool values serialized via JS_WriteObjectRec()
+
+### 6.2 JS_ReadObject Changes ✓
+- [x] Changed JS_ReadObjectTag to use bc_get_key() for property keys
+- [x] Uses JS_SetPropertyInternal with JSValue keys
+
+### 6.3 Opcode Format Updates ✓
+- [x] Added OP_FMT_key_u8, OP_FMT_key_u16, OP_FMT_key_label_u16 formats
+- [x] Updated variable opcodes to use key formats instead of atom formats
+- [x] Updated bc_byte_swap() to handle new key formats
+- [x] Updated JS_WriteFunctionBytecode() to skip key format opcodes
+- [x] Updated JS_ReadFunctionBytecode() to skip key format opcodes
+
+### 6.4 Version Bump ✓
+- [x] Incremented BC_VERSION from 5 to 6
+
+---
+
+## Phase 7: Final Cleanup ✓
+
+### 7.1 Additional Parser/Compiler Fixes ✓
+- [x] Fixed TOK_IDENT case to use JSValue name, JS_DupValue, emit_key
+- [x] Fixed TOK_TRY catch clause to use JSValue name
+- [x] Fixed js_parse_statement_or_decl label_name to use JSValue
+- [x] Fixed OP_scope_get_var "eval" check to use js_key_equal_str
+- [x] Fixed js_parse_delete to use JSValue for name comparison
+- [x] Fixed JSON parsing to use js_key_from_string for property names
+- [x] Added js_key_from_string() helper function
+- [x] Added JS_KEY__ret_, JS_KEY__eval_, JS_KEY__var_ for internal names
+- [x] Updated add_closure_var, get_closure_var2, get_closure_var to use JSValue var_name
+- [x] Updated set_closure_from_var to use JS_DupValue
+- [x] Updated add_closure_variables to use JS_DupValue
+- [x] Updated instantiate_hoisted_definitions to use fd_cpool_add for keys
+- [x] Updated resolve_variables to use js_key_equal and fd_cpool_add
+
+### 7.1.1 Property Access and Runtime Fixes ✓
+- [x] Fixed JS_GetPropertyValue to use js_key_from_string instead of JS_ValueToAtom
+- [x] Fixed JS_GetPropertyKey to use js_key_from_string for string keys
+- [x] Fixed JS_SetPropertyKey to use js_key_from_string for string keys
+- [x] Fixed JS_HasPropertyKey to use js_key_from_string for string keys
+- [x] Fixed JS_DeletePropertyKey to use js_key_from_string for string keys
+- [x] Updated JS_HasProperty signature to take JSValue prop
+- [x] Fixed OP_get_ref_value handler to use JSValue key
+- [x] Fixed OP_put_ref_value handler to use JSValue key
+- [x] Updated free_func_def to use JS_FreeValue for JSValue fields
+
+### 7.2 Remove JSAtom Type and Functions ✓
+- [x] Removed most JS_ATOM_* constants (kept JS_ATOM_NULL, JS_ATOM_END for BC compat)
+- [x] JS_NewAtomString now returns JSValue using js_key_new
+- [x] JS_FreeAtom, JS_DupAtom are stubs (no-op for backward compat)
+- [x] JS_AtomToValue, JS_ValueToAtom are stubs (minimal BC compat)
+- [x] Replaced JS_ATOM_* usages with JS_KEY_* or JS_GetPropertyStr
+
+### 7.3 Additional Runtime Fixes ✓
+- [x] Fixed free_function_bytecode to use JS_FreeValueRT for JSValue fields
+- [x] Fixed JS_SetPropertyFunctionList to use JSValue keys via find_key()
+- [x] Fixed JS_InstantiateFunctionListItem to use JSValue keys
+- [x] Fixed internalize_json_property to use JSValue names
+- [x] Fixed emit_break and push_break_entry to use JSValue label_name
+- [x] Implemented JS_Invoke to use JSValue method key
+
+### 7.4 Remaining Stubs (kept for bytecode backward compatibility)
+- JSAtom typedef (uint32_t) - used in BC serialization
+- JS_ATOM_NULL, JS_ATOM_END - bytecode format markers
+- JS_FreeAtom, JS_DupAtom - no-op stubs
+- JS_FreeAtomRT, JS_DupAtomRT - no-op stubs
+- Legacy BC reader (idx_to_atom array) - for reading old bytecode
+
+---
+
+## Current Build Status
+
+**Build: SUCCEEDS** with warnings (unused variables, labels)
+
+**Statistics:**
+- JS_ATOM_* usages: Minimal (only BC serialization compat)
+- Property access uses JS_KEY_* macros or JS_GetPropertyStr
+- BC_VERSION: 6 (updated for new key-based format)
+
+**What Works:**
+- All property access via JSValue keys
+- Keyword detection via string comparison
+- Function declaration parsing with JSValue names
+- Variable definition with JSValue names
+- Closure variable tracking with JSValue names
+- VM opcode handlers read cpool indices and look up JSValue
+- resolve_scope_var() uses JSValue throughout
+- js_parse_property_name() returns JSValue
+- Bytecode serialization uses bc_put_key/bc_get_key for property keys
+- Variable opcodes use key format (cpool indices)
+- JSON parsing uses JSValue keys
+- Internal variable names use JS_KEY__ret_, JS_KEY__eval_, JS_KEY__var_
+- JS_SetPropertyFunctionList uses JSValue keys
+- JS_Invoke uses JSValue method keys
+- break/continue labels use JSValue
+
+---
+
+## Phase 8: Migrate to New Tagging System (IN PROGRESS)
+
+**Problem**: `JS_VALUE_GET_TAG` returns `JS_TAG_PTR` for all pointers, but ~200 places check for obsolete tags like `JS_TAG_OBJECT`, `JS_TAG_STRING`, `JS_TAG_FUNCTION`, etc., which are never returned. This causes crashes.
+
+**Target Design** (from memory.md):
+- JSValue tags: Only `JS_TAG_INT`, `JS_TAG_PTR`, `JS_TAG_SHORT_FLOAT`, `JS_TAG_SPECIAL`
+- Pointer types determined by `objhdr_t` header at offset 8 in heap objects
+- mist_obj_type: `OBJ_ARRAY(0)`, `OBJ_BLOB(1)`, `OBJ_TEXT(2)`, `OBJ_RECORD(3)`, `OBJ_FUNCTION(4)`, etc.
+
+### 8.1 Unified Heap Object Layout ✓
+- [x] Updated mist_text structure to have objhdr_t at offset 8:
+  ```c
+  typedef struct mist_text {
+    JSRefCountHeader _dummy_header; /* unused, for offset alignment */
+    uint32_t _pad;                  /* padding to align objhdr_t to offset 8 */
+    objhdr_t hdr;                   /* NOW at offset 8, like JSString */
+    word_t length;
+    word_t packed[];
+  } mist_text;
+  ```
+- [x] JSString already has objhdr_t at offset 8
+
+### 8.2 Type-Checking Helper Functions ✓
+Added lowercase internal helpers (to avoid conflict with quickjs.h declarations):
+```c
+static inline JS_BOOL js_is_gc_object(JSValue v) { return JS_IsPtr(v); }
+static inline JSGCObjectTypeEnum js_get_gc_type(JSValue v) {
+  return ((JSGCObjectHeader *)JS_VALUE_GET_PTR(v))->gc_obj_type;
+}
+static inline JS_BOOL js_is_record(JSValue v) {
+  if (!JS_IsPtr(v)) return FALSE;
+  return js_get_gc_type(v) == JS_GC_OBJ_TYPE_RECORD;
+}
+static inline JS_BOOL js_is_array(JSValue v) {
+  if (!JS_IsPtr(v)) return FALSE;
+  return js_get_gc_type(v) == JS_GC_OBJ_TYPE_ARRAY;
+}
+static inline JS_BOOL js_is_function(JSValue v) {
+  if (!JS_IsPtr(v)) return FALSE;
+  return js_get_gc_type(v) == JS_GC_OBJ_TYPE_FUNCTION;
+}
+static inline JS_BOOL js_is_object(JSValue v) {
+  if (!JS_IsPtr(v)) return FALSE;
+  JSGCObjectTypeEnum t = js_get_gc_type(v);
+  return t == JS_GC_OBJ_TYPE_RECORD || t == JS_GC_OBJ_TYPE_ARRAY;
+}
+```
+
+### 8.3 Updated Core Functions ✓
+- [x] Updated JS_IsString to read objhdr_t from offset 8
+- [x] Updated js_key_hash to read objhdr_t from offset 8
+- [x] Updated js_key_equal to read objhdr_t from offset 8
+- [x] Updated __JS_FreeValueRT to use objhdr_type for type dispatch
+- [x] Updated JS_MarkValue, JS_MarkValueEdgeEx for GC
+- [x] Added JS_SetPropertyValue function
+- [x] Changed quickjs.h JS_IsFunction/JS_IsObject from inline to extern declarations
+
+### 8.4 Tag Check Migration (PARTIAL)
+Updated some critical tag checks:
+- [x] Some JS_TAG_OBJECT checks → js_is_object() or js_is_record()
+- [ ] Many more JS_TAG_OBJECT checks remain (~200 total)
+- [ ] JS_TAG_FUNCTION checks → js_is_function()
+- [ ] JS_TAG_STRING checks (some already use JS_IsString)
+
+### 8.5 Remaining Work
+- [ ] Fix ASAN memory corruption error (attempting free on address not malloc'd)
+  - Crash occurs in js_def_realloc during js_realloc_array
+  - Address is 112 bytes inside a JSFunctionDef allocation
+- [ ] Complete remaining ~200 tag check migrations
+- [ ] Add mist_hdr to JSFunction (optional, gc_obj_type already works)
+- [ ] Remove obsolete tag definitions from quickjs.h:
+  - JS_TAG_STRING = -8
+  - JS_TAG_ARRAY = -6
+  - JS_TAG_FUNCTION = -5
+  - JS_TAG_FUNCTION_BYTECODE = -2
+  - JS_TAG_OBJECT = -1
+
+### Current Status
+
+**Build: SUCCEEDS** with warnings
+
+**Runtime: CRASHES** with ASAN error:
+```
+==16122==ERROR: AddressSanitizer: attempting free on address which was not malloc()-ed
+```
+The crash occurs during test execution in `js_def_realloc` called from `js_realloc_array`.
+Root cause not yet identified - likely a pointer being passed to realloc that wasn't allocated with malloc.
+
+---
+
+## Notes
+
+- JSVarDef.var_name is JSValue
+- JSClosureVar.var_name is JSValue
+- JSGlobalVar.var_name is JSValue
+- JSFunctionDef.func_name is JSValue
+- BlockEnv.label_name is JSValue
+- OP_get_field/put_field/define_field already use cpool index format
+- JSRecord with open addressing is fully implemented
+- js_key_hash and js_key_equal work with both immediate and heap text
+- js_key_equal_str enables comparison with C string literals for internal names

playdate/json_playdate.c

@@ -145,12 +145,12 @@ static void encode_js_value(json_encoder *enc, JSContext *js, JSValue val) {
         double d = js2number(js, val);
         if (d == (int)d) enc->writeInt(enc, (int)d);
         else enc->writeDouble(enc, d);
-    } else if (JS_IsString(val)) {
+    } else if (JS_IsText(val)) {
         size_t len;
         const char *str = JS_ToCStringLen(js, &len, val);
         enc->writeString(enc, str, len);
         JS_FreeCString(js, str);
-    } else if (JS_IsArray(js, val)) {
+    } else if (JS_IsArray(val)) {
         encode_js_array(enc, js, val);
     } else if (JS_IsObject(val)) {
         encode_js_object(enc, js, val);

qop.c

@@ -8,10 +8,10 @@ static void js_qop_archive_finalizer(JSRuntime *rt, JSValue val) {
     qop_desc *qop = JS_GetOpaque(val, js_qop_archive_class_id);
     if (qop) {
         if (qop->hashmap) {
-            js_free_rt(rt, qop->hashmap);
+            js_free_rt(qop->hashmap);
         }
         qop_close(qop);
-        js_free_rt(rt, qop);
+        js_free_rt(qop);
     }
 }
 
@@ -34,8 +34,8 @@ static void js_qop_writer_finalizer(JSRuntime *rt, JSValue val) {
     qop_writer *w = JS_GetOpaque(val, js_qop_writer_class_id);
     if (w) {
         if (w->fh) fclose(w->fh);
-        if (w->files) js_free_rt(rt, w->files);
-        js_free_rt(rt, w);
+        if (w->files) js_free_rt(w->files);
+        js_free_rt(w);
     }
 }
 

source/cJSON.h

@@ -0,0 +1,306 @@
+/*
+  Copyright (c) 2009-2017 Dave Gamble and cJSON contributors
+
+  Permission is hereby granted, free of charge, to any person obtaining a copy
+  of this software and associated documentation files (the "Software"), to deal
+  in the Software without restriction, including without limitation the rights
+  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+  copies of the Software, and to permit persons to whom the Software is
+  furnished to do so, subject to the following conditions:
+
+  The above copyright notice and this permission notice shall be included in
+  all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+  THE SOFTWARE.
+*/
+
+#ifndef cJSON__h
+#define cJSON__h
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#if !defined(__WINDOWS__) && (defined(WIN32) || defined(WIN64) || defined(_MSC_VER) || defined(_WIN32))
+#define __WINDOWS__
+#endif
+
+#ifdef __WINDOWS__
+
+/* When compiling for windows, we specify a specific calling convention to avoid issues where we are being called from a project with a different default calling convention.  For windows you have 3 define options:
+
+CJSON_HIDE_SYMBOLS - Define this in the case where you don't want to ever dllexport symbols
+CJSON_EXPORT_SYMBOLS - Define this on library build when you want to dllexport symbols (default)
+CJSON_IMPORT_SYMBOLS - Define this if you want to dllimport symbol
+
+For *nix builds that support visibility attribute, you can define similar behavior by
+
+setting default visibility to hidden by adding
+-fvisibility=hidden (for gcc)
+or
+-xldscope=hidden (for sun cc)
+to CFLAGS
+
+then using the CJSON_API_VISIBILITY flag to "export" the same symbols the way CJSON_EXPORT_SYMBOLS does
+
+*/
+
+#define CJSON_CDECL __cdecl
+#define CJSON_STDCALL __stdcall
+
+/* export symbols by default, this is necessary for copy pasting the C and header file */
+#if !defined(CJSON_HIDE_SYMBOLS) && !defined(CJSON_IMPORT_SYMBOLS) && !defined(CJSON_EXPORT_SYMBOLS)
+#define CJSON_EXPORT_SYMBOLS
+#endif
+
+#if defined(CJSON_HIDE_SYMBOLS)
+#define CJSON_PUBLIC(type)   type CJSON_STDCALL
+#elif defined(CJSON_EXPORT_SYMBOLS)
+#define CJSON_PUBLIC(type)   __declspec(dllexport) type CJSON_STDCALL
+#elif defined(CJSON_IMPORT_SYMBOLS)
+#define CJSON_PUBLIC(type)   __declspec(dllimport) type CJSON_STDCALL
+#endif
+#else /* !__WINDOWS__ */
+#define CJSON_CDECL
+#define CJSON_STDCALL
+
+#if (defined(__GNUC__) || defined(__SUNPRO_CC) || defined (__SUNPRO_C)) && defined(CJSON_API_VISIBILITY)
+#define CJSON_PUBLIC(type)   __attribute__((visibility("default"))) type
+#else
+#define CJSON_PUBLIC(type) type
+#endif
+#endif
+
+/* project version */
+#define CJSON_VERSION_MAJOR 1
+#define CJSON_VERSION_MINOR 7
+#define CJSON_VERSION_PATCH 19
+
+#include <stddef.h>
+
+/* cJSON Types: */
+#define cJSON_Invalid (0)
+#define cJSON_False  (1 << 0)
+#define cJSON_True   (1 << 1)
+#define cJSON_NULL   (1 << 2)
+#define cJSON_Number (1 << 3)
+#define cJSON_String (1 << 4)
+#define cJSON_Array  (1 << 5)
+#define cJSON_Object (1 << 6)
+#define cJSON_Raw    (1 << 7) /* raw json */
+
+#define cJSON_IsReference 256
+#define cJSON_StringIsConst 512
+
+/* The cJSON structure: */
+typedef struct cJSON
+{
+    /* next/prev allow you to walk array/object chains. Alternatively, use GetArraySize/GetArrayItem/GetObjectItem */
+    struct cJSON *next;
+    struct cJSON *prev;
+    /* An array or object item will have a child pointer pointing to a chain of the items in the array/object. */
+    struct cJSON *child;
+
+    /* The type of the item, as above. */
+    int type;
+
+    /* The item's string, if type==cJSON_String  and type == cJSON_Raw */
+    char *valuestring;
+    /* writing to valueint is DEPRECATED, use cJSON_SetNumberValue instead */
+    int valueint;
+    /* The item's number, if type==cJSON_Number */
+    double valuedouble;
+
+    /* The item's name string, if this item is the child of, or is in the list of subitems of an object. */
+    char *string;
+} cJSON;
+
+typedef struct cJSON_Hooks
+{
+      /* malloc/free are CDECL on Windows regardless of the default calling convention of the compiler, so ensure the hooks allow passing those functions directly. */
+      void *(CJSON_CDECL *malloc_fn)(size_t sz);
+      void (CJSON_CDECL *free_fn)(void *ptr);
+} cJSON_Hooks;
+
+typedef int cJSON_bool;
+
+/* Limits how deeply nested arrays/objects can be before cJSON rejects to parse them.
+ * This is to prevent stack overflows. */
+#ifndef CJSON_NESTING_LIMIT
+#define CJSON_NESTING_LIMIT 1000
+#endif
+
+/* Limits the length of circular references can be before cJSON rejects to parse them.
+ * This is to prevent stack overflows. */
+#ifndef CJSON_CIRCULAR_LIMIT
+#define CJSON_CIRCULAR_LIMIT 10000
+#endif
+
+/* returns the version of cJSON as a string */
+CJSON_PUBLIC(const char*) cJSON_Version(void);
+
+/* Supply malloc, realloc and free functions to cJSON */
+CJSON_PUBLIC(void) cJSON_InitHooks(cJSON_Hooks* hooks);
+
+/* Memory Management: the caller is always responsible to free the results from all variants of cJSON_Parse (with cJSON_Delete) and cJSON_Print (with stdlib free, cJSON_Hooks.free_fn, or cJSON_free as appropriate). The exception is cJSON_PrintPreallocated, where the caller has full responsibility of the buffer. */
+/* Supply a block of JSON, and this returns a cJSON object you can interrogate. */
+CJSON_PUBLIC(cJSON *) cJSON_Parse(const char *value);
+CJSON_PUBLIC(cJSON *) cJSON_ParseWithLength(const char *value, size_t buffer_length);
+/* ParseWithOpts allows you to require (and check) that the JSON is null terminated, and to retrieve the pointer to the final byte parsed. */
+/* If you supply a ptr in return_parse_end and parsing fails, then return_parse_end will contain a pointer to the error so will match cJSON_GetErrorPtr(). */
+CJSON_PUBLIC(cJSON *) cJSON_ParseWithOpts(const char *value, const char **return_parse_end, cJSON_bool require_null_terminated);
+CJSON_PUBLIC(cJSON *) cJSON_ParseWithLengthOpts(const char *value, size_t buffer_length, const char **return_parse_end, cJSON_bool require_null_terminated);
+
+/* Render a cJSON entity to text for transfer/storage. */
+CJSON_PUBLIC(char *) cJSON_Print(const cJSON *item);
+/* Render a cJSON entity to text for transfer/storage without any formatting. */
+CJSON_PUBLIC(char *) cJSON_PrintUnformatted(const cJSON *item);
+/* Render a cJSON entity to text using a buffered strategy. prebuffer is a guess at the final size. guessing well reduces reallocation. fmt=0 gives unformatted, =1 gives formatted */
+CJSON_PUBLIC(char *) cJSON_PrintBuffered(const cJSON *item, int prebuffer, cJSON_bool fmt);
+/* Render a cJSON entity to text using a buffer already allocated in memory with given length. Returns 1 on success and 0 on failure. */
+/* NOTE: cJSON is not always 100% accurate in estimating how much memory it will use, so to be safe allocate 5 bytes more than you actually need */
+CJSON_PUBLIC(cJSON_bool) cJSON_PrintPreallocated(cJSON *item, char *buffer, const int length, const cJSON_bool format);
+/* Delete a cJSON entity and all subentities. */
+CJSON_PUBLIC(void) cJSON_Delete(cJSON *item);
+
+/* Returns the number of items in an array (or object). */
+CJSON_PUBLIC(int) cJSON_GetArraySize(const cJSON *array);
+/* Retrieve item number "index" from array "array". Returns NULL if unsuccessful. */
+CJSON_PUBLIC(cJSON *) cJSON_GetArrayItem(const cJSON *array, int index);
+/* Get item "string" from object. Case insensitive. */
+CJSON_PUBLIC(cJSON *) cJSON_GetObjectItem(const cJSON * const object, const char * const string);
+CJSON_PUBLIC(cJSON *) cJSON_GetObjectItemCaseSensitive(const cJSON * const object, const char * const string);
+CJSON_PUBLIC(cJSON_bool) cJSON_HasObjectItem(const cJSON *object, const char *string);
+/* For analysing failed parses. This returns a pointer to the parse error. You'll probably need to look a few chars back to make sense of it. Defined when cJSON_Parse() returns 0. 0 when cJSON_Parse() succeeds. */
+CJSON_PUBLIC(const char *) cJSON_GetErrorPtr(void);
+
+/* Check item type and return its value */
+CJSON_PUBLIC(char *) cJSON_GetStringValue(const cJSON * const item);
+CJSON_PUBLIC(double) cJSON_GetNumberValue(const cJSON * const item);
+
+/* These functions check the type of an item */
+CJSON_PUBLIC(cJSON_bool) cJSON_IsInvalid(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsFalse(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsTrue(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsBool(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsNull(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsNumber(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsString(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsArray(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsObject(const cJSON * const item);
+CJSON_PUBLIC(cJSON_bool) cJSON_IsRaw(const cJSON * const item);
+
+/* These calls create a cJSON item of the appropriate type. */
+CJSON_PUBLIC(cJSON *) cJSON_CreateNull(void);
+CJSON_PUBLIC(cJSON *) cJSON_CreateTrue(void);
+CJSON_PUBLIC(cJSON *) cJSON_CreateFalse(void);
+CJSON_PUBLIC(cJSON *) cJSON_CreateBool(cJSON_bool boolean);
+CJSON_PUBLIC(cJSON *) cJSON_CreateNumber(double num);
+CJSON_PUBLIC(cJSON *) cJSON_CreateString(const char *string);
+/* raw json */
+CJSON_PUBLIC(cJSON *) cJSON_CreateRaw(const char *raw);
+CJSON_PUBLIC(cJSON *) cJSON_CreateArray(void);
+CJSON_PUBLIC(cJSON *) cJSON_CreateObject(void);
+
+/* Create a string where valuestring references a string so
+ * it will not be freed by cJSON_Delete */
+CJSON_PUBLIC(cJSON *) cJSON_CreateStringReference(const char *string);
+/* Create an object/array that only references it's elements so
+ * they will not be freed by cJSON_Delete */
+CJSON_PUBLIC(cJSON *) cJSON_CreateObjectReference(const cJSON *child);
+CJSON_PUBLIC(cJSON *) cJSON_CreateArrayReference(const cJSON *child);
+
+/* These utilities create an Array of count items.
+ * The parameter count cannot be greater than the number of elements in the number array, otherwise array access will be out of bounds.*/
+CJSON_PUBLIC(cJSON *) cJSON_CreateIntArray(const int *numbers, int count);
+CJSON_PUBLIC(cJSON *) cJSON_CreateFloatArray(const float *numbers, int count);
+CJSON_PUBLIC(cJSON *) cJSON_CreateDoubleArray(const double *numbers, int count);
+CJSON_PUBLIC(cJSON *) cJSON_CreateStringArray(const char *const *strings, int count);
+
+/* Append item to the specified array/object. */
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToArray(cJSON *array, cJSON *item);
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToObject(cJSON *object, const char *string, cJSON *item);
+/* Use this when string is definitely const (i.e. a literal, or as good as), and will definitely survive the cJSON object.
+ * WARNING: When this function was used, make sure to always check that (item->type & cJSON_StringIsConst) is zero before
+ * writing to `item->string` */
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToObjectCS(cJSON *object, const char *string, cJSON *item);
+/* Append reference to item to the specified array/object. Use this when you want to add an existing cJSON to a new cJSON, but don't want to corrupt your existing cJSON. */
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item);
+CJSON_PUBLIC(cJSON_bool) cJSON_AddItemReferenceToObject(cJSON *object, const char *string, cJSON *item);
+
+/* Remove/Detach items from Arrays/Objects. */
+CJSON_PUBLIC(cJSON *) cJSON_DetachItemViaPointer(cJSON *parent, cJSON * const item);
+CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromArray(cJSON *array, int which);
+CJSON_PUBLIC(void) cJSON_DeleteItemFromArray(cJSON *array, int which);
+CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObject(cJSON *object, const char *string);
+CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObjectCaseSensitive(cJSON *object, const char *string);
+CJSON_PUBLIC(void) cJSON_DeleteItemFromObject(cJSON *object, const char *string);
+CJSON_PUBLIC(void) cJSON_DeleteItemFromObjectCaseSensitive(cJSON *object, const char *string);
+
+/* Update array items. */
+CJSON_PUBLIC(cJSON_bool) cJSON_InsertItemInArray(cJSON *array, int which, cJSON *newitem); /* Shifts pre-existing items to the right. */
+CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemViaPointer(cJSON * const parent, cJSON * const item, cJSON * replacement);
+CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInArray(cJSON *array, int which, cJSON *newitem);
+CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInObject(cJSON *object,const char *string,cJSON *newitem);
+CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInObjectCaseSensitive(cJSON *object,const char *string,cJSON *newitem);
+
+/* Duplicate a cJSON item */
+CJSON_PUBLIC(cJSON *) cJSON_Duplicate(const cJSON *item, cJSON_bool recurse);
+/* Duplicate will create a new, identical cJSON item to the one you pass, in new memory that will
+ * need to be released. With recurse!=0, it will duplicate any children connected to the item.
+ * The item->next and ->prev pointers are always zero on return from Duplicate. */
+/* Recursively compare two cJSON items for equality. If either a or b is NULL or invalid, they will be considered unequal.
+ * case_sensitive determines if object keys are treated case sensitive (1) or case insensitive (0) */
+CJSON_PUBLIC(cJSON_bool) cJSON_Compare(const cJSON * const a, const cJSON * const b, const cJSON_bool case_sensitive);
+
+/* Minify a strings, remove blank characters(such as ' ', '\t', '\r', '\n') from strings.
+ * The input pointer json cannot point to a read-only address area, such as a string constant, 
+ * but should point to a readable and writable address area. */
+CJSON_PUBLIC(void) cJSON_Minify(char *json);
+
+/* Helper functions for creating and adding items to an object at the same time.
+ * They return the added item or NULL on failure. */
+CJSON_PUBLIC(cJSON*) cJSON_AddNullToObject(cJSON * const object, const char * const name);
+CJSON_PUBLIC(cJSON*) cJSON_AddTrueToObject(cJSON * const object, const char * const name);
+CJSON_PUBLIC(cJSON*) cJSON_AddFalseToObject(cJSON * const object, const char * const name);
+CJSON_PUBLIC(cJSON*) cJSON_AddBoolToObject(cJSON * const object, const char * const name, const cJSON_bool boolean);
+CJSON_PUBLIC(cJSON*) cJSON_AddNumberToObject(cJSON * const object, const char * const name, const double number);
+CJSON_PUBLIC(cJSON*) cJSON_AddStringToObject(cJSON * const object, const char * const name, const char * const string);
+CJSON_PUBLIC(cJSON*) cJSON_AddRawToObject(cJSON * const object, const char * const name, const char * const raw);
+CJSON_PUBLIC(cJSON*) cJSON_AddObjectToObject(cJSON * const object, const char * const name);
+CJSON_PUBLIC(cJSON*) cJSON_AddArrayToObject(cJSON * const object, const char * const name);
+
+/* When assigning an integer value, it needs to be propagated to valuedouble too. */
+#define cJSON_SetIntValue(object, number) ((object) ? (object)->valueint = (object)->valuedouble = (number) : (number))
+/* helper for the cJSON_SetNumberValue macro */
+CJSON_PUBLIC(double) cJSON_SetNumberHelper(cJSON *object, double number);
+#define cJSON_SetNumberValue(object, number) ((object != NULL) ? cJSON_SetNumberHelper(object, (double)number) : (number))
+/* Change the valuestring of a cJSON_String object, only takes effect when type of object is cJSON_String */
+CJSON_PUBLIC(char*) cJSON_SetValuestring(cJSON *object, const char *valuestring);
+
+/* If the object is not a boolean type this does nothing and returns cJSON_Invalid else it returns the new type*/
+#define cJSON_SetBoolValue(object, boolValue) ( \
+    (object != NULL && ((object)->type & (cJSON_False|cJSON_True))) ? \
+    (object)->type=((object)->type &(~(cJSON_False|cJSON_True)))|((boolValue)?cJSON_True:cJSON_False) : \
+    cJSON_Invalid\
+)
+
+/* Macro for iterating over an array or object */
+#define cJSON_ArrayForEach(element, array) for(element = (array != NULL) ? (array)->child : NULL; element != NULL; element = element->next)
+
+/* malloc/free objects using the malloc/free functions that have been set with cJSON_InitHooks */
+CJSON_PUBLIC(void *) cJSON_malloc(size_t size);
+CJSON_PUBLIC(void) cJSON_free(void *object);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

source/cell.c

@@ -2,7 +2,6 @@
 #include <windows.h>
 #endif
 
-#define WOTA_IMPLEMENTATION
 #include "wota.h"
 
 #define STB_DS_IMPLEMENTATION
@@ -10,15 +9,21 @@
 
 #include "cell.h"
 #include "cell_internal.h"
+#include "cJSON.h"
 
 #define ENGINE "internal/engine.cm"
 #define CELL_SHOP_DIR ".cell"
 #define CELL_CORE_DIR "packages/core"
 
+#include <math.h>
 #include <signal.h>
 #include <unistd.h>
 #include <sys/stat.h>
 
+/* Test suite declarations */
+int run_c_test_suite(JSContext *ctx);
+static int run_test_suite(size_t heap_size);
+
 cell_rt *root_cell = NULL;
 static char *core_path = NULL;
 
@@ -100,6 +105,35 @@ static char* load_core_file(const char *filename, size_t *out_size) {
   return data;
 }
 
+static int print_json_errors(const char *json) {
+  if (!json) return 0;
+  cJSON *root = cJSON_Parse(json);
+  if (!root) return 0;
+  cJSON *errors = cJSON_GetObjectItemCaseSensitive(root, "errors");
+  if (!cJSON_IsArray(errors) || cJSON_GetArraySize(errors) == 0) {
+    cJSON_Delete(root);
+    return 0;
+  }
+  const char *filename = "<unknown>";
+  cJSON *fname = cJSON_GetObjectItemCaseSensitive(root, "filename");
+  if (cJSON_IsString(fname))
+    filename = fname->valuestring;
+  cJSON *e;
+  cJSON_ArrayForEach(e, errors) {
+    const char *msg = cJSON_GetStringValue(
+      cJSON_GetObjectItemCaseSensitive(e, "message"));
+    cJSON *line = cJSON_GetObjectItemCaseSensitive(e, "line");
+    cJSON *col = cJSON_GetObjectItemCaseSensitive(e, "column");
+    if (msg && cJSON_IsNumber(line) && cJSON_IsNumber(col))
+      fprintf(stderr, "%s:%d:%d: error: %s\n",
+        filename, (int)line->valuedouble, (int)col->valuedouble, msg);
+    else if (msg)
+      fprintf(stderr, "%s: error: %s\n", filename, msg);
+  }
+  cJSON_Delete(root);
+  return 1;
+}
+
 // Get the core path for use by scripts
 const char* cell_get_core_path(void) {
   return core_path;
@@ -114,20 +148,15 @@ void actor_disrupt(cell_rt *crt)
 
 JSValue js_os_use(JSContext *js);
 JSValue js_math_use(JSContext *js);
+JSValue js_json_use(JSContext *js);
+JSValue js_nota_use(JSContext *js);
+JSValue js_wota_use(JSContext *js);
 
 void script_startup(cell_rt *prt)
 {
-  JSRuntime *rt;
-
-  rt = JS_NewRuntime();
-
-  JSContext *js = JS_NewContextRaw(rt);
-  JS_SetInterruptHandler(rt, actor_interrupt_cb, prt);
-  
-  JS_AddIntrinsicBaseObjects(js);
-  JS_AddIntrinsicEval(js);
-  JS_AddIntrinsicRegExp(js);
-  JS_AddIntrinsicJSON(js);
+  JSRuntime *rt = JS_NewRuntime();
+  JS_SetInterruptHandler(rt, (JSInterruptHandler *)actor_interrupt_cb, prt);
+  JSContext *js = JS_NewContext(rt);
 
   JS_SetContextOpaque(js, prt);
   prt->context = js;
@@ -135,38 +164,7 @@ void script_startup(cell_rt *prt)
   cell_rt *crt = JS_GetContextOpaque(js);
   JS_FreeValue(js, js_blob_use(js));
 
-  JSValue globalThis = JS_GetGlobalObject(js);
-
-  JSValue cell = JS_NewObject(js);
-  JS_SetPropertyStr(js,globalThis,"cell", cell);
-
-  JSValue hidden_fn = JS_NewObject(js);
-
-  JS_SetPropertyStr(js, cell, "hidden", hidden_fn);
-  JS_SetPropertyStr(js, hidden_fn, "os", js_os_use(js));
-
-  crt->actor_sym = JS_NewObject(js);
-  JS_SetPropertyStr(js, hidden_fn, "actorsym", JS_DupValue(js,crt->actor_sym));
-  
-  if (crt->init_wota) {
-    JS_SetPropertyStr(js, hidden_fn, "init", wota2value(js, crt->init_wota));
-    // init wota can now be freed
-    free(crt->init_wota);
-    crt->init_wota = NULL;
-  }
-
-  // Store the core path for scripts to use
-  JSValue js_cell = JS_GetPropertyStr(js, globalThis, "cell");
-  JSValue hidden = JS_GetPropertyStr(js, js_cell, "hidden");
-  if (core_path) {
-    JS_SetPropertyStr(js, hidden, "core_path", JS_NewString(js, core_path));
-  }
-  JS_FreeValue(js, hidden);
-  JS_FreeValue(js, js_cell);
-
-  JS_FreeValue(js, globalThis);
-
-  // Load engine.cm from the core directory
+  // Load and compile engine.cm
   size_t engine_size;
   char *data = load_core_file(ENGINE, &engine_size);
   if (!data) {
@@ -174,9 +172,42 @@ void script_startup(cell_rt *prt)
     return;
   }
 
-  crt->state = ACTOR_RUNNING;
-  JSValue v = JS_Eval(js, data, engine_size, ENGINE, 0);
+  JSValue bytecode = JS_Compile(js, data, engine_size, ENGINE);
   free(data);
+  if (JS_IsException(bytecode)) {
+    uncaught_exception(js, bytecode);
+    return;
+  }
+
+  // Create hidden environment
+  JSValue hidden_env = JS_NewObject(js);
+  JS_SetPropertyStr(js, hidden_env, "os", js_os_use(js));
+  JS_SetPropertyStr(js, hidden_env, "json", js_json_use(js));
+  JS_SetPropertyStr(js, hidden_env, "nota", js_nota_use(js));
+  JS_SetPropertyStr(js, hidden_env, "wota", js_wota_use(js));
+
+  crt->actor_sym = JS_NewObject(js);
+  JS_SetPropertyStr(js, hidden_env, "actorsym", JS_DupValue(js, crt->actor_sym));
+
+  // Always set init (even if null)
+  if (crt->init_wota) {
+    JS_SetPropertyStr(js, hidden_env, "init", wota2value(js, crt->init_wota));
+    free(crt->init_wota);
+    crt->init_wota = NULL;
+  } else {
+    JS_SetPropertyStr(js, hidden_env, "init", JS_NULL);
+  }
+
+  if (core_path) {
+    JS_SetPropertyStr(js, hidden_env, "core_path", JS_NewString(js, core_path));
+  }
+
+  // Stone the environment
+  hidden_env = JS_Stone(js, hidden_env);
+
+  // Integrate and run
+  crt->state = ACTOR_RUNNING;
+  JSValue v = JS_Integrate(js, bytecode, hidden_env);
   uncaught_exception(js, v);
   crt->state = ACTOR_IDLE;
   set_actor_state(crt);
@@ -200,8 +231,547 @@ static void signal_handler(int sig)
   exit_handler();
 }
 
+/* Run the C test suite with minimal runtime setup */
+static int run_test_suite(size_t heap_size)
+{
+  JSRuntime *rt = JS_NewRuntime();
+  if (!rt) {
+    printf("Failed to create JS runtime\n");
+    return 1;
+  }
+
+  JSContext *ctx = JS_NewContextWithHeapSize(rt, heap_size);
+  if (!ctx) {
+    printf("Failed to create JS context\n");
+    JS_FreeRuntime(rt);
+    return 1;
+  }
+
+  int result = run_c_test_suite(ctx);
+
+  JS_FreeContext(ctx);
+  JS_FreeRuntime(rt);
+
+  return result;
+}
+
+/* Run an immediate script string */
+static int run_eval(const char *script_or_file, int print_bytecode, int use_bootstrap_env)
+{
+  if (!find_cell_shop()) return 1;
+
+  /* Check if argument is a file path */
+  struct stat st;
+  char *script = NULL;
+  char *allocated_script = NULL;
+  const char *filename = "<eval>";
+
+  if (stat(script_or_file, &st) == 0 && S_ISREG(st.st_mode)) {
+    /* It's a file, read its contents */
+    FILE *f = fopen(script_or_file, "r");
+    if (!f) {
+      printf("Failed to open file: %s\n", script_or_file);
+      return 1;
+    }
+    allocated_script = malloc(st.st_size + 1);
+    if (!allocated_script) {
+      fclose(f);
+      printf("Failed to allocate memory for script\n");
+      return 1;
+    }
+    size_t read_size = fread(allocated_script, 1, st.st_size, f);
+    fclose(f);
+    allocated_script[read_size] = '\0';
+    script = allocated_script;
+    filename = script_or_file;
+  } else {
+    /* Treat as inline script */
+    script = (char *)script_or_file;
+  }
+
+  JSRuntime *rt = JS_NewRuntime();
+  if (!rt) {
+    printf("Failed to create JS runtime\n");
+    free(allocated_script);
+    return 1;
+  }
+
+  JSContext *ctx = JS_NewContext(rt);
+  if (!ctx) {
+    printf("Failed to create JS context\n");
+    JS_FreeRuntime(rt);
+    free(allocated_script);
+    return 1;
+  }
+
+  int result = 0;
+
+  JSGCRef bytecode_ref;
+  JS_PushGCRef(ctx, &bytecode_ref);
+  bytecode_ref.val = JS_Compile(ctx, script, strlen(script), filename);
+  if (JS_IsException(bytecode_ref.val)) {
+    uncaught_exception(ctx, bytecode_ref.val);
+    JS_PopGCRef(ctx, &bytecode_ref);
+    result = 1;
+  } else {
+    if (print_bytecode) {
+      printf("=== Compiled Bytecode ===\n");
+      JS_DumpFunctionBytecode(ctx, bytecode_ref.val);
+    }
+    JSValue env = JS_NULL;
+    if (use_bootstrap_env) {
+      JSGCRef env_ref, json_ref, nota_ref, wota_ref;
+      JS_PushGCRef(ctx, &env_ref);
+      JS_PushGCRef(ctx, &json_ref);
+      JS_PushGCRef(ctx, &nota_ref);
+      JS_PushGCRef(ctx, &wota_ref);
+      env_ref.val = JS_NewObject(ctx);
+      /* Create modules with GC rooting, then stone them */
+      json_ref.val = js_json_use(ctx);
+      nota_ref.val = js_nota_use(ctx);
+      wota_ref.val = js_wota_use(ctx);
+      JS_SetPropertyStr(ctx, env_ref.val, "json", JS_Stone(ctx, json_ref.val));
+      JS_SetPropertyStr(ctx, env_ref.val, "nota", JS_Stone(ctx, nota_ref.val));
+      JS_SetPropertyStr(ctx, env_ref.val, "wota", JS_Stone(ctx, wota_ref.val));
+      env = JS_Stone(ctx, env_ref.val);
+      JS_PopGCRef(ctx, &wota_ref);
+      JS_PopGCRef(ctx, &nota_ref);
+      JS_PopGCRef(ctx, &json_ref);
+      JS_PopGCRef(ctx, &env_ref);
+    }
+    JSValue v = JS_Integrate(ctx, bytecode_ref.val, env);
+    JS_PopGCRef(ctx, &bytecode_ref);
+    if (JS_IsException(v)) {
+      uncaught_exception(ctx, v);
+      result = 1;
+    } else {
+      JS_FreeValue(ctx, v);
+    }
+  }
+
+  JS_FreeContext(ctx);
+  JS_FreeRuntime(rt);
+  free(allocated_script);
+  return result;
+}
+
 int cell_init(int argc, char **argv)
 {
+  /* Check for --test flag to run C test suite */
+  if (argc >= 2 && strcmp(argv[1], "--test") == 0) {
+    size_t heap_size = 64 * 1024; /* 64KB default */
+    if (argc >= 3) {
+      heap_size = strtoull(argv[2], NULL, 0);
+      /* Round up to power of 2 for buddy allocator */
+      size_t p = 1;
+      while (p < heap_size) p <<= 1;
+      heap_size = p;
+    }
+    return run_test_suite(heap_size);
+  }
+
+  /* Check for --ast flag to output AST JSON */
+  if (argc >= 3 && strcmp(argv[1], "--ast") == 0) {
+    const char *script_or_file = argv[2];
+    char *script = NULL;
+    char *allocated_script = NULL;
+    const char *filename = "<eval>";
+
+    struct stat st;
+    if (stat(script_or_file, &st) == 0 && S_ISREG(st.st_mode)) {
+      FILE *f = fopen(script_or_file, "r");
+      if (!f) {
+        printf("Failed to open file: %s\n", script_or_file);
+        return 1;
+      }
+      allocated_script = malloc(st.st_size + 1);
+      if (!allocated_script) {
+        fclose(f);
+        printf("Failed to allocate memory for script\n");
+        return 1;
+      }
+      size_t read_size = fread(allocated_script, 1, st.st_size, f);
+      fclose(f);
+      allocated_script[read_size] = '\0';
+      script = allocated_script;
+      filename = script_or_file;
+    } else {
+      script = (char *)script_or_file;
+    }
+
+    char *json = JS_AST(script, strlen(script), filename);
+    if (json) {
+      int has_errors = print_json_errors(json);
+      printf("%s\n", json);
+      free(json);
+      free(allocated_script);
+      return has_errors ? 1 : 0;
+    } else {
+      printf("Failed to parse AST\n");
+      free(allocated_script);
+      return 1;
+    }
+  }
+
+  /* Check for --tokenize flag to output token array JSON */
+  if (argc >= 3 && strcmp(argv[1], "--tokenize") == 0) {
+    const char *script_or_file = argv[2];
+    char *script = NULL;
+    char *allocated_script = NULL;
+    const char *filename = "<eval>";
+
+    struct stat st;
+    if (stat(script_or_file, &st) == 0 && S_ISREG(st.st_mode)) {
+      FILE *f = fopen(script_or_file, "r");
+      if (!f) {
+        printf("Failed to open file: %s\n", script_or_file);
+        return 1;
+      }
+      allocated_script = malloc(st.st_size + 1);
+      if (!allocated_script) {
+        fclose(f);
+        printf("Failed to allocate memory for script\n");
+        return 1;
+      }
+      size_t read_size = fread(allocated_script, 1, st.st_size, f);
+      fclose(f);
+      allocated_script[read_size] = '\0';
+      script = allocated_script;
+      filename = script_or_file;
+    } else {
+      script = (char *)script_or_file;
+    }
+
+    char *json = JS_Tokenize(script, strlen(script), filename);
+    if (json) {
+      int has_errors = print_json_errors(json);
+      printf("%s\n", json);
+      free(json);
+      free(allocated_script);
+      return has_errors ? 1 : 0;
+    } else {
+      printf("Failed to tokenize\n");
+      free(allocated_script);
+      return 1;
+    }
+  }
+
+  /* Check for --mcode flag to output MCODE JSON IR */
+  if (argc >= 3 && strcmp(argv[1], "--mcode") == 0) {
+    const char *script_or_file = argv[2];
+    char *script = NULL;
+    char *allocated_script = NULL;
+    const char *filename = "<eval>";
+
+    struct stat st;
+    if (stat(script_or_file, &st) == 0 && S_ISREG(st.st_mode)) {
+      FILE *f = fopen(script_or_file, "r");
+      if (!f) {
+        printf("Failed to open file: %s\n", script_or_file);
+        return 1;
+      }
+      allocated_script = malloc(st.st_size + 1);
+      if (!allocated_script) {
+        fclose(f);
+        printf("Failed to allocate memory for script\n");
+        return 1;
+      }
+      size_t read_size = fread(allocated_script, 1, st.st_size, f);
+      fclose(f);
+      allocated_script[read_size] = '\0';
+      script = allocated_script;
+      filename = script_or_file;
+    } else {
+      script = (char *)script_or_file;
+    }
+
+    char *ast_json = JS_AST(script, strlen(script), filename);
+    if (!ast_json) {
+      printf("Failed to parse AST\n");
+      free(allocated_script);
+      return 1;
+    }
+
+    if (print_json_errors(ast_json)) {
+      free(ast_json);
+      free(allocated_script);
+      return 1;
+    }
+
+    char *mcode_json = JS_Mcode(ast_json);
+    free(ast_json);
+
+    if (!mcode_json) {
+      printf("Failed to generate MCODE\n");
+      free(allocated_script);
+      return 1;
+    }
+
+    printf("%s\n", mcode_json);
+    free(mcode_json);
+
+    free(allocated_script);
+    return 0;
+  }
+
+  /* Check for --run-mcode flag to execute via MCODE interpreter */
+  if (argc >= 3 && strcmp(argv[1], "--run-mcode") == 0) {
+    const char *script_or_file = argv[2];
+    char *script = NULL;
+    char *allocated_script = NULL;
+    const char *filename = "<eval>";
+
+    struct stat st;
+    if (stat(script_or_file, &st) == 0 && S_ISREG(st.st_mode)) {
+      FILE *f = fopen(script_or_file, "r");
+      if (!f) { printf("Failed to open file: %s\n", script_or_file); return 1; }
+      allocated_script = malloc(st.st_size + 1);
+      if (!allocated_script) { fclose(f); printf("Failed to allocate memory\n"); return 1; }
+      size_t read_size = fread(allocated_script, 1, st.st_size, f);
+      fclose(f);
+      allocated_script[read_size] = '\0';
+      script = allocated_script;
+      filename = script_or_file;
+    } else {
+      script = (char *)script_or_file;
+    }
+
+    char *ast_json = JS_AST(script, strlen(script), filename);
+    if (!ast_json) {
+      printf("Failed to parse AST\n");
+      free(allocated_script);
+      return 1;
+    }
+
+    if (print_json_errors(ast_json)) {
+      free(ast_json); free(allocated_script);
+      return 1;
+    }
+
+    char *mcode_json = JS_Mcode(ast_json);
+    free(ast_json);
+
+    if (!mcode_json) {
+      printf("Failed to generate MCODE\n");
+      free(allocated_script);
+      return 1;
+    }
+
+    if (print_json_errors(mcode_json)) {
+      free(mcode_json); free(allocated_script);
+      return 1;
+    }
+
+    /* Use a larger heap context for execution */
+    JSRuntime *rt = JS_NewRuntime();
+    if (!rt) { printf("Failed to create JS runtime\n"); free(mcode_json); free(allocated_script); return 1; }
+    JSContext *ctx = JS_NewContextWithHeapSize(rt, 64 * 1024);
+    if (!ctx) { printf("Failed to create execution context\n"); free(mcode_json); JS_FreeRuntime(rt); free(allocated_script); return 1; }
+
+    JSValue result = JS_CallMcode(ctx, mcode_json);
+    free(mcode_json);
+
+    if (JS_IsException(result)) {
+      JSValue exc = JS_GetException(ctx);
+      const char *str = JS_ToCString(ctx, exc);
+      if (str) { printf("Error: %s\n", str); JS_FreeCString(ctx, str); }
+      cJSON *stack = JS_GetStack(ctx);
+      if (stack) {
+        int n = cJSON_GetArraySize(stack);
+        for (int i = 0; i < n; i++) {
+          cJSON *fr = cJSON_GetArrayItem(stack, i);
+          const char *fn = cJSON_GetStringValue(cJSON_GetObjectItem(fr, "function"));
+          const char *file = cJSON_GetStringValue(cJSON_GetObjectItem(fr, "file"));
+          int line = (int)cJSON_GetNumberValue(cJSON_GetObjectItem(fr, "line"));
+          int col = (int)cJSON_GetNumberValue(cJSON_GetObjectItem(fr, "column"));
+          printf("    at %s (%s:%d:%d)\n", fn ? fn : "<anonymous>", file ? file : "<unknown>", line, col);
+        }
+        cJSON_Delete(stack);
+      }
+      JS_FreeValue(ctx, exc);
+    } else if (!JS_IsNull(result)) {
+      const char *str = JS_ToCString(ctx, result);
+      if (str) { printf("%s\n", str); JS_FreeCString(ctx, str); }
+    }
+
+    JS_FreeContext(ctx);
+    JS_FreeRuntime(rt);
+    free(allocated_script);
+    return JS_IsException(result) ? 1 : 0;
+  }
+
+  /* Check for --mach flag to dump MACH bytecode */
+  if (argc >= 3 && strcmp(argv[1], "--mach") == 0) {
+    const char *script_or_file = argv[2];
+    char *script = NULL;
+    char *allocated_script = NULL;
+    const char *filename = "<eval>";
+
+    struct stat st;
+    if (stat(script_or_file, &st) == 0 && S_ISREG(st.st_mode)) {
+      FILE *f = fopen(script_or_file, "r");
+      if (!f) {
+        printf("Failed to open file: %s\n", script_or_file);
+        return 1;
+      }
+      allocated_script = malloc(st.st_size + 1);
+      if (!allocated_script) {
+        fclose(f);
+        printf("Failed to allocate memory for script\n");
+        return 1;
+      }
+      size_t read_size = fread(allocated_script, 1, st.st_size, f);
+      fclose(f);
+      allocated_script[read_size] = '\0';
+      script = allocated_script;
+      filename = script_or_file;
+    } else {
+      script = (char *)script_or_file;
+    }
+
+    char *ast_json = JS_AST(script, strlen(script), filename);
+    if (!ast_json) {
+      printf("Failed to parse AST\n");
+      free(allocated_script);
+      return 1;
+    }
+
+    if (print_json_errors(ast_json)) {
+      free(ast_json);
+      free(allocated_script);
+      return 1;
+    }
+
+    JSRuntime *rt = JS_NewRuntime();
+    if (!rt) {
+      printf("Failed to create JS runtime\n");
+      free(ast_json); free(allocated_script);
+      return 1;
+    }
+    JSContext *ctx = JS_NewContext(rt);
+    if (!ctx) {
+      printf("Failed to create JS context\n");
+      free(ast_json); JS_FreeRuntime(rt); free(allocated_script);
+      return 1;
+    }
+
+    JS_DumpMach(ctx, ast_json, JS_NULL);
+    free(ast_json);
+
+    JS_FreeContext(ctx);
+    JS_FreeRuntime(rt);
+    free(allocated_script);
+    return 0;
+  }
+
+  /* Check for --mach-run flag to compile and run through MACH VM */
+  if (argc >= 3 && strcmp(argv[1], "--mach-run") == 0) {
+    const char *script_or_file = argv[2];
+    char *script = NULL;
+    char *allocated_script = NULL;
+    const char *filename = "<eval>";
+
+    struct stat st;
+    if (stat(script_or_file, &st) == 0 && S_ISREG(st.st_mode)) {
+      FILE *f = fopen(script_or_file, "r");
+      if (!f) {
+        printf("Failed to open file: %s\n", script_or_file);
+        return 1;
+      }
+      allocated_script = malloc(st.st_size + 1);
+      if (!allocated_script) {
+        fclose(f);
+        printf("Failed to allocate memory for script\n");
+        return 1;
+      }
+      size_t read_size = fread(allocated_script, 1, st.st_size, f);
+      fclose(f);
+      allocated_script[read_size] = '\0';
+      script = allocated_script;
+      filename = script_or_file;
+    } else {
+      script = (char *)script_or_file;
+    }
+
+    char *ast_json = JS_AST(script, strlen(script), filename);
+    if (!ast_json) {
+      printf("Failed to parse AST\n");
+      free(allocated_script);
+      return 1;
+    }
+
+    if (print_json_errors(ast_json)) {
+      free(ast_json);
+      free(allocated_script);
+      return 1;
+    }
+
+    JSRuntime *rt = JS_NewRuntime();
+    if (!rt) {
+      printf("Failed to create JS runtime\n");
+      free(ast_json); free(allocated_script);
+      return 1;
+    }
+    JSContext *ctx = JS_NewContext(rt);
+    if (!ctx) {
+      printf("Failed to create JS context\n");
+      free(ast_json); JS_FreeRuntime(rt); free(allocated_script);
+      return 1;
+    }
+
+    JSValue result = JS_RunMach(ctx, ast_json, JS_NULL);
+    free(ast_json);
+
+    int exit_code = 0;
+    if (JS_IsException(result)) {
+      JSValue exc = JS_GetException(ctx);
+      const char *err_str = JS_ToCString(ctx, exc);
+      if (err_str) {
+        printf("Error: %s\n", err_str);
+        JS_FreeCString(ctx, err_str);
+      }
+      cJSON *stack = JS_GetStack(ctx);
+      if (stack) {
+        int n = cJSON_GetArraySize(stack);
+        for (int i = 0; i < n; i++) {
+          cJSON *fr = cJSON_GetArrayItem(stack, i);
+          const char *fn = cJSON_GetStringValue(cJSON_GetObjectItem(fr, "function"));
+          const char *file = cJSON_GetStringValue(cJSON_GetObjectItem(fr, "file"));
+          int line = (int)cJSON_GetNumberValue(cJSON_GetObjectItem(fr, "line"));
+          int col = (int)cJSON_GetNumberValue(cJSON_GetObjectItem(fr, "column"));
+          printf("    at %s (%s:%d:%d)\n", fn ? fn : "<anonymous>", file ? file : "<unknown>", line, col);
+        }
+        cJSON_Delete(stack);
+      }
+      JS_FreeValue(ctx, exc);
+      exit_code = 1;
+    } else if (!JS_IsNull(result)) {
+      const char *str = JS_ToCString(ctx, result);
+      if (str) {
+        printf("%s\n", str);
+        JS_FreeCString(ctx, str);
+      }
+    }
+
+    JS_FreeContext(ctx);
+    JS_FreeRuntime(rt);
+    free(allocated_script);
+    return exit_code;
+  }
+
+  /* Check for -e or --eval flag to run immediate script */
+  /* Also check for -p flag to print bytecode */
+  /* -s / --serializers flag provides json, nota, wota in env */
+  if (argc >= 3 && (strcmp(argv[1], "-e") == 0 || strcmp(argv[1], "--eval") == 0)) {
+    return run_eval(argv[2], 0, 0);
+  }
+  if (argc >= 3 && (strcmp(argv[1], "-p") == 0 || strcmp(argv[1], "--print-bytecode") == 0)) {
+    return run_eval(argv[2], 1, 0);
+  }
+  if (argc >= 3 && (strcmp(argv[1], "-s") == 0 || strcmp(argv[1], "--serializers") == 0)) {
+    return run_eval(argv[2], 0, 1);
+  }
+
   int script_start = 1;
 
   /* Find the cell shop at ~/.cell */

source/cell.h

@@ -28,6 +28,13 @@ JSValue number2js(JSContext *js, double g);
 JSValue wota2value(JSContext *js, void *v);
 void *value2wota(JSContext *js, JSValue v, JSValue replacer, size_t *bytes);
 
+JSValue nota2value(JSContext *js, void *nota);
+void *value2nota(JSContext *js, JSValue v);
+
+JSValue js_json_use(JSContext *js);
+JSValue js_nota_use(JSContext *js);
+JSValue js_wota_use(JSContext *js);
+
 #define CELL_HOOK_ENTER 1
 #define CELL_HOOK_EXIT 2
 typedef void (*cell_hook)(const char *name, int type);

source/qjs_wota.c

@@ -1,396 +0,0 @@
-#include "cell.h"
-#include "cell_internal.h"
-
-#include "wota.h"
-#include <stdlib.h>
-
-typedef struct ObjectRef {
-  void *ptr;
-  struct ObjectRef *next;
-} ObjectRef;
-
-typedef struct WotaEncodeContext {
-  JSContext *ctx;
-  ObjectRef *visited_stack;
-  WotaBuffer wb;
-  int cycle;
-  JSValue replacer;
-} WotaEncodeContext;
-
-static void wota_stack_push(WotaEncodeContext *enc, JSValueConst val)
-{
-  if (!JS_IsObject(val)) return;
-  
-  ObjectRef *ref = malloc(sizeof(ObjectRef));
-  if (!ref) return;
-  
-  ref->ptr = JS_VALUE_GET_PTR(val);
-  ref->next = enc->visited_stack;
-  enc->visited_stack = ref;
-}
-
-static void wota_stack_pop(WotaEncodeContext *enc)
-{
-  if (!enc->visited_stack) return;
-  
-  ObjectRef *top = enc->visited_stack;
-  enc->visited_stack = top->next;
-  free(top);
-}
-
-static int wota_stack_has(WotaEncodeContext *enc, JSValueConst val)
-{
-  if (!JS_IsObject(val)) return 0;
-  
-  void *ptr = JS_VALUE_GET_PTR(val);
-  ObjectRef *current = enc->visited_stack;
-  
-  while (current) {
-    if (current->ptr == ptr) return 1;
-    current = current->next;
-  }
-  return 0;
-}
-
-static void wota_stack_free(WotaEncodeContext *enc)
-{
-  while (enc->visited_stack) {
-    wota_stack_pop(enc);
-  }
-}
-
-static JSValue apply_replacer(WotaEncodeContext *enc, JSValueConst holder, JSAtom key, JSValueConst val)
-{
-  if (JS_IsNull(enc->replacer)) return JS_DupValue(enc->ctx, val);
-  JSValue key_val = (key == JS_ATOM_NULL) ? JS_NULL : JS_AtomToValue(enc->ctx, key);
-  JSValue args[2] = { key_val, JS_DupValue(enc->ctx, val) };
-  JSValue result = JS_Call(enc->ctx, enc->replacer, holder, 2, args);
-  JS_FreeValue(enc->ctx, args[0]);
-  JS_FreeValue(enc->ctx, args[1]);
-  if (JS_IsException(result)) return JS_DupValue(enc->ctx, val);
-  return result;
-}
-
-static void wota_encode_value(WotaEncodeContext *enc, JSValueConst val, JSValueConst holder, JSAtom key);
-
-static void encode_object_properties(WotaEncodeContext *enc, JSValueConst val, JSValueConst holder)
-{
-  JSContext *ctx = enc->ctx;
-  JSPropertyEnum *ptab;
-  uint32_t plen;
-  if (JS_GetOwnPropertyNames(ctx, &ptab, &plen, val, JS_GPN_ENUM_ONLY | JS_GPN_STRING_MASK) < 0) {
-    wota_write_sym(&enc->wb, WOTA_NULL);
-    return;
-  }
-  uint32_t non_function_count = 0;
-  JSValue props[plen];
-  JSAtom atoms[plen];
-  
-  for (uint32_t i = 0; i < plen; i++) {
-    JSValue prop_val = JS_GetProperty(ctx, val, ptab[i].atom);
-    if (!JS_IsFunction(prop_val)) {
-      atoms[non_function_count] = ptab[i].atom;
-      props[non_function_count++] = prop_val;
-    } else
-      JS_FreeValue(ctx, prop_val);
-  }
-  wota_write_record(&enc->wb, non_function_count);
-  for (uint32_t i = 0; i < non_function_count; i++) {
-    size_t plen;
-    const char *prop_name = JS_AtomToCStringLen(ctx, &plen, atoms[i]);
-    JSValue prop_val = props[i];
-    wota_write_text_len(&enc->wb, prop_name, plen);
-    wota_encode_value(enc, prop_val, val, atoms[i]);
-    JS_FreeCString(ctx, prop_name);
-    JS_FreeValue(ctx, prop_val);
-  }
-
-  for (int i = 0; i < plen; i++)
-    JS_FreeAtom(ctx, ptab[i].atom);
-
-  js_free(ctx, ptab);
-}
-
-static void wota_encode_value(WotaEncodeContext *enc, JSValueConst val, JSValueConst holder, JSAtom key)
-{
-  JSContext *ctx = enc->ctx;
-  JSValue replaced;
-  if (!JS_IsNull(enc->replacer) && key != JS_ATOM_NULL)
-    replaced = apply_replacer(enc, holder, key, val);
-  else
-    replaced = JS_DupValue(enc->ctx, val);
-    
-  int tag = JS_VALUE_GET_TAG(replaced);
-  switch (tag) {
-    case JS_TAG_INT: {
-      int32_t d;
-      JS_ToInt32(ctx, &d, replaced);
-      wota_write_int_word(&enc->wb, d);
-      break;
-    }
-    case JS_TAG_FLOAT64: {
-      double d;
-      if (JS_ToFloat64(ctx, &d, replaced) < 0) {
-        wota_write_sym(&enc->wb, WOTA_NULL);
-        break;
-      }
-      wota_write_float_word(&enc->wb, d);
-      break;
-    }
-    case JS_TAG_STRING: {
-      size_t plen;
-      const char *str = JS_ToCStringLen(ctx, &plen, replaced);
-      wota_write_text_len(&enc->wb, str ? str : "", str ? plen : 0);
-      JS_FreeCString(ctx, str);
-      break;
-    }
-    case JS_TAG_BOOL:
-      wota_write_sym(&enc->wb, JS_VALUE_GET_BOOL(replaced) ? WOTA_TRUE : WOTA_FALSE);
-      break;
-    case JS_TAG_NULL:
-      wota_write_sym(&enc->wb, WOTA_NULL);
-      break;
-    case JS_TAG_OBJECT: {
-      if (js_is_blob(ctx, replaced)) {
-        size_t buf_len;
-        void *buf_data = js_get_blob_data(ctx, &buf_len, replaced);
-        if (buf_data == (void *)-1) {
-          JS_FreeValue(ctx, replaced);
-          return; // JS_EXCEPTION will be handled by caller
-        }
-        if (buf_len == 0) {
-          wota_write_blob(&enc->wb, 0, "");
-        } else {
-          wota_write_blob(&enc->wb, (unsigned long long)buf_len * 8, (const char *)buf_data);
-        }
-        break;
-      }
-      if (JS_IsArray(ctx, replaced)) {
-        if (wota_stack_has(enc, replaced)) {
-          enc->cycle = 1;
-          break;
-        }
-        wota_stack_push(enc, replaced);
-        int64_t arr_len;
-        JS_GetLength(ctx, replaced, &arr_len);
-        wota_write_array(&enc->wb, arr_len);
-        for (int64_t i = 0; i < arr_len; i++) {
-          JSValue elem_val = JS_GetPropertyUint32(ctx, replaced, i);
-          JSAtom idx_atom = JS_NewAtomUInt32(ctx, (uint32_t)i);
-          wota_encode_value(enc, elem_val, replaced, idx_atom);
-          JS_FreeAtom(ctx, idx_atom);
-          JS_FreeValue(ctx, elem_val);
-        }
-        wota_stack_pop(enc);
-        break;
-      }
-      cell_rt *crt = JS_GetContextOpaque(ctx);
-//      JSValue adata = JS_GetProperty(ctx, replaced, crt->actor_sym);
-      JSValue adata = JS_NULL;
-      if (!JS_IsNull(adata)) {
-        wota_write_sym(&enc->wb, WOTA_PRIVATE);
-        wota_encode_value(enc, adata, replaced, JS_ATOM_NULL);
-        JS_FreeValue(ctx, adata);
-        break;
-      }
-      JS_FreeValue(ctx, adata);
-      if (wota_stack_has(enc, replaced)) {
-        enc->cycle = 1;
-        break;
-      }
-      wota_stack_push(enc, replaced);
-      JSValue to_json = JS_GetPropertyStr(ctx, replaced, "toJSON");
-      if (JS_IsFunction(to_json)) {
-        JSValue result = JS_Call(ctx, to_json, replaced, 0, NULL);
-        JS_FreeValue(ctx, to_json);
-        if (!JS_IsException(result)) {
-          wota_encode_value(enc, result, holder, key);
-          JS_FreeValue(ctx, result);
-        } else
-          wota_write_sym(&enc->wb, WOTA_NULL);
-        wota_stack_pop(enc);
-        break;
-      }
-      JS_FreeValue(ctx, to_json);
-      encode_object_properties(enc, replaced, holder);
-      wota_stack_pop(enc);
-      break;
-    }
-    default:
-      wota_write_sym(&enc->wb, WOTA_NULL);
-      break;
-  }
-  JS_FreeValue(ctx, replaced);
-}
-
-static char *decode_wota_value(JSContext *ctx, char *data_ptr, JSValue *out_val, JSValue holder, JSAtom key, JSValue reviver)
-{
-  uint64_t first_word = *(uint64_t *)data_ptr;
-  int type = (int)(first_word & 0xffU);
-  switch (type) {
-    case WOTA_INT: {
-      long long val;
-      data_ptr = wota_read_int(&val, data_ptr);
-      *out_val = JS_NewInt64(ctx, val);
-      break;
-    }
-    case WOTA_FLOAT: {
-      double d;
-      data_ptr = wota_read_float(&d, data_ptr);
-      *out_val = JS_NewFloat64(ctx, d);
-      break;
-    }
-    case WOTA_SYM: {
-      int scode;
-      data_ptr = wota_read_sym(&scode, data_ptr);
-      if (scode == WOTA_PRIVATE) {
-        JSValue inner = JS_NULL;
-        data_ptr = decode_wota_value(ctx, data_ptr, &inner, holder, JS_ATOM_NULL, reviver);
-        JSValue obj = JS_NewObject(ctx);
-        cell_rt *crt = JS_GetContextOpaque(ctx);
-//        JS_SetProperty(ctx, obj, crt->actor_sym, inner);
-        *out_val = obj;
-      } else if (scode == WOTA_NULL) *out_val = JS_NULL;
-      else if (scode == WOTA_FALSE) *out_val = JS_NewBool(ctx, 0);
-      else if (scode == WOTA_TRUE) *out_val = JS_NewBool(ctx, 1);
-      else *out_val = JS_NULL;
-      break;
-    }
-    case WOTA_BLOB: {
-      long long blen;
-      char *bdata = NULL;
-      data_ptr = wota_read_blob(&blen, &bdata, data_ptr);
-      *out_val = bdata ? js_new_blob_stoned_copy(ctx, (uint8_t *)bdata, (size_t)blen) : js_new_blob_stoned_copy(ctx, NULL, 0);
-      if (bdata) free(bdata);
-      break;
-    }
-    case WOTA_TEXT: {
-      char *utf8 = NULL;
-      data_ptr = wota_read_text(&utf8, data_ptr);
-      *out_val = JS_NewString(ctx, utf8 ? utf8 : "");
-      if (utf8) free(utf8);
-      break;
-    }
-    case WOTA_ARR: {
-      long long c;
-      data_ptr = wota_read_array(&c, data_ptr);
-      JSValue arr = JS_NewArrayLen(ctx, c);
-      for (long long i = 0; i < c; i++) {
-        JSValue elem_val = JS_NULL;
-        JSAtom idx_atom = JS_NewAtomUInt32(ctx, (uint32_t)i);
-        data_ptr = decode_wota_value(ctx, data_ptr, &elem_val, arr, idx_atom, reviver);
-        JS_SetPropertyUint32(ctx, arr, i, elem_val);
-        JS_FreeAtom(ctx, idx_atom);
-      }
-      *out_val = arr;
-      break;
-    }
-    case WOTA_REC: {
-      long long c;
-      data_ptr = wota_read_record(&c, data_ptr);
-      JSValue obj = JS_NewObject(ctx);
-      for (long long i = 0; i < c; i++) {
-        char *tkey = NULL;
-        size_t key_len;
-        data_ptr = wota_read_text_len(&key_len, &tkey, data_ptr);
-        if (!tkey) continue; // invalid key
-        JSAtom prop_key = JS_NewAtomLen(ctx, tkey, key_len);
-        JSValue sub_val = JS_NULL;
-        data_ptr = decode_wota_value(ctx, data_ptr, &sub_val, obj, prop_key, reviver);
-        JS_SetProperty(ctx, obj, prop_key, sub_val);
-        JS_FreeAtom(ctx, prop_key);
-        free(tkey);
-      }
-      *out_val = obj;
-      break;
-    }
-    default:
-      data_ptr += 8;
-      *out_val = JS_NULL;
-      break;
-  }
-  if (!JS_IsNull(reviver)) {
-    JSValue key_val = (key == JS_ATOM_NULL) ? JS_NULL : JS_AtomToValue(ctx, key);
-    JSValue args[2] = { key_val, JS_DupValue(ctx, *out_val) };
-    JSValue revived = JS_Call(ctx, reviver, holder, 2, args);
-    JS_FreeValue(ctx, args[0]);
-    JS_FreeValue(ctx, args[1]);
-    if (!JS_IsException(revived)) {
-      JS_FreeValue(ctx, *out_val);
-      *out_val = revived;
-    } else
-      JS_FreeValue(ctx, revived);
-  }
-  return data_ptr;
-}
-
-void *value2wota(JSContext *ctx, JSValue v, JSValue replacer, size_t *bytes)
-{
-  WotaEncodeContext enc_s, *enc = &enc_s;
-  
-  enc->ctx = ctx;
-  enc->visited_stack = NULL;
-  enc->cycle = 0;
-  enc->replacer = replacer;
-  wota_buffer_init(&enc->wb, 16);
-  wota_encode_value(enc, v, JS_NULL, JS_ATOM_NULL);
-  if (enc->cycle) {
-    wota_stack_free(enc);
-    wota_buffer_free(&enc->wb);
-    return NULL;
-  }
-  wota_stack_free(enc);
-  size_t total_bytes = enc->wb.size * sizeof(uint64_t);
-  void *wota = realloc(enc->wb.data, total_bytes);
-  if (bytes) *bytes = total_bytes;
-  return wota;
-}
-
-JSValue wota2value(JSContext *ctx, void *wota)
-{
-  JSValue result = JS_NULL;
-  JSValue holder = JS_NewObject(ctx);
-  decode_wota_value(ctx, wota, &result, holder, JS_ATOM_NULL, JS_NULL);
-  JS_FreeValue(ctx, holder);
-  return result;
-}
-
-static JSValue js_wota_encode(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv)
-{
-  if (argc < 1) return JS_ThrowTypeError(ctx, "wota.encode requires at least 1 argument");
-  size_t total_bytes;
-  void *wota = value2wota(ctx, argv[0], JS_IsFunction(argv[1]) ? argv[1] : JS_NULL, &total_bytes);
-  JSValue ret = js_new_blob_stoned_copy(ctx, wota, total_bytes);
-  free(wota);
-  return ret;
-}
-
-static JSValue js_wota_decode(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv)
-{
-  if (argc < 1) return JS_NULL;
-  size_t len;
-  uint8_t *buf = js_get_blob_data(ctx, &len, argv[0]);
-  if (buf == (uint8_t *)-1) return JS_EXCEPTION;
-  if (!buf || len == 0) return JS_ThrowTypeError(ctx, "No blob data present");
-  JSValue reviver = (argc > 1 && JS_IsFunction(argv[1])) ? argv[1] : JS_NULL;
-  char *data_ptr = (char *)buf;
-  JSValue result = JS_NULL;
-  JSValue holder = JS_NewObject(ctx);
-  JSAtom empty_atom = JS_NewAtom(ctx, "");
-  decode_wota_value(ctx, data_ptr, &result, holder, empty_atom, reviver);
-  JS_FreeAtom(ctx, empty_atom);
-  JS_FreeValue(ctx, holder);
-  return result;
-}
-
-static const JSCFunctionListEntry js_wota_funcs[] = {
-  JS_CFUNC_DEF("encode", 2, js_wota_encode),
-  JS_CFUNC_DEF("decode", 2, js_wota_decode),
-};
-
-JSValue js_wota_use(JSContext *ctx)
-{
-  JSValue exports = JS_NewObject(ctx);
-  JS_SetPropertyFunctionList(ctx, exports, js_wota_funcs, sizeof(js_wota_funcs)/sizeof(js_wota_funcs[0]));
-  return exports;
-}

source/quickjs-opcode.h

@@ -28,7 +28,6 @@ FMT(none)
 FMT(none_int)
 FMT(none_loc)
 FMT(none_arg)
-FMT(none_var_ref)
 FMT(u8)
 FMT(i8)
 FMT(loc8)
@@ -42,17 +41,16 @@ FMT(npopx)
 FMT(npop_u16)
 FMT(loc)
 FMT(arg)
-FMT(var_ref)
 FMT(u32)
 FMT(i32)
 FMT(const)
 FMT(label)
-FMT(atom)
-FMT(atom_u8)
-FMT(atom_u16)
-FMT(atom_label_u8)
-FMT(atom_label_u16)
 FMT(label_u16)
+FMT(key)
+FMT(key_u8)
+FMT(key_u16)
+FMT(key_label_u16)
+FMT(u8_u16)  /* 1 byte + 2 bytes for upvalue access */
 #undef FMT
 #endif /* FMT */
 
@@ -68,7 +66,6 @@ DEF(invalid, 1, 0, 0, none) /* never emitted */
 DEF(       push_i32, 5, 0, 1, i32)
 DEF(     push_const, 5, 0, 1, const)
 DEF(       fclosure, 5, 0, 1, const) /* must follow push_const */
-DEF(push_atom_value, 5, 0, 1, atom)
 DEF(           null, 1, 0, 1, none)
 DEF(      push_this, 1, 0, 1, none) /* only used at the start of a function */
 DEF(     push_false, 1, 0, 1, none)
@@ -104,40 +101,38 @@ DEF(     array_from, 3, 0, 1, npop) /* arguments are not counted in n_pop */
 DEF(         return, 1, 1, 0, none)
 DEF(   return_undef, 1, 0, 0, none)
 DEF(          throw, 1, 1, 0, none)
-DEF(    throw_error, 6, 0, 0, atom_u8)
-DEF(           eval, 5, 1, 1, npop_u16) /* func args... -> ret_val */
+DEF(    throw_error, 6, 0, 0, key_u8)
 DEF(         regexp, 1, 2, 1, none) /* create a RegExp object from the pattern and a
                                        bytecode string */
 
-DEF(      check_var, 5, 0, 1, atom) /* check if a variable exists */
-DEF(  get_var_undef, 5, 0, 1, atom) /* push undefined if the variable does not exist */
-DEF(        get_var, 5, 0, 1, atom) /* throw an exception if the variable does not exist */
-DEF(        put_var, 5, 1, 0, atom) /* must come after get_var */
-DEF(   put_var_init, 5, 1, 0, atom) /* must come after put_var. Used to initialize a global lexical variable */
-DEF( put_var_strict, 5, 2, 0, atom) /* for strict mode variable write */
+/* Global variable access - resolved by linker to get/set_global_slot */
+DEF(      check_var, 5, 0, 1, key) /* check if a variable exists - resolved by linker */
+DEF(  get_var_undef, 5, 0, 1, key) /* resolved by linker to get_global_slot */
+DEF(        get_var, 5, 0, 1, key) /* resolved by linker to get_global_slot */
+DEF(        put_var, 5, 1, 0, key) /* resolved by linker to set_global_slot */
+DEF(   put_var_init, 5, 1, 0, key) /* resolved by linker to set_global_slot */
+DEF( put_var_strict, 5, 2, 0, key) /* resolved by linker to set_global_slot */
 
-DEF(  get_ref_value, 1, 2, 3, none)
-DEF(  put_ref_value, 1, 3, 0, none)
-
-DEF(     define_var, 6, 0, 0, atom_u8)
-DEF(check_define_var, 6, 0, 0, atom_u8)
-DEF(    define_func, 6, 1, 0, atom_u8)
-DEF(      get_field, 5, 1, 1, atom)
-DEF(     get_field2, 5, 1, 2, atom)
-DEF(      put_field, 5, 2, 0, atom)
+/* Global variable opcodes - resolved by linker to get/set_global_slot */
+DEF(     define_var, 6, 0, 0, key_u8)
+DEF(check_define_var, 6, 0, 0, key_u8)
+DEF(    define_func, 6, 1, 0, key_u8)
+DEF(      get_field, 5, 1, 1, key)
+DEF(     get_field2, 5, 1, 2, key)
+DEF(      put_field, 5, 2, 0, key)
 DEF(   get_array_el, 1, 2, 1, none)
 DEF(  get_array_el2, 1, 2, 2, none) /* obj prop -> obj value */
 DEF(  get_array_el3, 1, 2, 3, none) /* obj prop -> obj prop1 value */
 DEF(   put_array_el, 1, 3, 0, none)
-DEF(   define_field, 5, 2, 1, atom)
-DEF(       set_name, 5, 1, 1, atom)
+DEF(   define_field, 5, 2, 1, key)
+DEF(       set_name, 5, 1, 1, key)
 DEF(set_name_computed, 1, 2, 2, none)
 DEF(define_array_el, 1, 3, 2, none)
 DEF(copy_data_properties, 2, 3, 3, u8)
-DEF(  define_method, 6, 2, 1, atom_u8)
+DEF(  define_method, 6, 2, 1, key_u8)
 DEF(define_method_computed, 2, 3, 1, u8) /* must come after define_method */
-DEF(   define_class, 6, 2, 2, atom_u8) /* parent ctor -> ctor proto */
-DEF(   define_class_computed, 6, 3, 3, atom_u8) /* field_name parent ctor -> field_name ctor proto (class with computed name) */
+DEF(   define_class, 6, 2, 2, key_u8) /* parent ctor -> ctor proto */
+DEF(   define_class_computed, 6, 3, 3, key_u8) /* field_name parent ctor -> field_name ctor proto (class with computed name) */
 
 DEF(        get_loc, 3, 0, 1, loc)
 DEF(        put_loc, 3, 1, 0, loc) /* must come after get_loc */
@@ -145,18 +140,11 @@ DEF(        set_loc, 3, 1, 1, loc) /* must come after put_loc */
 DEF(        get_arg, 3, 0, 1, arg)
 DEF(        put_arg, 3, 1, 0, arg) /* must come after get_arg */
 DEF(        set_arg, 3, 1, 1, arg) /* must come after put_arg */
-DEF(    get_var_ref, 3, 0, 1, var_ref)
-DEF(    put_var_ref, 3, 1, 0, var_ref) /* must come after get_var_ref */
-DEF(    set_var_ref, 3, 1, 1, var_ref) /* must come after put_var_ref */
 DEF(set_loc_uninitialized, 3, 0, 0, loc)
 DEF(  get_loc_check, 3, 0, 1, loc)
 DEF(  put_loc_check, 3, 1, 0, loc) /* must come after get_loc_check */
 DEF(  put_loc_check_init, 3, 1, 0, loc)
 DEF(get_loc_checkthis, 3, 0, 1, loc)
-DEF(get_var_ref_check, 3, 0, 1, var_ref)
-DEF(put_var_ref_check, 3, 1, 0, var_ref) /* must come after get_var_ref_check */
-DEF(put_var_ref_check_init, 3, 1, 0, var_ref)
-DEF(      close_loc, 3, 0, 0, loc)
 DEF(       if_false, 5, 1, 0, label)
 DEF(        if_true, 5, 1, 0, label) /* must come after if_false */
 DEF(           goto, 5, 0, 0, label) /* must come after if_true */
@@ -165,15 +153,8 @@ DEF(          gosub, 5, 0, 0, label) /* used to execute the finally block */
 DEF(            ret, 1, 1, 0, none) /* used to return from the finally block */
 DEF(      nip_catch, 1, 2, 1, none) /* catch ... a -> a */
 
-DEF(      to_object, 1, 1, 1, none)
-//DEF(      to_string, 1, 1, 1, none)
 DEF(     to_propkey, 1, 1, 1, none)
 
-DEF(   make_loc_ref, 7, 0, 2, atom_u16)
-DEF(   make_arg_ref, 7, 0, 2, atom_u16)
-DEF(make_var_ref_ref, 7, 0, 2, atom_u16)
-DEF(   make_var_ref, 5, 0, 2, atom)
-
 /* arithmetic/logic operations */
 DEF(            neg, 1, 1, 1, none)
 DEF(           plus, 1, 1, 1, none)
@@ -187,7 +168,7 @@ DEF(        add_loc, 2, 1, 0, loc8)
 DEF(            not, 1, 1, 1, none)
 DEF(           lnot, 1, 1, 1, none)
 DEF(         delete, 1, 2, 1, none)
-DEF(     delete_var, 5, 0, 1, atom)
+DEF(     delete_var, 5, 0, 1, key)  /* deprecated - global object is immutable */
 
 DEF(            mul, 1, 2, 1, none)
 DEF(      mul_float, 1, 2, 1, none)
@@ -212,8 +193,21 @@ DEF(     strict_neq, 1, 2, 1, none)
 DEF(            and, 1, 2, 1, none)
 DEF(            xor, 1, 2, 1, none)
 DEF(             or, 1, 2, 1, none)
-/* template literal concatenation - pops N parts, pushes concatenated string */
-DEF(template_concat, 3, 0, 1, npop_u16)
+/* format template - format_string_cpool_idx(u32), expr_count(u16)
+   Note: n_push=2 ensures stack has room for temp [format_str, arr] pair,
+   even though we only leave 1 value (the result) on the stack. */
+DEF(format_template, 7, 0, 1, npop_u16)
+
+/* Upvalue access (closures via outer_frame chain) */
+DEF(        get_up, 4, 0, 1, u8_u16)  /* depth:u8, slot:u16 -> value */
+DEF(        set_up, 4, 1, 0, u8_u16)  /* value, depth:u8, slot:u16 -> */
+
+/* Name resolution with bytecode patching */
+DEF(      get_name, 5, 0, 1, const)   /* cpool_idx -> value, patches itself */
+DEF(  get_env_slot, 3, 0, 1, u16)     /* slot -> value (patched from get_name) */
+DEF(  set_env_slot, 3, 1, 0, u16)     /* value -> slot (patched from put_var) */
+DEF(get_global_slot, 3, 0, 1, u16)    /* slot -> value (patched from get_var) */
+DEF(set_global_slot, 3, 1, 0, u16)    /* value -> slot (patched from put_var) */
 
 /* must be the last non short and non temporary opcode */
 DEF(            nop, 1, 0, 0, none)
@@ -227,15 +221,13 @@ def(          label, 5, 0, 0, label) /* emitted in phase 1, removed in phase 3 *
 
 /* the following opcodes must be in the same order as the 'with_x' and
    get_var_undef, get_var and put_var opcodes */
-def(scope_get_var_undef, 7, 0, 1, atom_u16) /* emitted in phase 1, removed in phase 2 */
-def(  scope_get_var, 7, 0, 1, atom_u16) /* emitted in phase 1, removed in phase 2 */
-def(  scope_put_var, 7, 1, 0, atom_u16) /* emitted in phase 1, removed in phase 2 */
-def(scope_delete_var, 7, 0, 1, atom_u16) /* emitted in phase 1, removed in phase 2 */
-def( scope_make_ref, 11, 0, 2, atom_label_u16) /* emitted in phase 1, removed in phase 2 */
-def(  scope_get_ref, 7, 0, 2, atom_u16) /* emitted in phase 1, removed in phase 2 */
-def(scope_put_var_init, 7, 0, 2, atom_u16) /* emitted in phase 1, removed in phase 2 */
-def(scope_get_var_checkthis, 7, 0, 1, atom_u16) /* emitted in phase 1, removed in phase 2, only used to return 'this' in derived class constructors */
-def(get_field_opt_chain, 5, 1, 1, atom) /* emitted in phase 1, removed in phase 2 */
+def(scope_get_var_undef, 7, 0, 1, key_u16) /* emitted in phase 1, removed in phase 2 */
+def(  scope_get_var, 7, 0, 1, key_u16) /* emitted in phase 1, removed in phase 2 */
+def(  scope_put_var, 7, 1, 0, key_u16) /* emitted in phase 1, removed in phase 2 */
+def(scope_delete_var, 7, 0, 1, key_u16) /* emitted in phase 1, removed in phase 2 */
+def(scope_put_var_init, 7, 0, 2, key_u16) /* emitted in phase 1, removed in phase 2 */
+def(scope_get_var_checkthis, 7, 0, 1, key_u16) /* emitted in phase 1, removed in phase 2, only used to return 'this' in derived class constructors */
+def(get_field_opt_chain, 5, 1, 1, key) /* emitted in phase 1, removed in phase 2 */
 def(get_array_el_opt_chain, 1, 2, 1, none) /* emitted in phase 1, removed in phase 2 */
 def( set_class_name, 5, 1, 1, u32) /* emitted in phase 1, removed in phase 2 */
 
@@ -285,18 +277,6 @@ DEF(       set_arg0, 1, 1, 1, none_arg)
 DEF(       set_arg1, 1, 1, 1, none_arg)
 DEF(       set_arg2, 1, 1, 1, none_arg)
 DEF(       set_arg3, 1, 1, 1, none_arg)
-DEF(   get_var_ref0, 1, 0, 1, none_var_ref)
-DEF(   get_var_ref1, 1, 0, 1, none_var_ref)
-DEF(   get_var_ref2, 1, 0, 1, none_var_ref)
-DEF(   get_var_ref3, 1, 0, 1, none_var_ref)
-DEF(   put_var_ref0, 1, 1, 0, none_var_ref)
-DEF(   put_var_ref1, 1, 1, 0, none_var_ref)
-DEF(   put_var_ref2, 1, 1, 0, none_var_ref)
-DEF(   put_var_ref3, 1, 1, 0, none_var_ref)
-DEF(   set_var_ref0, 1, 1, 1, none_var_ref)
-DEF(   set_var_ref1, 1, 1, 1, none_var_ref)
-DEF(   set_var_ref2, 1, 1, 1, none_var_ref)
-DEF(   set_var_ref3, 1, 1, 1, none_var_ref)
 
 DEF(      if_false8, 2, 1, 0, label8)
 DEF(       if_true8, 2, 1, 0, label8) /* must come after if_false8 */

source/scheduler_playdate.c

@@ -122,7 +122,7 @@ void actor_free(cell_rt *actor)
   JS_FreeValue(js, actor->message_handle);
   JS_FreeValue(js, actor->on_exception);
   JS_FreeValue(js, actor->unneeded);
-  JS_FreeAtom(js, actor->actor_sym);
+  JS_FreeValue(js, actor->actor_sym);
   
   /* Free timer callbacks stored in actor */
   for (int i = 0; i < hmlen(actor->timers); i++) {
@@ -332,7 +332,7 @@ cell_rt *create_actor(void *wota)
   actor->message_handle = JS_NULL;
   actor->unneeded = JS_NULL;
   actor->on_exception = JS_NULL;
-  actor->actor_sym = JS_ATOM_NULL;
+  actor->actor_sym = JS_NULL;
 
   arrsetcap(actor->letters, 5);
 

status.md

@@ -0,0 +1,94 @@
+QuickJS Mist Memory Format Refactoring
+Current Status
+The codebase is partially refactored but doesn't compile due to missing KeyId type definitions.
+
+Incremental Refactoring Tasks
+Phase 0: Fix Compilation (Prerequisite)
+ Define missing KeyId type as transitional typedef (will be replaced by JSValue later)
+ Define K_EMPTY, K_TOMB, 
+key_text()
+, 
+key_is_text()
+, 
+key_payload()
+ macros/functions
+ Verify build compiles and tests pass
+Phase 1: New JSValue Encoding in quickjs.h
+ Add new LSB-based tag constants alongside existing tags
+ Add JS_TAG_SHORT_FLOAT for 61-bit truncated double
+ Add JS_TAG_STRING_ASCII for immediate 7-byte ASCII strings
+ Add new value extraction/creation macros
+ Add type check inline functions
+ Keep existing NaN-boxing code active (compile-time switch)
+Phase 2: Short Float Implementation
+ Implement JS_NewFloat64_ShortFloat() with range checking
+ Implement JS_VALUE_GET_FLOAT64_ShortFloat() for decoding
+ Out-of-range values return JS_NULL
+ Prefer integer encoding when exact
+Phase 3: Immediate ASCII String
+Phase 3: Immediate ASCII String
+ Implement JS_TryNewImmediateASCII() for strings up to 7 chars
+ Implement JS_IsImmediateASCII() type check
+ Implement JS_GetImmediateASCIILen() and JS_GetImmediateASCIIChar()
+Integrate with 
+JS_NewStringLen()
+ to try immediate first
+Phase 4: Remove JSStringRope
+ Delete JSStringRope structure
+ Remove JS_TAG_STRING_ROPE handling
+ Update string concatenation to create immediate mist_text objects
+ Remove rope-related iterator functions
+Phase 5: Refactor JSString to UTF-32 (mist_text)
+ Modify struct JSString to store UTF-32 characters only
+ Remove is_wide_char flag and 8.16 unions
+ Update 
+js_alloc_string
+ to allocate UTF-32 buffer
+ Update string creation functions (
+js_new_string8
+, etc.)
+ Update all string accessors to use UTF-32
+ Implement immediate-to-UTF32 conversion helper
+ Update string operations (
+concat
+, 
+compare
+) to work on UTF-32
+Phase 6: Replace KeyId with JSValue in Records
+ Change JSRecordEntry.key from KeyId to JSValue
+ Update 
+rec_hash_key()
+ to hash JSValue keys directly
+ Update 
+rec_find_slot()
+ for JSValue key comparison
+ Update 
+rec_get_own()
+, 
+rec_get()
+, 
+rec_set_own()
+ for JSValue keys
+ Remove KeyId typedef and related functions
+Phase 7: Consolidate JSObject → JSRecord
+ Remove JSShape and JSShapeProperty structures
+ Remove shape hash table from JSRuntime
+ Update all property access to use JSRecord
+ Migrate JSObject users to JSRecord
+ Remove JSObject structure
+Phase 8: Update GC for New Format
+ Update mark_children for JSRecord with JSValue keys
+ Update free_record for JSValue keys
+ Handle immediate values correctly (no marking needed)
+ Test for cycles and correct collection
+Phase 9: C Class Storage in Slot 0
+ Implement slot 0 reservation for class_id and opaque pointer
+ Update JS_SetOpaque() / JS_GetOpaque()
+ Migrate existing class storage
+Verification Checklist
+ Build compiles without errors
+ Existing tests pass
+ Property access works correctly
+ GC correctly handles cycles
+ Short float encoding/decoding verified
+ Immediate ASCII strings work

tests/demo.ce

@@ -0,0 +1,39 @@
+function safe_add(a, b) {
+  return a + b
+} disruption {
+  print("disruption caught in safe_add")
+}
+
+function inner() {
+  disrupt
+}
+
+function outer() {
+  inner()
+} disruption {
+  print("disruption caught in outer — from inner()")
+}
+
+// Test 1: explicit disrupt with handler
+function test_explicit() {
+  disrupt
+} disruption {
+  print("test 1: explicit disrupt handled")
+}
+test_explicit()
+
+// Test 2: type error disrupt (number + function)
+safe_add(1, print)
+
+// Test 3: unwinding — inner disrupts, outer catches
+outer()
+
+// Test 4: disrupt from inside disruption clause
+function test_nested() {
+  disrupt
+} disruption {
+  print("test 4: first disruption")
+}
+test_nested()
+
+print("done")

tests/suite.cm

@@ -1244,15 +1244,16 @@ return {
     // EDGE CASES AND SPECIAL VALUES
     // ============================================================================
 
-    test_infinity: function() {
+    test_division_by_zero_is_null: function() {
         var inf = 1 / 0
-        if (!(inf > 1000000)) throw "infinity failed"
-        if (!(-inf < -1000000)) throw "negative infinity failed"
+        if (inf != null) throw "division by zero should be null"
+        var ninf = -1 / 0
+        if (ninf != null) throw "negative division by zero should be null"
     },
 
-    test_nan: function() {
+    test_zero_div_zero_is_null: function() {
         var nan = 0 / 0
-        if (nan == nan) throw "NaN should not equal itself"
+        if (nan != null) throw "0/0 should be null"
     },
 
     test_max_safe_integer: function() {
@@ -1403,17 +1404,36 @@ return {
 
     test_number_division_by_zero: function() {
         var result = 1 / 0
-        if (!(result > 1000000)) throw "division by zero should give infinity"
+        if (result != null) throw "division by zero should give null"
     },
 
     test_number_negative_division_by_zero: function() {
         var result = -1 / 0
-        if (!(result < -1000000)) throw "negative division by zero should give -infinity"
+        if (result != null) throw "negative division by zero should give null"
     },
 
     test_zero_division_by_zero: function() {
         var result = 0 / 0
-        if (result == result) throw "0/0 should give NaN"
+        if (result != null) throw "0/0 should give null"
+    },
+
+    test_negative_zero_normalized: function() {
+        var nz = -0
+        if (nz != 0) throw "-0 should equal 0"
+        var mul_nz = 0 * -1
+        if (mul_nz != 0) throw "0 * -1 should be 0"
+        var neg_zero = -(0)
+        if (neg_zero != 0) throw "-(0) should be 0"
+    },
+
+    test_overflow_is_null: function() {
+        var result = 1e38 * 1e38
+        if (result != null) throw "overflow should give null"
+    },
+
+    test_modulo_by_zero_is_null: function() {
+        var result = 5 % 0
+        if (result != null) throw "modulo by zero should give null"
     },
 
     // ============================================================================
@@ -3506,4 +3526,158 @@ return {
         if (obj.beta[1] != obj) throw "text key cycle failed"
     },
 
+    // ============================================================================
+    // OBJECT INTRINSIC TESTS
+    // ============================================================================
+
+    test_object_shallow_copy: function() {
+        var orig = {a: 1, b: 2, c: 3}
+        var copy = object(orig)
+        if (copy.a != 1) throw "object copy a failed"
+        if (copy.b != 2) throw "object copy b failed"
+        if (copy.c != 3) throw "object copy c failed"
+        copy.a = 99
+        if (orig.a != 1) throw "object copy should not mutate original"
+    },
+
+    test_object_combine: function() {
+        var obj1 = {a: 1, b: 2}
+        var obj2 = {c: 3, d: 4}
+        var combined = object(obj1, obj2)
+        if (combined.a != 1) throw "object combine a failed"
+        if (combined.b != 2) throw "object combine b failed"
+        if (combined.c != 3) throw "object combine c failed"
+        if (combined.d != 4) throw "object combine d failed"
+    },
+
+    test_object_combine_override: function() {
+        var obj1 = {a: 1, b: 2}
+        var obj2 = {b: 99, c: 3}
+        var combined = object(obj1, obj2)
+        if (combined.a != 1) throw "object combine override a failed"
+        if (combined.b != 99) throw "object combine should override with second arg"
+        if (combined.c != 3) throw "object combine override c failed"
+    },
+
+    test_object_select_keys: function() {
+        var orig = {a: 1, b: 2, c: 3, d: 4}
+        var selected = object(orig, ["a", "c"])
+        if (selected.a != 1) throw "object select a failed"
+        if (selected.c != 3) throw "object select c failed"
+        if (selected.b != null) throw "object select should not include b"
+        if (selected.d != null) throw "object select should not include d"
+    },
+
+    test_object_from_keys_true: function() {
+        var keys = ["x", "y", "z"]
+        var obj = object(keys)
+        if (obj.x != true) throw "object from keys x failed"
+        if (obj.y != true) throw "object from keys y failed"
+        if (obj.z != true) throw "object from keys z failed"
+    },
+
+    test_object_from_keys_function: function() {
+        var keys = ["a", "b", "c"]
+        var obj = object(keys, function(k) { return k + "_val" })
+        if (obj.a != "a_val") throw "object from keys func a failed"
+        if (obj.b != "b_val") throw "object from keys func b failed"
+        if (obj.c != "c_val") throw "object from keys func c failed"
+    },
+
+    // ============================================================================
+    // SPLAT INTRINSIC TESTS
+    // ============================================================================
+
+    test_splat_prototype_flattening: function() {
+        var proto = {x: 10, y: 20}
+        var obj = {z: 30}
+        obj.__proto__ = proto
+        var flat = splat(obj)
+        if (flat.x != 10) throw "splat x failed"
+        if (flat.y != 20) throw "splat y failed"
+        if (flat.z != 30) throw "splat z failed"
+    },
+
+    // ============================================================================
+    // REVERSE INTRINSIC TESTS
+    // ============================================================================
+
+    test_reverse_array: function() {
+        var arr = [1, 2, 3, 4, 5]
+        var rev = reverse(arr)
+        if (rev[0] != 5) throw "reverse[0] failed"
+        if (rev[1] != 4) throw "reverse[1] failed"
+        if (rev[2] != 3) throw "reverse[2] failed"
+        if (rev[3] != 2) throw "reverse[3] failed"
+        if (rev[4] != 1) throw "reverse[4] failed"
+        if (arr[0] != 1) throw "reverse should not mutate original"
+    },
+
+    // ============================================================================
+    // APPLY INTRINSIC TESTS
+    // ============================================================================
+
+    test_apply_with_array_args: function() {
+        def sum = function(a, b, c) { return a + b + c }
+        var result = fn.apply(sum, [1, 2, 3])
+        if (result != 6) throw "apply with array args failed"
+    },
+
+    test_apply_with_no_args: function() {
+        def ret42 = function() { return 42 }
+        var result = fn.apply(ret42)
+        if (result != 42) throw "apply with no args failed"
+    },
+
+    test_apply_with_single_value: function() {
+        def double = function(x) { return x * 2 }
+        var result = fn.apply(double, 10)
+        if (result != 20) throw "apply with single value failed"
+    },
+
+    // ============================================================================
+    // GC STRESS TESTS FOR FIXED INTRINSICS
+    // ============================================================================
+
+    test_gc_reverse_under_pressure: function() {
+        // Create GC pressure by making many arrays, then reverse
+        var arrays = []
+        for (var i = 0; i < 100; i = i + 1) {
+            arrays[i] = [i, i+1, i+2, i+3, i+4]
+        }
+        // Now reverse each one - this tests re-chase after allocation
+        for (var i = 0; i < 100; i = i + 1) {
+            var rev = reverse(arrays[i])
+            if (rev[0] != i+4) throw "gc reverse stress failed at " + text(i)
+        }
+    },
+
+    test_gc_object_select_under_pressure: function() {
+        // Create GC pressure
+        var objs = []
+        for (var i = 0; i < 100; i = i + 1) {
+            objs[i] = {a: i, b: i+1, c: i+2, d: i+3}
+        }
+        // Select keys - tests re-chase in loop
+        for (var i = 0; i < 100; i = i + 1) {
+            var selected = object(objs[i], ["a", "c"])
+            if (selected.a != i) throw "gc object select stress failed at " + text(i)
+            if (selected.c != i+2) throw "gc object select stress c failed at " + text(i)
+        }
+    },
+
+    test_gc_object_from_keys_function_under_pressure: function() {
+        // Create GC pressure
+        var keysets = []
+        for (var i = 0; i < 50; i = i + 1) {
+            keysets[i] = ["k" + text(i), "j" + text(i), "m" + text(i)]
+        }
+        // Create objects with function - tests JS_PUSH/POP and re-chase
+        for (var i = 0; i < 50; i = i + 1) {
+            var obj = object(keysets[i], function(k) { return k + "_value" })
+            var expected = "k" + text(i) + "_value"
+            if (obj["k" + text(i)] != expected) throw "gc object from keys func stress failed at " + text(i)
+        }
+    },
+
 }

vm_test/arrow_block.txt

@@ -0,0 +1 @@
+var f = x => { return x }; f(1)

vm_test/arrow_default.txt

@@ -0,0 +1 @@
+var f = (x = 10) => x; f()

vm_test/arrow_expr.txt

@@ -0,0 +1 @@
+var f = x => x * 2; f(5)

vm_test/arrow_multi.txt

@@ -0,0 +1 @@
+var f = (a, b) => a + b; f(2, 3)

vm_test/arrow_no_param.txt

@@ -0,0 +1 @@
+var f = () => 42; f()

vm_test/assign_add.txt

@@ -0,0 +1 @@
+var x = 5; x += 3; x

vm_test/assign_and.txt

@@ -0,0 +1 @@
+var x = 7; x &= 3; x

vm_test/assign_div.txt

@@ -0,0 +1 @@
+var x = 6; x /= 2; x

vm_test/assign_land.txt

@@ -0,0 +1 @@
+var x = 5; x &&= 10; x

vm_test/assign_lor.txt

@@ -0,0 +1 @@
+var x = 0; x ||= 10; x

vm_test/assign_mod.txt

@@ -0,0 +1 @@
+var x = 7; x %= 3; x

vm_test/assign_mul.txt

@@ -0,0 +1 @@
+var x = 5; x *= 3; x

vm_test/assign_nullish.txt

@@ -0,0 +1 @@
+var x = null; x ??= 10; x

vm_test/assign_or.txt

@@ -0,0 +1 @@
+var x = 5; x |= 2; x

vm_test/assign_power.txt

@@ -0,0 +1 @@
+var x = 2; x **= 3; x

vm_test/assign_shl.txt

@@ -0,0 +1 @@
+var x = 2; x <<= 3; x

vm_test/assign_shr.txt

@@ -0,0 +1 @@
+var x = 8; x >>= 2; x

vm_test/assign_shru.txt

@@ -0,0 +1 @@
+var x = -8; x >>>= 2; x

vm_test/assign_sub.txt

@@ -0,0 +1 @@
+var x = 5; x -= 3; x

vm_test/assign_xor.txt

@@ -0,0 +1 @@
+var x = 5; x ^= 3; x

vm_test/chained_assign.txt

@@ -0,0 +1 @@
+var x, y; x = y = 5; x + y

vm_test/closure_basic.txt

@@ -0,0 +1 @@
+var f = function(x) { return function() { return x } }; f(5)()

vm_test/closure_mutate.txt

@@ -0,0 +1,11 @@
+var counter = function() {
+  var n = 0
+  return function() {
+    n = n + 1
+    return n
+  }
+}
+var c = counter()
+c()
+c()
+c()

vm_test/comment.txt

@@ -0,0 +1,3 @@
+// simple test that comments work
+var x = 5
+// other comment

vm_test/comment_block.txt

@@ -0,0 +1 @@
+/* comment */ 5

vm_test/comment_multi.txt

@@ -0,0 +1 @@
+1 /* a */ + /* b */ 2

vm_test/def_basic.txt

@@ -0,0 +1 @@
+def x = 5; x

vm_test/do_while.txt

@@ -0,0 +1 @@
+var i = 0; do { i = i + 1 } while (i < 3); i

vm_test/do_while_continue.txt

@@ -0,0 +1 @@
+var s = 0; var i = 0; do { i = i + 1; if (i == 2) continue; s = s + i } while (i < 5); s

vm_test/empty_statement.txt

@@ -0,0 +1 @@
+;;; 5

vm_test/for_basic.txt

@@ -0,0 +1 @@
+var s = 0; for (var i = 0; i < 3; i++) s = s + i; s

vm_test/for_break.txt

@@ -0,0 +1 @@
+var s = 0; for (var i = 0; i < 10; i++) { if (i == 4) break; s = s + i }; s

vm_test/for_continue.txt

@@ -0,0 +1 @@
+var s = 0; for (var i = 0; i < 5; i++) { if (i == 2) continue; s = s + i }; s