managed frames

- Added default dimensions for images when width/height not specified, using original image size
- Enhanced text rendering to use natural text dimensions when width/height not provided
- Disabled file monitoring system by nullifying dmon to prevent unnecessary file watching

.cell/lock.toml

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

.gitignore

@@ -6,25 +6,25 @@ build/
 *.o
 *.a
 *.d
-tags
-Jenkinsfile
 *~
 *.log
 *.gz
 *.tar
 .nova/
-packer*
-primum
-sokol-shdc*
 source/shaders/*.h
-core.cdb
-primum.exe
-core.cdb.h
-jsc
 .DS_Store
 *.html
 .vscode
 *.icns
-game.zip
 icon.ico
 steam/
+subprojects/*/
+build_dbg/
+modules/
+sdk/
+artifacts/
+discord_social_sdk/
+discord_partner_sdk/
+steam_api64.dll
+subprojects/.wraplock
+.gemini

Info.plist

@@ -1,16 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-    <key>CFBundleExecutable</key>
-    <string>Prosperon</string>
-    <key>CFBundleIdentifier</key>
-    <string>pockle.world.prosperon</string>
-    <key>CFBundleName</key>
-    <string>Prosperon</string>
-    <key>CFBundleVersion</key>
-    <string>0.5</string>
-    <key>NSHumanReadableCopyright</key>
-    <string>Copyright © 2024 Pockle World. All rights reserved.</string>
-</dict>
-</plist>

LICENSE

@@ -1,26 +0,0 @@
-Prosperon Game Engine
- 
-Copyright (c) 2019-2024 John Alanbrook
-
-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:
-
-(1) The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-(2) Any games or other derivative software must display the "Prosperon" logo
-at near the beginning of the software's startup, before the chief purpose
-of the software is underway.
-
-
-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.

Makefile

@@ -1,25 +1,80 @@
-debug: FORCE
+# Development build: creates libcell_runtime.dylib + thin main wrapper
+# This is the default target for working on cell itself
+#
+# If cell doesn't exist yet, use 'make bootstrap' first (requires meson)
+# or manually build with meson once.
+#
+# The cell shop is at ~/.cell and core scripts are installed to ~/.cell/core
+
+CELL_SHOP = $(HOME)/.cell
+CELL_CORE_PACKAGE = $(CELL_SHOP)/packages/core
+
+makecell:
+	cell pack core -o cell
+	cp cell /opt/homebrew/bin/
+
+# Install core: symlink this directory to ~/.cell/core
+install: bootstrap $(CELL_SHOP)
+	@echo "Linking cell core to $(CELL_CORE_PACKAGE)"
+	rm -rf $(CELL_CORE_PACKAGE)
+	ln -s $(PWD) $(CELL_CORE_PACKAGE)
+	cp cell /opt/homebrew/bin/
+	cp libcell_runtime.dylib /opt/homebrew/lib/
+	@echo "Core installed."
+
+cell: libcell_runtime.dylib cell_main
+	cp cell_main cell
+	chmod +x cell
+	cp cell /opt/homebrew/bin/cell
+	cp libcell_runtime.dylib /opt/homebrew/lib/
+
+# Build the shared runtime library (everything except main.c)
+# Uses existing cell to run build -d
+libcell_runtime.dylib: $(CELL_SHOP)/build/dynamic
+	cell build -d
+	cp $(CELL_SHOP)/build/dynamic/libcell_runtime.dylib .
+
+# Build the thin main wrapper that links to libcell_runtime
+cell_main: source/main.c libcell_runtime.dylib
+	cc -o cell_main source/main.c -L. -lcell_runtime -Wl,-rpath,@loader_path -Wl,-rpath,/opt/homebrew/lib
+
+# Create the cell shop directories
+$(CELL_SHOP):
+	mkdir -p $(CELL_SHOP)
+	mkdir -p $(CELL_SHOP)/packages
+	mkdir -p $(CELL_SHOP)/cache
+	mkdir -p $(CELL_SHOP)/build
+
+$(CELL_CORE):
+	ln -s $(PWD) $(CELL_CORE)
+
+# Static build: creates a fully static cell binary (for distribution)
+static:
+	cell build
+	cp $(CELL_SHOP)/build/static/cell .
+
+# Bootstrap: build cell from scratch using meson (only needed once)
+# Also installs core scripts to ~/.cell/core
+bootstrap: 
+	meson setup build_bootstrap -Dbuildtype=debugoptimized
+	meson compile -C build_bootstrap
+	cp build_bootstrap/cell .
+	cp build_bootstrap/libcell_runtime.dylib .
+	@echo "Bootstrap complete. Cell shop initialized at $(CELL_SHOP)"
+	@echo "Now run 'make' to rebuild with cell itself."
+
+# Clean build artifacts
+clean:
+	rm -rf $(CELL_SHOP)/build build_bootstrap
+	rm -f cell cell_main libcell_runtime.dylib
+
+# Ensure dynamic build directory exists
+$(CELL_SHOP)/build/dynamic: $(CELL_SHOP)
+	mkdir -p $(CELL_SHOP)/build/dynamic
+
+# Legacy meson target
+meson:
 	meson setup build_dbg -Dbuildtype=debugoptimized
-	meson compile -C build_dbg
+	meson install -C build_dbg
 
-release: FORCE
-	meson setup -Dbuildtype=release -Db_lto=true -Db_ndebug=true -Db_pgo=use build_release
-	meson compile -C build_release
-
-sanitize: FORCE
-	meson setup -Db_sanitize=address -Db_sanitize=memory -Db_sanitize=leak -Db_sanitize=undefined build_sani
-	meson compile -C build_sani
-
-small: FORCE
-	meson setup -Dbuildtype=minsize -Db_lto=true -Db_ndebug=true -Db_pgo=use build_small
-	meson compile -C build_small
-
-web: FORCE
-	meson setup -Deditor=false -Dbuildtype=minsize -Db_lto=true -Db_ndebug=true --cross-file emscripten.cross build_web
-	meson compile -C build_web
-
-crosswin: FORCE
-	meson setup -Dbuildtype=debugoptimized --cross-file mingw32.cross build_win
-	meson compile -C build_win
-
-FORCE:
+.PHONY: cell static bootstrap clean meson install

README.md

@@ -1,13 +1 @@
-![alt text](doc/prosperon_orb_horizontal.gif)
-
-The easily moddable, programming minded, 2D-first game engine. The aim is to make the fastest way to make games.
-
-Using ...
-* Sokol for rendering
-* Chipmunk2D for physics
-* imgui for easy editor UI
-* Clay for game UI
-
-Includes an implementation for Nota, and Kim.
-
-*Prosperon is useful, but is a work in progress. Breaking changes are frequent.*
+Read the docs to get started.

add.ce

@@ -0,0 +1,28 @@
+// cell add <locator> [alias] - Add and install a package with its dependencies
+
+var shop = use('internal/shop')
+var fd = use('fd')
+
+if (args.length < 1) {
+  log.console("Usage: cell add <locator> [alias]")
+  log.console("Examples:")
+  log.console("  cell add gitea.pockle.world/john/prosperon@main")
+  log.console("  cell add github.com/user/repo@v1.0.0 myalias")
+  $stop()
+  return
+}
+
+var locator = args[0]
+
+// Resolve relative paths to absolute paths
+if (locator == '.' || locator.startsWith('./') || locator.startsWith('../') || fd.is_dir(locator)) {
+  var resolved = fd.realpath(locator)
+  if (resolved) {
+    locator = resolved
+  }
+}
+var alias = args.length > 1 ? args[1] : null
+
+shop.get(locator, alias)
+
+$stop()

archive/miniz.c

@@ -0,0 +1,399 @@
+#include "quickjs.h"
+#include "miniz.h"
+#include "cell.h"
+
+static JSClassID js_reader_class_id;
+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);
+}
+
+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);
+}
+
+static JSClassDef js_reader_class = {
+  "zip reader",
+  .finalizer = js_reader_finalizer,
+};
+
+static JSClassDef js_writer_class = {
+  "zip writer",
+  .finalizer = js_writer_finalizer,
+};
+
+static mz_zip_archive *js2reader(JSContext *js, JSValue v)
+{
+  return JS_GetOpaque(v, js_reader_class_id);
+}
+
+static mz_zip_archive *js2writer(JSContext *js, JSValue v)
+{
+  return JS_GetOpaque(v, js_writer_class_id);
+}
+
+static JSValue js_miniz_read(JSContext *js, JSValue self, int argc, JSValue *argv)
+{
+  size_t len;
+  void *data = js_get_blob_data(js, &len, argv[0]);
+  if (data == -1)
+    return JS_EXCEPTION;
+
+  mz_zip_archive *zip = calloc(sizeof(*zip), 1);
+  if (!zip)
+    return JS_ThrowOutOfMemory(js);
+
+  mz_bool success = mz_zip_reader_init_mem(zip, data, len, 0);
+  
+  if (!success) {
+    int err = mz_zip_get_last_error(zip);
+    free(zip);
+    return JS_ThrowInternalError(js, "Failed to initialize zip reader: %s", mz_zip_get_error_string(err));
+  }
+
+  JSValue jszip = JS_NewObjectClass(js, js_reader_class_id);
+  JS_SetOpaque(jszip, zip);
+  return jszip;
+}
+
+static JSValue js_miniz_write(JSContext *js, JSValue self, int argc, JSValue *argv)
+{
+  const char *file = JS_ToCString(js, argv[0]);
+  if (!file)
+    return JS_EXCEPTION;
+  
+  mz_zip_archive *zip = calloc(sizeof(*zip), 1);
+  if (!zip) {
+    JS_FreeCString(js, file);
+    return JS_ThrowOutOfMemory(js);
+  }
+  
+  mz_bool success = mz_zip_writer_init_file(zip, file, 0);
+  JS_FreeCString(js, file);
+  
+  if (!success) {
+    int err = mz_zip_get_last_error(zip);
+    mz_zip_writer_end(zip);
+    free(zip);
+    return JS_ThrowInternalError(js, "Failed to initialize zip writer: %s", mz_zip_get_error_string(err));
+  }
+  
+  JSValue jszip = JS_NewObjectClass(js, js_writer_class_id);
+  JS_SetOpaque(jszip, zip);
+  return jszip;
+}
+
+static JSValue js_miniz_compress(JSContext *js, JSValue this_val,
+                                 int argc, JSValueConst *argv)
+{
+  if (argc < 1)
+    return JS_ThrowTypeError(js,
+            "compress needs a string or ArrayBuffer");
+
+  /* ─── 1. Grab the input data ──────────────────────────────── */
+  const char *cstring = NULL;
+  size_t      in_len  = 0;
+  const void *in_ptr  = NULL;
+
+  if (JS_IsString(argv[0])) {
+    /* String → UTF-8 bytes without the terminating NUL */
+    cstring = JS_ToCStringLen(js, &in_len, argv[0]);
+    if (!cstring)
+      return JS_EXCEPTION;
+    in_ptr = cstring;
+  } else { 
+    in_ptr = js_get_blob_data(js, &in_len, argv[0]);
+    if (in_ptr == -1)
+      return JS_EXCEPTION;
+  }
+
+  /* ─── 2. Allocate an output buffer big enough  ────────────── */
+  mz_ulong out_len_est = mz_compressBound(in_len);
+  void *out_buf = js_malloc(js, out_len_est);
+  if (!out_buf) {
+    if (cstring) JS_FreeCString(js, cstring);
+    return JS_EXCEPTION;
+  }
+
+  /* ─── 3. Do the compression (MZ_DEFAULT_COMPRESSION = level 6) */
+  mz_ulong out_len = out_len_est;
+  int st = mz_compress2(out_buf, &out_len,
+                        in_ptr, in_len, MZ_DEFAULT_COMPRESSION);
+
+  /* clean-up for string input */
+  if (cstring) JS_FreeCString(js, cstring);
+
+  if (st != MZ_OK) {
+    js_free(js, out_buf);
+    return JS_ThrowInternalError(js,
+            "miniz: compression failed (%d)", st);
+  }
+
+  /* ─── 4. Hand JavaScript a copy of the compressed data ────── */
+  JSValue abuf = js_new_blob_stoned_copy(js, out_buf, out_len);
+  js_free(js, out_buf);
+  return abuf;
+}
+
+static JSValue js_miniz_decompress(JSContext *js,
+                                   JSValueConst this_val,
+                                   int argc,
+                                   JSValueConst *argv)
+{
+  if (argc < 1)
+    return JS_ThrowTypeError(js,
+            "decompress: need compressed ArrayBuffer");
+
+  /* grab compressed data */
+  size_t in_len;
+  void  *in_ptr = js_get_blob_data(js, &in_len, argv[0]);
+  if (in_ptr == -1)
+    return JS_EXCEPTION;
+
+  /* zlib header present → tell tinfl to parse it */
+  size_t out_len = 0;
+  void  *out_ptr = tinfl_decompress_mem_to_heap(
+                     in_ptr, in_len, &out_len,
+                     TINFL_FLAG_PARSE_ZLIB_HEADER);
+
+  if (!out_ptr)
+    return JS_ThrowInternalError(js,
+            "miniz: decompression failed");
+
+  JSValue ret;
+    ret = JS_NewStringLen(js, (const char *)out_ptr, out_len);
+#ifdef MZ_FREE
+  MZ_FREE(out_ptr);
+#else
+  free(out_ptr);
+#endif
+  return ret;
+}
+
+
+static const JSCFunctionListEntry js_miniz_funcs[] = {
+  JS_CFUNC_DEF("read", 1, js_miniz_read),
+  JS_CFUNC_DEF("write", 1, js_miniz_write),
+  JS_CFUNC_DEF("compress", 1, js_miniz_compress),
+  JS_CFUNC_DEF("decompress", 1, js_miniz_decompress),
+};
+
+JSValue js_writer_add_file(JSContext *js, JSValue self, int argc, JSValue *argv)
+{
+  if (argc < 2)
+    return JS_ThrowTypeError(js, "add_file requires (path, arrayBuffer)");
+  
+  mz_zip_archive *zip = js2writer(js, self);
+  const char *pathInZip = JS_ToCString(js, argv[0]);
+  if (!pathInZip)
+    return JS_ThrowTypeError(js, "Could not parse path argument");
+  
+  size_t dataLen;
+  void *data = js_get_blob_data(js, &dataLen, argv[1]);
+  if (data == -1) {
+    JS_FreeCString(js, pathInZip);
+    return JS_EXCEPTION;
+  }
+
+  int success = mz_zip_writer_add_mem(zip, pathInZip, data, dataLen, MZ_DEFAULT_COMPRESSION);
+  JS_FreeCString(js, pathInZip);
+  
+  if (!success)
+    return JS_ThrowInternalError(js, "Failed to add memory to zip");
+  
+  return JS_NULL;
+}
+
+
+static const JSCFunctionListEntry js_writer_funcs[] = {
+  JS_CFUNC_DEF("add_file", 1, js_writer_add_file),
+};
+
+JSValue js_reader_mod(JSContext *js, JSValue self, int argc, JSValue *argv)
+{
+#ifndef MINIZ_NO_TIME
+  const char *file = JS_ToCString(js,argv[0]);
+  if (!file)
+    return JS_EXCEPTION;
+  
+  mz_zip_archive *zip = js2reader(js, self);
+  if (!zip) {
+    JS_FreeCString(js, file);
+    return JS_ThrowInternalError(js, "Invalid zip reader");
+  }
+  
+  mz_zip_archive_file_stat pstat;
+  mz_uint index = mz_zip_reader_locate_file(zip, file, NULL, 0);
+  
+  if (index == (mz_uint)-1) {
+    JS_FreeCString(js, file);
+    return JS_ThrowReferenceError(js, "File '%s' not found in archive", file);
+  }
+  
+  JS_FreeCString(js, file);
+  
+  if (!mz_zip_reader_file_stat(zip, index, &pstat)) {
+    int err = mz_zip_get_last_error(zip);
+    return JS_ThrowInternalError(js, "Failed to get file stats: %s", mz_zip_get_error_string(err));
+  }
+  
+  return JS_NewFloat64(js, pstat.m_time);
+#else
+  return JS_ThrowInternalError(js, "MINIZ_NO_TIME is defined");
+#endif
+}
+
+JSValue js_reader_exists(JSContext *js, JSValue self, int argc, JSValue *argv)
+{
+  const char *file = JS_ToCString(js,argv[0]);
+  if (!file)
+    return JS_EXCEPTION;
+  
+  mz_zip_archive *zip = js2reader(js, self);
+  if (!zip) {
+    JS_FreeCString(js, file);
+    return JS_ThrowInternalError(js, "Invalid zip reader");
+  }
+  
+  mz_uint index = mz_zip_reader_locate_file(zip, file, NULL, 0);
+  JS_FreeCString(js,file);
+  if (index == (mz_uint)-1) return JS_NewBool(js, 0);
+  return JS_NewBool(js, 1);
+}
+
+JSValue js_reader_slurp(JSContext *js, JSValue self, int argc, JSValue *argv)
+{
+  const char *file = JS_ToCString(js,argv[0]);
+  if (!file)
+    return JS_EXCEPTION;
+  
+  mz_zip_archive *zip = js2reader(js, self);
+  if (!zip) {
+    JS_FreeCString(js, file);
+    return JS_ThrowInternalError(js, "Invalid zip reader");
+  }
+  
+  size_t len;
+  void *data = mz_zip_reader_extract_file_to_heap(zip, file, &len, 0);
+  
+  if (!data) {
+    int err = mz_zip_get_last_error(zip);
+    const char *filename = file;
+    JS_FreeCString(js, file);
+    return JS_ThrowInternalError(js, "Failed to extract file '%s': %s", filename, mz_zip_get_error_string(err));
+  }
+  
+  JS_FreeCString(js, file);
+
+  JSValue ret = js_new_blob_stoned_copy(js, data, len);
+  free(data);
+  return ret;
+}
+
+JSValue js_reader_list(JSContext *js, JSValue self, int argc, JSValue *argv)
+{
+  mz_zip_archive *zip = js2reader(js, self);
+  if (!zip)
+    return JS_ThrowInternalError(js, "Invalid zip reader");
+  
+  mz_uint num_files = mz_zip_reader_get_num_files(zip);
+  
+  JSValue arr = JS_NewArray(js);
+  if (JS_IsException(arr))
+    return arr;
+  
+  mz_uint arr_index = 0;
+  for (mz_uint i = 0; i < num_files; i++) {
+    mz_zip_archive_file_stat file_stat;
+    if (!mz_zip_reader_file_stat(zip, i, &file_stat))
+      continue;
+    
+    JSValue filename = JS_NewString(js, file_stat.m_filename);
+    if (JS_IsException(filename)) {
+      JS_FreeValue(js, arr);
+      return filename;
+    }
+    JS_SetPropertyUint32(js, arr, arr_index++, filename);
+  }
+  
+  return arr;
+}
+
+JSValue js_reader_is_directory(JSContext *js, JSValue self, int argc, JSValue *argv)
+{
+  if (argc < 1)
+    return JS_ThrowTypeError(js, "is_directory requires a file index");
+    
+  int32_t index;
+  if (JS_ToInt32(js, &index, argv[0]))
+    return JS_EXCEPTION;
+  
+  mz_zip_archive *zip = js2reader(js, self);
+  if (!zip)
+    return JS_ThrowInternalError(js, "Invalid zip reader");
+  
+  return JS_NewBool(js, mz_zip_reader_is_file_a_directory(zip, index));
+}
+
+JSValue js_reader_get_filename(JSContext *js, JSValue self, int argc, JSValue *argv)
+{
+  if (argc < 1)
+    return JS_ThrowTypeError(js, "get_filename requires a file index");
+    
+  int32_t index;
+  if (JS_ToInt32(js, &index, argv[0]))
+    return JS_EXCEPTION;
+  
+  mz_zip_archive *zip = js2reader(js, self);
+  if (!zip)
+    return JS_ThrowInternalError(js, "Invalid zip reader");
+  
+  mz_zip_archive_file_stat file_stat;
+  if (!mz_zip_reader_file_stat(zip, index, &file_stat))
+    return JS_ThrowInternalError(js, "Failed to get file stats");
+    
+  return JS_NewString(js, file_stat.m_filename);
+}
+
+JSValue js_reader_count(JSContext *js, JSValue self, int argc, JSValue *argv)
+{
+  mz_zip_archive *zip = js2reader(js, self);
+  if (!zip)
+    return JS_ThrowInternalError(js, "Invalid zip reader");
+  return JS_NewUint32(js, mz_zip_reader_get_num_files(zip));
+}
+
+static const JSCFunctionListEntry js_reader_funcs[] = {
+  JS_CFUNC_DEF("mod", 1, js_reader_mod),
+  JS_CFUNC_DEF("exists", 1, js_reader_exists),
+  JS_CFUNC_DEF("slurp", 1, js_reader_slurp),
+  JS_CFUNC_DEF("list", 0, js_reader_list),
+  JS_CFUNC_DEF("is_directory", 1, js_reader_is_directory),
+  JS_CFUNC_DEF("get_filename", 1, js_reader_get_filename),
+  JS_CFUNC_DEF("count", 0, js_reader_count),
+};
+
+JSValue js_miniz_use(JSContext *js)
+{
+  JS_NewClassID(&js_reader_class_id);
+  JS_NewClass(JS_GetRuntime(js), js_reader_class_id, &js_reader_class);
+  JSValue reader_proto = JS_NewObject(js);
+  JS_SetPropertyFunctionList(js, reader_proto, js_reader_funcs, sizeof(js_reader_funcs) / sizeof(JSCFunctionListEntry));
+  JS_SetClassProto(js, js_reader_class_id, reader_proto);
+
+  JS_NewClassID(&js_writer_class_id);
+  JS_NewClass(JS_GetRuntime(js), js_writer_class_id, &js_writer_class);
+  JSValue writer_proto = JS_NewObject(js);
+  JS_SetPropertyFunctionList(js, writer_proto, js_writer_funcs, sizeof(js_writer_funcs) / sizeof(JSCFunctionListEntry));
+  JS_SetClassProto(js, js_writer_class_id, writer_proto);
+  
+  JSValue export = JS_NewObject(js);
+  JS_SetPropertyFunctionList(js, export, js_miniz_funcs, sizeof(js_miniz_funcs)/sizeof(JSCFunctionListEntry));
+  return export;
+}

bench.ce

@@ -0,0 +1,603 @@
+var shop = use('internal/shop')
+var pkg = use('package')
+var fd = use('fd')
+var time = use('time')
+var json = use('json')
+var blob = use('blob')
+var os = use('os')
+var testlib = use('internal/testlib')
+var math = use('math/radians')
+
+if (!args) args = []
+
+var target_pkg = null // null = current package
+var target_bench = null // null = all benchmarks, otherwise specific bench file
+var all_pkgs = false
+
+// Benchmark configuration
+def WARMUP_BATCHES = 3
+def SAMPLES = 11 // Number of timing samples to collect
+def TARGET_SAMPLE_NS = 20000000 // 20ms per sample (fast mode)
+def MIN_SAMPLE_NS = 2000000 // 2ms minimum sample duration
+def MIN_BATCH_SIZE = 1
+def MAX_BATCH_SIZE = 100000000 // 100M iterations max per batch
+
+// Statistical functions
+function median(arr) {
+  if (arr.length == 0) return 0
+  var sorted = arr.slice().sort(function(a, b) { return a - b })
+  var mid = number.floor(arr.length / 2)
+  if (arr.length % 2 == 0) {
+    return (sorted[mid - 1] + sorted[mid]) / 2
+  }
+  return sorted[mid]
+}
+
+function mean(arr) {
+  if (arr.length == 0) return 0
+  var sum = 0
+  for (var i = 0; i < arr.length; i++) {
+    sum += arr[i]
+  }
+  return sum / arr.length
+}
+
+function stddev(arr, mean_val) {
+  if (arr.length < 2) return 0
+  var sum_sq_diff = 0
+  for (var i = 0; i < arr.length; i++) {
+    var diff = arr[i] - mean_val
+    sum_sq_diff += diff * diff
+  }
+  return math.sqrt(sum_sq_diff / (arr.length - 1))
+}
+
+function percentile(arr, p) {
+  if (arr.length == 0) return 0
+  var sorted = arr.slice().sort(function(a, b) { return a - b })
+  var idx = number.floor(arr.length * p / 100)
+  if (idx >= arr.length) idx = arr.length - 1
+  return sorted[idx]
+}
+
+function min_val(arr) {
+  if (arr.length == 0) return 0
+  var m = arr[0]
+  for (var i = 1; i < arr.length; i++) {
+    if (arr[i] < m) m = arr[i]
+  }
+  return m
+}
+
+function max_val(arr) {
+  if (arr.length == 0) return 0
+  var m = arr[0]
+  for (var i = 1; i < arr.length; i++) {
+    if (arr[i] > m) m = arr[i]
+  }
+  return m
+}
+
+// Parse arguments similar to test.ce
+function parse_args() {
+  if (args.length == 0) {
+    if (!testlib.is_valid_package('.')) {
+      log.console('No cell.toml found in current directory')
+      return false
+    }
+    target_pkg = null
+    return true
+  }
+
+  if (args[0] == 'all') {
+    if (!testlib.is_valid_package('.')) {
+      log.console('No cell.toml found in current directory')
+      return false
+    }
+    target_pkg = null
+    return true
+  }
+
+  if (args[0] == 'package') {
+    if (args.length < 2) {
+      log.console('Usage: cell bench package <name> [bench]')
+      log.console('       cell bench package all')
+      return false
+    }
+
+    if (args[1] == 'all') {
+      all_pkgs = true
+      log.console('Benchmarking all packages...')
+      return true
+    }
+
+    var name = args[1]
+    var lock = shop.load_lock()
+    if (lock[name]) {
+      target_pkg = name
+    } else if (name.startsWith('/') && testlib.is_valid_package(name)) {
+      target_pkg = name
+    } else {
+      if (testlib.is_valid_package('.')) {
+        var resolved = pkg.alias_to_package(null, name)
+        if (resolved) {
+          target_pkg = resolved
+        } else {
+          log.console(`Package not found: ${name}`)
+          return false
+        }
+      } else {
+        log.console(`Package not found: ${name}`)
+        return false
+      }
+    }
+
+    if (args.length >= 3) {
+      target_bench = args[2]
+    }
+
+    log.console(`Benchmarking package: ${target_pkg}`)
+    return true
+  }
+
+  // cell bench benches/suite or cell bench <path>
+  var bench_path = args[0]
+
+  // Normalize path - add benches/ prefix if not present
+  if (!bench_path.startsWith('benches/') && !bench_path.startsWith('/')) {
+    if (!fd.is_file(bench_path + '.cm') && !fd.is_file(bench_path)) {
+      if (fd.is_file('benches/' + bench_path + '.cm') || fd.is_file('benches/' + bench_path)) {
+        bench_path = 'benches/' + bench_path
+      }
+    }
+  }
+
+  target_bench = bench_path
+  target_pkg = null
+
+  if (!testlib.is_valid_package('.')) {
+    log.console('No cell.toml found in current directory')
+    return false
+  }
+
+  return true
+}
+
+if (!parse_args()) {
+  $stop()
+  return
+}
+
+// Collect benchmark files from a package
+function collect_benches(package_name, specific_bench) {
+  var prefix = testlib.get_pkg_dir(package_name)
+  var benches_dir = prefix + '/benches'
+
+  if (!fd.is_dir(benches_dir)) return []
+
+  var files = pkg.list_files(package_name)
+  var bench_files = []
+  for (var i = 0; i < files.length; i++) {
+    var f = files[i]
+    if (f.startsWith("benches/") && f.endsWith(".cm")) {
+      if (specific_bench) {
+        var bench_name = f.substring(0, f.length - 3)
+        var match_name = specific_bench
+        if (!match_name.startsWith('benches/')) match_name = 'benches/' + match_name
+        var match_base = match_name.endsWith('.cm') ? match_name.substring(0, match_name.length - 3) : match_name
+        if (bench_name != match_base) continue
+      }
+      bench_files.push(f)
+    }
+  }
+  return bench_files
+}
+
+// Calibrate batch size for a benchmark
+function calibrate_batch_size(bench_fn, is_batch) {
+  if (!is_batch) return 1
+
+  var n = MIN_BATCH_SIZE
+  var dt = 0
+
+  // Find a batch size that takes at least MIN_SAMPLE_NS
+  while (n < MAX_BATCH_SIZE) {
+    // Ensure n is a valid number before calling
+    if (typeof n != 'number' || n < 1) {
+      n = 1
+      break
+    }
+
+    var start = os.now()
+    bench_fn(n)
+    dt = os.now() - start
+
+    if (dt >= MIN_SAMPLE_NS) break
+
+    // Double the batch size
+    var new_n = n * 2
+    // Check if multiplication produced a valid number
+    if (typeof new_n != 'number' || new_n > MAX_BATCH_SIZE) {
+      n = MAX_BATCH_SIZE
+      break
+    }
+    n = new_n
+  }
+
+  // Adjust to target sample duration
+  if (dt > 0 && dt < TARGET_SAMPLE_NS && typeof n == 'number' && typeof dt == 'number') {
+    var calc = n * TARGET_SAMPLE_NS / dt
+    if (typeof calc == 'number' && calc > 0) {
+      var target_n = number.floor(calc)
+      // Check if floor returned a valid number
+      if (typeof target_n == 'number' && target_n > 0) {
+        if (target_n > MAX_BATCH_SIZE) target_n = MAX_BATCH_SIZE
+        if (target_n < MIN_BATCH_SIZE) target_n = MIN_BATCH_SIZE
+        n = target_n
+      }
+    }
+  }
+
+  // Safety check - ensure we always return a valid batch size
+  if (typeof n != 'number' || n < 1) {
+    n = 1
+  }
+
+  return n
+}
+
+// Run a single benchmark function
+function run_single_bench(bench_fn, bench_name) {
+  var timings_per_op = []
+
+  // Detect benchmark format:
+  // 1. Object with { setup, run, teardown } - structured format
+  // 2. Function that accepts (n) - batch format
+  // 3. Function that accepts () - legacy format
+  var is_structured = typeof bench_fn == 'object' && bench_fn.run
+  var is_batch = false
+  var batch_size = 1
+  var setup_fn = null
+  var run_fn = null
+  var teardown_fn = null
+
+  if (is_structured) {
+    setup_fn = bench_fn.setup || function() { return null }
+    run_fn = bench_fn.run
+    teardown_fn = bench_fn.teardown || function(state) {}
+
+    // Check if run function accepts batch size
+    try {
+      var test_state = setup_fn()
+      run_fn(1, test_state)
+      is_batch = true
+      if (teardown_fn) teardown_fn(test_state)
+    } catch (e) {
+      is_batch = false
+    }
+
+    // Create wrapper for calibration
+    var calibrate_fn = function(n) {
+      var state = setup_fn()
+      run_fn(n, state)
+      if (teardown_fn) teardown_fn(state)
+    }
+    batch_size = calibrate_batch_size(calibrate_fn, is_batch)
+
+    // Safety check for structured benchmarks
+    if (typeof batch_size != 'number' || batch_size < 1) {
+      batch_size = 1
+    }
+  } else {
+    // Simple function format
+    try {
+      bench_fn(1)
+      is_batch = true
+    } catch (e) {
+      is_batch = false
+    }
+    batch_size = calibrate_batch_size(bench_fn, is_batch)
+  }
+
+  // Safety check - ensure batch_size is valid
+  if (!batch_size || batch_size < 1) {
+    batch_size = 1
+  }
+
+  // Warmup phase
+  for (var i = 0; i < WARMUP_BATCHES; i++) {
+    // Ensure batch_size is valid before warmup
+    if (typeof batch_size != 'number' || batch_size < 1) {
+      log.console(`WARNING: batch_size became ${typeof batch_size} = ${batch_size}, resetting to 1`)
+      batch_size = 1
+    }
+
+    if (is_structured) {
+      var state = setup_fn()
+      if (is_batch) {
+        run_fn(batch_size, state)
+      } else {
+        run_fn(state)
+      }
+      if (teardown_fn) teardown_fn(state)
+    } else {
+      if (is_batch) {
+        bench_fn(batch_size)
+      } else {
+        bench_fn()
+      }
+    }
+  }
+
+  // Measurement phase - collect SAMPLES timing samples
+  for (var i = 0; i < SAMPLES; i++) {
+    // Double-check batch_size is valid (should never happen, but defensive)
+    if (typeof batch_size != 'number' || batch_size < 1) {
+      batch_size = 1
+    }
+
+    if (is_structured) {
+      var state = setup_fn()
+      var start = os.now()
+      if (is_batch) {
+        run_fn(batch_size, state)
+      } else {
+        run_fn(state)
+      }
+      var duration = os.now() - start
+      if (teardown_fn) teardown_fn(state)
+
+      var ns_per_op = is_batch ? duration / batch_size : duration
+      timings_per_op.push(ns_per_op)
+    } else {
+      var start = os.now()
+      if (is_batch) {
+        bench_fn(batch_size)
+      } else {
+        bench_fn()
+      }
+      var duration = os.now() - start
+
+      var ns_per_op = is_batch ? duration / batch_size : duration
+      timings_per_op.push(ns_per_op)
+    }
+  }
+
+  // Calculate statistics
+  var mean_ns = mean(timings_per_op)
+  var median_ns = median(timings_per_op)
+  var min_ns = min_val(timings_per_op)
+  var max_ns = max_val(timings_per_op)
+  var stddev_ns = stddev(timings_per_op, mean_ns)
+  var p95_ns = percentile(timings_per_op, 95)
+  var p99_ns = percentile(timings_per_op, 99)
+
+  // Calculate ops/s from median
+  var ops_per_sec = 0
+  if (median_ns > 0) {
+    ops_per_sec = number.floor(1000000000 / median_ns)
+  }
+
+  return {
+    name: bench_name,
+    batch_size: batch_size,
+    samples: SAMPLES,
+    mean_ns: number.round(mean_ns),
+    median_ns: number.round(median_ns),
+    min_ns: number.round(min_ns),
+    max_ns: number.round(max_ns),
+    stddev_ns: number.round(stddev_ns),
+    p95_ns: number.round(p95_ns),
+    p99_ns: number.round(p99_ns),
+    ops_per_sec: ops_per_sec
+  }
+}
+
+// Format nanoseconds for display
+function format_ns(ns) {
+  if (ns < 1000) return `${ns}ns`
+  if (ns < 1000000) return `${number.round(ns / 1000 * 100) / 100}µs`
+  if (ns < 1000000000) return `${number.round(ns / 1000000 * 100) / 100}ms`
+  return `${number.round(ns / 1000000000 * 100) / 100}s`
+}
+
+// Format ops/sec for display
+function format_ops(ops) {
+  if (ops < 1000) return `${ops} ops/s`
+  if (ops < 1000000) return `${number.round(ops / 1000 * 100) / 100}K ops/s`
+  if (ops < 1000000000) return `${number.round(ops / 1000000 * 100) / 100}M ops/s`
+  return `${number.round(ops / 1000000000 * 100) / 100}G ops/s`
+}
+
+// Run benchmarks for a package
+function run_benchmarks(package_name, specific_bench) {
+  var bench_files = collect_benches(package_name, specific_bench)
+
+  var pkg_result = {
+    package: package_name || "local",
+    files: [],
+    total: 0
+  }
+
+  if (bench_files.length == 0) return pkg_result
+
+  if (package_name) log.console(`Running benchmarks for ${package_name}`)
+  else log.console(`Running benchmarks for local package`)
+
+  for (var i = 0; i < bench_files.length; i++) {
+    var f = bench_files[i]
+    var mod_path = f.substring(0, f.length - 3)
+
+    var file_result = {
+      name: f,
+      benchmarks: []
+    }
+
+    try {
+      var bench_mod
+      var use_pkg = package_name ? package_name : fd.realpath('.')
+      bench_mod = shop.use(mod_path, use_pkg)
+
+      var benches = []
+      if (typeof bench_mod == 'function') {
+        benches.push({name: 'main', fn: bench_mod})
+      } else if (typeof bench_mod == 'object') {
+        for (var k in bench_mod) {
+          if (typeof bench_mod[k] == 'function') {
+            benches.push({name: k, fn: bench_mod[k]})
+          }
+        }
+      }
+
+      if (benches.length > 0) {
+        log.console(`  ${f}`)
+        for (var j = 0; j < benches.length; j++) {
+          var b = benches[j]
+          try {
+            var result = run_single_bench(b.fn, b.name)
+            result.package = pkg_result.package
+            file_result.benchmarks.push(result)
+            pkg_result.total++
+
+            log.console(`    ${result.name}`)
+            log.console(`      ${format_ns(result.median_ns)}/op  ${format_ops(result.ops_per_sec)}`)
+            log.console(`      min: ${format_ns(result.min_ns)}  max: ${format_ns(result.max_ns)}  stddev: ${format_ns(result.stddev_ns)}`)
+            if (result.batch_size > 1) {
+              log.console(`      batch: ${result.batch_size}  samples: ${result.samples}`)
+            }
+          } catch (e) {
+            log.console(`    ERROR ${b.name}: ${e}`)
+            log.error(e)
+            var error_result = {
+              package: pkg_result.package,
+              name: b.name,
+              error: e.toString()
+            }
+            file_result.benchmarks.push(error_result)
+            pkg_result.total++
+          }
+        }
+      }
+    } catch (e) {
+      log.console(`  Error loading ${f}: ${e}`)
+      var error_result = {
+        package: pkg_result.package,
+        name: "load_module",
+        error: `Error loading module: ${e}`
+      }
+      file_result.benchmarks.push(error_result)
+      pkg_result.total++
+    }
+
+    if (file_result.benchmarks.length > 0) {
+      pkg_result.files.push(file_result)
+    }
+  }
+
+  return pkg_result
+}
+
+// Run all benchmarks
+var all_results = []
+
+if (all_pkgs) {
+  if (testlib.is_valid_package('.')) {
+    all_results.push(run_benchmarks(null, null))
+  }
+
+  var packages = shop.list_packages()
+  for (var i = 0; i < packages.length; i++) {
+    all_results.push(run_benchmarks(packages[i], null))
+  }
+} else {
+  all_results.push(run_benchmarks(target_pkg, target_bench))
+}
+
+// Calculate totals
+var total_benches = 0
+for (var i = 0; i < all_results.length; i++) {
+  total_benches += all_results[i].total
+}
+
+log.console(`----------------------------------------`)
+log.console(`Benchmarks: ${total_benches} total`)
+
+// Generate reports
+function generate_reports() {
+  var timestamp = text(number.floor(time.number()))
+  var report_dir = shop.get_reports_dir() + '/bench_' + timestamp
+  testlib.ensure_dir(report_dir)
+
+  var txt_report = `BENCHMARK REPORT
+Date: ${time.text(time.number())}
+Total benchmarks: ${total_benches}
+
+=== SUMMARY ===
+`
+  for (var i = 0; i < all_results.length; i++) {
+    var pkg_res = all_results[i]
+    if (pkg_res.total == 0) continue
+    txt_report += `Package: ${pkg_res.package}\n`
+    for (var j = 0; j < pkg_res.files.length; j++) {
+      var f = pkg_res.files[j]
+      txt_report += `  ${f.name}\n`
+      for (var k = 0; k < f.benchmarks.length; k++) {
+        var b = f.benchmarks[k]
+        if (b.error) {
+          txt_report += `    ERROR ${b.name}: ${b.error}\n`
+        } else {
+          txt_report += `    ${b.name}: ${format_ns(b.median_ns)}/op (${format_ops(b.ops_per_sec)})\n`
+        }
+      }
+    }
+  }
+
+  txt_report += `\n=== DETAILED RESULTS ===\n`
+  for (var i = 0; i < all_results.length; i++) {
+    var pkg_res = all_results[i]
+    if (pkg_res.total == 0) continue
+
+    for (var j = 0; j < pkg_res.files.length; j++) {
+      var f = pkg_res.files[j]
+      for (var k = 0; k < f.benchmarks.length; k++) {
+        var b = f.benchmarks[k]
+        if (b.error) continue
+
+        txt_report += `\n${pkg_res.package}::${b.name}\n`
+        txt_report += `  batch_size: ${b.batch_size}  samples: ${b.samples}\n`
+        txt_report += `  median: ${format_ns(b.median_ns)}/op\n`
+        txt_report += `  mean: ${format_ns(b.mean_ns)}/op\n`
+        txt_report += `  min: ${format_ns(b.min_ns)}\n`
+        txt_report += `  max: ${format_ns(b.max_ns)}\n`
+        txt_report += `  stddev: ${format_ns(b.stddev_ns)}\n`
+        txt_report += `  p95: ${format_ns(b.p95_ns)}\n`
+        txt_report += `  p99: ${format_ns(b.p99_ns)}\n`
+        txt_report += `  ops/s: ${format_ops(b.ops_per_sec)}\n`
+      }
+    }
+  }
+
+  testlib.ensure_dir(report_dir)
+  fd.slurpwrite(`${report_dir}/bench.txt`, stone(new blob(txt_report)))
+  log.console(`Report written to ${report_dir}/bench.txt`)
+
+  // Generate JSON per package
+  for (var i = 0; i < all_results.length; i++) {
+    var pkg_res = all_results[i]
+    if (pkg_res.total == 0) continue
+
+    var pkg_benches = []
+    for (var j = 0; j < pkg_res.files.length; j++) {
+      var f = pkg_res.files[j]
+      for (var k = 0; k < f.benchmarks.length; k++) {
+        pkg_benches.push(f.benchmarks[k])
+      }
+    }
+
+    var json_path = `${report_dir}/${pkg_res.package.replace(/\//g, '_')}.json`
+    fd.slurpwrite(json_path, stone(new blob(json.encode(pkg_benches))))
+  }
+}
+
+generate_reports()
+$stop()

benches/micro_ops.cm

@@ -0,0 +1,262 @@
+// micro_ops.bench.ce (or .cm depending on your convention)
+
+// Note: We use a function-local sink in each benchmark to avoid cross-contamination
+function blackhole(sink, x) {
+  // Prevent dead-code elimination
+  return (sink + (x | 0)) | 0
+}
+
+function make_obj_xy(x, y) {
+  return { x, y }
+}
+
+function make_obj_yx(x, y) {
+  // Different insertion order to force a different shape in many engines
+  return { y, x }
+}
+
+function make_shapes(n) {
+  var out = []
+  for (var i = 0; i < n; i++) {
+    var o = { a: i }
+    o[`p${i}`] = i
+    out.push(o)
+  }
+  return out
+}
+
+function make_packed_array(n) {
+  var a = []
+  for (var i = 0; i < n; i++) a.push(i)
+  return a
+}
+
+function make_holey_array(n) {
+  var a = []
+  for (var i = 0; i < n; i += 2) a[i] = i
+  return a
+}
+
+return {
+  // 0) Baseline loop cost
+  loop_empty: function(n) {
+    var sink = 0
+    for (var i = 0; i < n; i++) {}
+    return blackhole(sink, n)
+  },
+
+  // 1) Numeric pipelines
+  i32_add: function(n) {
+    var sink = 0
+    var x = 1
+    for (var i = 0; i < n; i++) x = (x + 3) | 0
+    return blackhole(sink, x)
+  },
+
+  f64_add: function(n) {
+    var sink = 0
+    var x = 1.0
+    for (var i = 0; i < n; i++) x = x + 3.14159
+    return blackhole(sink, x | 0)
+  },
+
+  mixed_add: function(n) {
+    var sink = 0
+    var x = 1
+    for (var i = 0; i < n; i++) x = x + 0.25
+    return blackhole(sink, x | 0)
+  },
+
+  bit_ops: function(n) {
+    var sink = 0
+    var x = 0x12345678
+    for (var i = 0; i < n; i++) x = ((x << 5) ^ (x >>> 3)) | 0
+    return blackhole(sink, x)
+  },
+
+  overflow_path: function(n) {
+    var sink = 0
+    var x = 0x70000000
+    for (var i = 0; i < n; i++) x = (x + 0x10000000) | 0
+    return blackhole(sink, x)
+  },
+
+  // 2) Branching
+  branch_predictable: function(n) {
+    var sink = 0
+    var x = 0
+    for (var i = 0; i < n; i++) {
+      if ((i & 7) != 0) x++
+      else x += 2
+    }
+    return blackhole(sink, x)
+  },
+
+  branch_alternating: function(n) {
+    var sink = 0
+    var x = 0
+    for (var i = 0; i < n; i++) {
+      if ((i & 1) == 0) x++
+      else x += 2
+    }
+    return blackhole(sink, x)
+  },
+
+  // 3) Calls
+  call_direct: function(n) {
+    var sink = 0
+    function f(a) { return (a + 1) | 0 }
+    var x = 0
+    for (var i = 0; i < n; i++) x = f(x)
+    return blackhole(sink, x)
+  },
+
+  call_indirect: function(n) {
+    var sink = 0
+    function f(a) { return (a + 1) | 0 }
+    var g = f
+    var x = 0
+    for (var i = 0; i < n; i++) x = g(x)
+    return blackhole(sink, x)
+  },
+
+  call_closure: function(n) {
+    var sink = 0
+    function make_adder(k) {
+      return function(a) { return (a + k) | 0 }
+    }
+    var add3 = make_adder(3)
+    var x = 0
+    for (var i = 0; i < n; i++) x = add3(x)
+    return blackhole(sink, x)
+  },
+
+  // 4) Object props (ICs / shapes)
+  prop_read_mono: function(n) {
+    var sink = 0
+    var o = make_obj_xy(1, 2)
+    var x = 0
+    for (var i = 0; i < n; i++) x = (x + o.x) | 0
+    return blackhole(sink, x)
+  },
+
+  prop_read_poly_2: function(n) {
+    var sink = 0
+    var a = make_obj_xy(1, 2)
+    var b = make_obj_yx(1, 2)
+    var x = 0
+    for (var i = 0; i < n; i++) {
+      var o = (i & 1) == 0 ? a : b
+      x = (x + o.x) | 0
+    }
+    return blackhole(sink, x)
+  },
+
+  prop_read_mega: function(n) {
+    var sink = 0
+    var objs = make_shapes(32)
+    var x = 0
+    for (var i = 0; i < n; i++) {
+      var o = objs[i & 31]
+      x = (x + o.a) | 0
+    }
+    return blackhole(sink, x)
+  },
+
+  prop_write_mono: function(n) {
+    var sink = 0
+    var o = make_obj_xy(1, 2)
+    for (var i = 0; i < n; i++) o.x = (o.x + 1) | 0
+    return blackhole(sink, o.x)
+  },
+
+  // 5) Arrays
+  array_read_packed: function(n) {
+    var sink = 0
+    var a = make_packed_array(1024)
+    var x = 0
+    for (var i = 0; i < n; i++) x = (x + a[i & 1023]) | 0
+    return blackhole(sink, x)
+  },
+
+  array_write_packed: function(n) {
+    var sink = 0
+    var a = make_packed_array(1024)
+    for (var i = 0; i < n; i++) a[i & 1023] = i
+    return blackhole(sink, a[17] | 0)
+  },
+
+  array_read_holey: function(n) {
+    var sink = 0
+    var a = make_holey_array(2048)
+    var x = 0
+    for (var i = 0; i < n; i++) {
+      var v = a[(i & 2047)]
+      // If "missing" is a special value in your language, this stresses that path too
+      if (v) x = (x + v) | 0
+    }
+    return blackhole(sink, x)
+  },
+
+  array_push_steady: function(n) {
+    var sink = 0
+    var x = 0
+    for (var j = 0; j < n; j++) {
+      var a = []
+      for (var i = 0; i < 256; i++) a.push(i)
+      x = (x + a.length) | 0
+    }
+    return blackhole(sink, x)
+  },
+
+  // 6) Strings
+  string_concat_small: function(n) {
+    var sink = 0
+    var x = 0
+    for (var j = 0; j < n; j++) {
+      var s = ""
+      for (var i = 0; i < 16; i++) s = s + "x"
+      x = (x + s.length) | 0
+    }
+    return blackhole(sink, x)
+  },
+
+  // 7) Allocation / GC pressure
+  alloc_tiny_objects: function(n) {
+    var sink = 0
+    var x = 0
+    for (var i = 0; i < n; i++) {
+      var o = { a: i, b: i + 1, c: i + 2 }
+      x = (x + o.b) | 0
+    }
+    return blackhole(sink, x)
+  },
+
+  alloc_linked_list: function(n) {
+    var sink = 0
+    var head = null
+    for (var i = 0; i < n; i++) head = { v: i, next: head }
+    var x = 0
+    var p = head
+    while (p) {
+      x = (x + p.v) | 0
+      p = p.next
+    }
+    return blackhole(sink, x)
+  },
+
+  // 8) meme-specific (adapt these to your exact semantics)
+  meme_clone_read: function(n) {
+    // If meme(obj) clones like Object.create / prototypal clone, this hits it hard.
+    // Replace with your exact meme call form.
+    var sink = 0
+    var base = { x: 1, y: 2 }
+    var x = 0
+    for (var i = 0; i < n; i++) {
+      var o = meme(base)
+      x = (x + o.x) | 0
+    }
+    return blackhole(sink, x)
+  },
+
+}

benchmarks/binarytree.ce

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

benchmarks/eratosthenes.ce

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

benchmarks/fannkuch.ce

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

benchmarks/fib.ce

@@ -0,0 +1,16 @@
+var time = use('time')
+
+function fib(n) {
+  if (n<2) return n
+  return fib(n-1) + fib(n-2)
+}
+
+var now = time.number()
+var arr = [1,2,3,4,5]
+for (var i in arr) {
+  log.console(fib(28))
+}
+
+log.console(`elapsed: ${time.number()-now}`)
+
+$stop()

benchmarks/hyperfine_wota_nota_json.sh

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

benchmarks/js_perf.ce

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

benchmarks/mandelbrot.ce

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

benchmarks/montecarlo.ce

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

benchmarks/nbody.ce

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

benchmarks/nota.ce

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

benchmarks/spectral-norm.ce

@@ -0,0 +1,52 @@
+const math = require('math/radians');
+
+function A(i,j) {
+  return 1/((i+j)*(i+j+1)/2+i+1);
+}
+
+function Au(u,v) {
+  for (var i=0; i<u.length; ++i) {
+    var t = 0;
+    for (var j=0; j<u.length; ++j)
+      t += A(i,j) * u[j];
+      
+    v[i] = t;
+  }
+}
+
+function Atu(u,v) {
+  for (var i=0; i<u.length; ++i) {
+    var t = 0;
+    for (var j=0; j<u.length; ++j)
+      t += A(j,i) * u[j];
+      
+    v[i] = t;
+  }
+}
+
+function AtAu(u,v,w) {
+  Au(u,w);
+  Atu(w,v);
+}
+
+function spectralnorm(n) {
+  var i, u=[], v=[], w=[], vv=0, vBv=0;
+  for (i=0; i<n; ++i)
+    u[i] = 1; v[i] = w[i] = 0; 
+
+  for (i=0; i<10; ++i) {
+    AtAu(u,v,w);
+    AtAu(v,u,w);
+  }
+  
+  for (i=0; i<n; ++i) {
+    vBv += u[i]*v[i];
+    vv  += v[i]*v[i];
+  }
+  
+  return math.sqrt(vBv/vv);
+}
+
+log.console(spectralnorm(arg[0]).toFixed(9));
+
+$stop()

benchmarks/wota.ce

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

benchmarks/wota_nota_json.ce

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

build.ce

@@ -0,0 +1,102 @@
+// cell build [options] - Build dynamic libraries locally for the current machine
+//
+// Usage:
+//   cell build                Build dynamic libraries for all packages
+//   cell build -p <pkg>       Build dynamic library for specific package
+//   cell build -t <target>    Cross-compile dynamic libraries for target platform
+
+var build = use('build')
+var shop = use('internal/shop')
+var pkg_tools = use('package')
+var fd = use('fd')
+
+var target = null
+var target_package = null
+var buildtype = 'debug'
+
+for (var i = 0; i < args.length; i++) {
+  if (args[i] == '-t' || args[i] == '--target') {
+    if (i + 1 < args.length) {
+      target = args[++i]
+    } else {
+      log.error('-t requires a target')
+      $stop()
+    }
+  } else if (args[i] == '-p' || args[i] == '--package') {
+    if (i + 1 < args.length) {
+      target_package = args[++i]
+    } else {
+      log.error('-p requires a package name')
+      $stop()
+    }
+  } else if (args[i] == '-b' || args[i] == '--buildtype') {
+    if (i + 1 < args.length) {
+      buildtype = args[++i]
+      if (buildtype != 'release' && buildtype != 'debug' && buildtype != 'minsize') {
+        log.error('Invalid buildtype: ' + buildtype + '. Must be release, debug, or minsize')
+        $stop()
+      }
+    } else {
+      log.error('-b requires a buildtype (release, debug, minsize)')
+      $stop()
+    }
+  } else if (args[i] == '--list-targets') {
+    log.console('Available targets:')
+    var targets = build.list_targets()
+    for (var t = 0; t < targets.length; t++) {
+      log.console('  ' + targets[t])
+    }
+    $stop()
+  }
+}
+
+// Detect target if not specified
+if (!target) {
+  target = build.detect_host_target()
+  if (target) log.console('Target: ' + target)
+}
+
+if (target && !build.has_target(target)) {
+  log.error('Invalid target: ' + target)
+  log.console('Available targets: ' + build.list_targets().join(', '))
+  $stop()
+}
+
+var packages = shop.list_packages()
+log.console('Preparing packages...')
+for (var package of packages) {
+  if (package == 'core') continue
+  shop.extract(package)
+}
+
+if (target_package) {
+  // Build single package
+  log.console('Building ' + target_package + '...')
+  try {
+    var lib = build.build_dynamic(target_package, target, buildtype)
+    if (lib) {
+      log.console('Built: ' + lib)
+    }
+  } catch (e) {
+    log.error('Build failed: ' + e)
+    $stop()
+  }
+} else {
+  // Build all packages
+  log.console('Building all packages...')
+  var results = build.build_all_dynamic(target, buildtype)
+  
+  var success = 0
+  var failed = 0
+  for (var i = 0; i < results.length; i++) {
+    if (results[i].library) {
+      success++
+    } else if (results[i].error) {
+      failed++
+    }
+  }
+  
+  log.console(`Build complete: ${success} libraries built${failed > 0 ? `, ${failed} failed` : ''}`)
+}
+
+$stop()

build.cm

@@ -0,0 +1,406 @@
+// build.cm - Simplified build utilities for Cell
+//
+// Key functions:
+//   Build.compile_file(pkg, file, target)     - Compile a C file, returns object path
+//   Build.build_package(pkg, target)          - Build all C files for a package
+//   Build.build_dynamic(pkg, target)          - Build dynamic library for a package
+//   Build.build_static(packages, target, output) - Build static binary
+
+var fd = use('fd')
+var crypto = use('crypto')
+var blob = use('blob')
+var os = use('os')
+var toolchains = use('toolchains')
+var shop = use('internal/shop')
+var pkg_tools = use('package')
+
+var Build = {}
+
+// ============================================================================
+// Sigil replacement
+// ============================================================================
+
+// Get the local directory for prebuilt libraries
+function get_local_dir() {
+  return shop.get_local_dir()
+}
+
+// Replace sigils in a string
+// Currently supports: $LOCAL -> .cell/local full path
+function replace_sigils(str) {
+  return str.replaceAll('$LOCAL', get_local_dir())
+}
+
+// Replace sigils in an array of flags
+function replace_sigils_array(flags) {
+  var result = []
+  for (var i = 0; i < flags.length; i++) {
+    result.push(replace_sigils(flags[i]))
+  }
+  return result
+}
+
+Build.get_local_dir = get_local_dir
+
+// ============================================================================
+// Toolchain helpers
+// ============================================================================
+
+Build.list_targets = function() {
+  return array(toolchains)
+}
+
+Build.has_target = function(target) {
+  return toolchains[target] != null
+}
+
+Build.detect_host_target = function() {
+  var platform = os.platform()
+  var arch = os.arch ? os.arch() : 'arm64'
+  
+  if (platform == 'macOS' || platform == 'darwin') {
+    return arch == 'x86_64' ? 'macos_x86_64' : 'macos_arm64'
+  } else if (platform == 'Linux' || platform == 'linux') {
+    return arch == 'x86_64' ? 'linux' : 'linux_arm64'
+  } else if (platform == 'Windows' || platform == 'windows') {
+    return 'windows'
+  }
+  return null
+}
+
+// ============================================================================
+// Content-addressed build cache
+// ============================================================================
+
+function content_hash(str) {
+  var bb = stone(new blob(str))
+  return text(crypto.blake2(bb, 32), 'h')
+}
+
+function get_build_dir() {
+  return shop.get_build_dir()
+}
+
+function ensure_dir(path) {
+  if (fd.stat(path).isDirectory) return
+  var parts = path.split('/')
+  var current = path.startsWith('/') ? '/' : ''
+  for (var i = 0; i < parts.length; i++) {
+    if (parts[i] == '') continue
+    current += parts[i] + '/'
+    if (!fd.stat(current).isDirectory) {
+      fd.mkdir(current)
+    }
+  }
+}
+
+Build.ensure_dir = ensure_dir
+
+// ============================================================================
+// Compilation
+// ============================================================================
+
+// Compile a single C file for a package
+// Returns the object file path (content-addressed in .cell/build)
+Build.compile_file = function(pkg, file, target, buildtype = 'release') {
+  var pkg_dir = shop.get_package_dir(pkg)
+  var src_path = pkg_dir + '/' + file
+  
+  if (!fd.is_file(src_path)) {
+    throw new Error('Source file not found: ' + src_path)
+  }
+  
+  // Get flags (with sigil replacement)
+  var cflags = replace_sigils_array(pkg_tools.get_flags(pkg, 'CFLAGS', target))
+  var target_cflags = toolchains[target].c_args || []
+  var cc = toolchains[target].c
+  
+  // Symbol name for this file
+  var sym_name = shop.c_symbol_for_file(pkg, file)
+  
+  // Build command
+  var cmd_parts = [cc, '-c', '-fPIC']
+  
+  // Add buildtype-specific flags
+  if (buildtype == 'release') {
+    cmd_parts.push('-O3', '-DNDEBUG')
+  } else if (buildtype == 'debug') {
+    cmd_parts.push('-O2', '-g')
+  } else if (buildtype == 'minsize') {
+    cmd_parts.push('-Os', '-DNDEBUG')
+  }
+  
+  cmd_parts.push('-DCELL_USE_NAME=' + sym_name)
+  cmd_parts.push('-I"' + pkg_dir + '"')
+  
+  // Add package CFLAGS (resolve relative -I paths)
+  for (var i = 0; i < cflags.length; i++) {
+    var flag = cflags[i]
+    if (flag.startsWith('-I') && !flag.startsWith('-I/')) {
+      flag = '-I"' + pkg_dir + '/' + flag.substring(2) + '"'
+    }
+    cmd_parts.push(flag)
+  }
+  
+  // Add target CFLAGS
+  for (var i = 0; i < target_cflags.length; i++) {
+    cmd_parts.push(target_cflags[i])
+  }
+  
+  cmd_parts.push('"' + src_path + '"')
+  
+  var cmd_str = cmd_parts.join(' ')
+  
+  // Content hash: command + file content
+  var file_content = fd.slurp(src_path)
+  var hash_input = cmd_str + '\n' + text(file_content)
+  var hash = content_hash(hash_input)
+  
+  var build_dir = get_build_dir()
+  ensure_dir(build_dir)
+  var obj_path = build_dir + '/' + hash
+  
+  // Check if already compiled
+  if (fd.is_file(obj_path)) {
+    return obj_path
+  }
+  
+  // Compile
+  var full_cmd = cmd_str + ' -o "' + obj_path + '"'
+  log.console('Compiling ' + file)
+  var ret = os.system(full_cmd)
+  if (ret != 0) {
+    throw new Error('Compilation failed: ' + file)
+  }
+  
+  return obj_path
+}
+
+// Build all C files for a package
+// Returns array of object file paths
+Build.build_package = function(pkg, target = Build.detect_host_target(), exclude_main, buildtype = 'release') {
+  var c_files = pkg_tools.get_c_files(pkg, target, exclude_main)
+  var objects = []
+  
+  for (var i = 0; i < c_files.length; i++) {
+    var obj = Build.compile_file(pkg, c_files[i], target, buildtype)
+    objects.push(obj)
+  }
+  
+  return objects
+}
+
+// ============================================================================
+// Dynamic library building
+// ============================================================================
+// Build a dynamic library for a package
+// Output goes to .cell/lib/<package_name>.<ext>
+// Dynamic libraries do NOT link against core; undefined symbols are resolved at dlopen time
+Build.build_dynamic = function(pkg, target = Build.detect_host_target(), buildtype = 'release') {
+  var objects = Build.build_package(pkg, target, true, buildtype) // exclude main.c
+  
+  if (objects.length == 0) {
+    log.console('No C files in ' + pkg)
+    return null
+  }
+  
+  var lib_dir = shop.get_lib_dir()
+  ensure_dir(lib_dir)
+  
+  var lib_name = shop.lib_name_for_package(pkg)
+  var dylib_ext = toolchains[target].system == 'windows' ? '.dll' : (toolchains[target].system == 'darwin' ? '.dylib' : '.so')
+  var lib_path = lib_dir + '/' + lib_name + dylib_ext
+  
+  // Get link flags (with sigil replacement)
+  var ldflags = replace_sigils_array(pkg_tools.get_flags(pkg, 'LDFLAGS', target))
+  var target_ldflags = toolchains[target].c_link_args || []
+  var cc = toolchains[target].cpp || toolchains[target].c
+  var pkg_dir = shop.get_package_dir(pkg)
+  var local_dir = get_local_dir()
+  var tc = toolchains[target]
+  
+  // Build link command
+  var cmd_parts = [cc, '-shared', '-fPIC']
+  
+  // Platform-specific flags for undefined symbols (resolved at dlopen) and size optimization
+  if (tc.system == 'darwin') {
+    // Allow undefined symbols - they will be resolved when dlopen'd into the main executable
+    cmd_parts.push('-undefined', 'dynamic_lookup')
+    // Dead-strip unused code
+    cmd_parts.push('-Wl,-dead_strip')
+    // rpath for .cell/local libraries
+    cmd_parts.push('-Wl,-rpath,@loader_path/../local')
+    cmd_parts.push('-Wl,-rpath,' + local_dir)
+  } else if (tc.system == 'linux') {
+    // Allow undefined symbols at link time
+    cmd_parts.push('-Wl,--allow-shlib-undefined')
+    // Garbage collect unused sections
+    cmd_parts.push('-Wl,--gc-sections')
+    // rpath for .cell/local libraries
+    cmd_parts.push('-Wl,-rpath,$ORIGIN/../local')
+    cmd_parts.push('-Wl,-rpath,' + local_dir)
+  } else if (tc.system == 'windows') {
+    // Windows DLLs: use --allow-shlib-undefined for mingw
+    cmd_parts.push('-Wl,--allow-shlib-undefined')
+  }
+  
+  // Add .cell/local to library search path
+  cmd_parts.push('-L"' + local_dir + '"')
+  
+  for (var i = 0; i < objects.length; i++) {
+    cmd_parts.push('"' + objects[i] + '"')
+  }
+  
+  // Do NOT link against core library - symbols resolved at dlopen time
+  
+  // Add LDFLAGS (resolve relative -L paths)
+  for (var i = 0; i < ldflags.length; i++) {
+    var flag = ldflags[i]
+    if (flag.startsWith('-L') && !flag.startsWith('-L/')) {
+      flag = '-L"' + pkg_dir + '/' + flag.substring(2) + '"'
+    }
+    cmd_parts.push(flag)
+  }
+  
+  for (var i = 0; i < target_ldflags.length; i++) {
+    cmd_parts.push(target_ldflags[i])
+  }
+  
+  cmd_parts.push('-o', '"' + lib_path + '"')
+  
+  var cmd_str = cmd_parts.join(' ')
+  
+  log.console('Linking ' + lib_path)
+  var ret = os.system(cmd_str)
+  if (ret != 0) {
+    throw new Error('Linking failed: ' + pkg)
+  }
+  
+  return lib_path
+}
+
+// ============================================================================
+// Static binary building
+// ============================================================================
+
+// Build a static binary from multiple packages
+// packages: array of package names
+// output: output binary path
+Build.build_static = function(packages, target = Build.detect_host_target(), output, buildtype = 'release') {
+  var all_objects = []
+  var all_ldflags = []
+  var seen_flags = {}
+  
+  // Compile all packages
+  for (var i = 0; i < packages.length; i++) {
+    var pkg = packages[i]
+    var is_core = (pkg == 'core')
+    
+    // For core, include main.c; for others, exclude it
+    var objects = Build.build_package(pkg, target, !is_core, buildtype)
+    
+    for (var j = 0; j < objects.length; j++) {
+      all_objects.push(objects[j])
+    }
+    
+    // Collect LDFLAGS (with sigil replacement)
+    var ldflags = replace_sigils_array(pkg_tools.get_flags(pkg, 'LDFLAGS', target))
+    var pkg_dir = shop.get_package_dir(pkg)
+    
+    // Deduplicate based on the entire LDFLAGS string for this package
+    var ldflags_key = pkg + ':' + ldflags.join(' ')
+    if (!seen_flags[ldflags_key]) {
+      seen_flags[ldflags_key] = true
+      for (var j = 0; j < ldflags.length; j++) {
+        var flag = ldflags[j]
+        // Resolve relative -L paths
+        if (flag.startsWith('-L') && !flag.startsWith('-L/')) {
+          flag = '-L"' + pkg_dir + '/' + flag.substring(2) + '"'
+        }
+        all_ldflags.push(flag)
+      }
+    }
+  }
+  
+  if (all_objects.length == 0) {
+    throw new Error('No object files to link')
+  }
+  
+  // Link
+  var cc = toolchains[target].c
+  var target_ldflags = toolchains[target].c_link_args || []
+  var exe_ext = toolchains[target].system == 'windows' ? '.exe' : ''
+  
+  if (!output.endsWith(exe_ext) && exe_ext) {
+    output = output + exe_ext
+  }
+  
+  var cmd_parts = [cc]
+  
+  for (var i = 0; i < all_objects.length; i++) {
+    cmd_parts.push('"' + all_objects[i] + '"')
+  }
+  
+  for (var i = 0; i < all_ldflags.length; i++) {
+    cmd_parts.push(all_ldflags[i])
+  }
+  
+  for (var i = 0; i < target_ldflags.length; i++) {
+    cmd_parts.push(target_ldflags[i])
+  }
+  
+  cmd_parts.push('-o', '"' + output + '"')
+  
+  var cmd_str = cmd_parts.join(' ')
+  
+  log.console('Linking ' + output)
+  var ret = os.system(cmd_str)
+  if (ret != 0) {
+    throw new Error('Linking failed with command: ' + cmd_str)
+  }
+  
+  log.console('Built ' + output)
+  return output
+}
+
+// ============================================================================
+// Convenience functions
+// ============================================================================
+
+// Build dynamic libraries for all installed packages
+Build.build_all_dynamic = function(target, buildtype = 'release') {
+  target = target || Build.detect_host_target()
+  
+  var packages = shop.list_packages()
+  var results = []
+  
+  // Build core first
+  if (packages.indexOf('core') >= 0) {
+    try {
+      var lib = Build.build_dynamic('core', target, buildtype)
+      results.push({ package: 'core', library: lib })
+    } catch (e) {
+      log.error('Failed to build core: ' + text(e))
+      results.push({ package: 'core', error: e })
+    }
+  }
+  
+  // Build other packages
+  for (var i = 0; i < packages.length; i++) {
+    var pkg = packages[i]
+    if (pkg == 'core') continue
+    
+    try {
+      var lib = Build.build_dynamic(pkg, target, buildtype)
+      results.push({ package: pkg, library: lib })
+    } catch (e) {
+      log.error('Failed to build ' + pkg + ': ')
+      log.error(e)
+      results.push({ package: pkg, error: e })
+    }
+  }
+  
+  return results
+}
+
+return Build

cake/playdate.cm

@@ -0,0 +1 @@
+// cake file for making a playdate package

cell.toml

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

cellfs.cm

@@ -0,0 +1,481 @@
+var cellfs = {}
+
+// CellFS: A filesystem implementation using miniz and raw OS filesystem
+// Supports mounting multiple sources (fs, zip) and named mounts (@name)
+
+var fd = use('fd')
+var miniz = use('miniz')
+var qop = use('qop')
+var wildstar = use('wildstar')
+
+// Internal state
+var mounts = []  // Array of {source, type, handle, name}
+
+var writepath = "."
+
+// Helper to normalize paths
+function normalize_path(path) {
+  if (!path) return ""
+  // Remove leading/trailing slashes and normalize
+  return path.replace(/^\/+|\/+$/g, "")
+}
+
+// Helper to get directory from path
+function dirname(path) {
+  var idx = path.lastIndexOf("/")
+  if (idx == -1) return ""
+  return path.substring(0, idx)
+}
+
+// Helper to get basename from path
+function basename(path) {
+  var idx = path.lastIndexOf("/")
+  if (idx == -1) return path
+  return path.substring(idx + 1)
+}
+
+// Helper to join paths
+function join_paths(base, rel) {
+  base = base.replace(/\/+$/, "")
+  rel = rel.replace(/^\/+/, "")
+  if (!base) return rel
+  if (!rel) return base
+  return base + "/" + rel
+}
+
+// Check if a file exists in a specific mount
+function mount_exists(mount, path) {
+  if (mount.type == 'zip') {
+    try {
+      mount.handle.mod(path)
+      return true
+    } catch (e) {
+      return false
+    }
+  } else if (mount.type == 'qop') {
+    try {
+      return mount.handle.stat(path) != null
+    } catch (e) {
+      return false
+    }
+  } else { // fs
+    var full_path = join_paths(mount.source, path)
+    try {
+      var st = fd.stat(full_path)
+      return st.isFile || st.isDirectory
+    } catch (e) {
+      return false
+    }
+  }
+}
+
+// Check if a path refers to a directory in a specific mount
+function is_directory(path) {
+  var res = resolve(path)
+  var mount = res.mount
+  if (mount.type == 'zip') {
+    try {
+      return mount.handle.is_directory(path);
+    } catch (e) {
+      return false;
+    }
+  } else if (mount.type == 'qop') {
+    try {
+      return mount.handle.is_directory(path);
+    } catch (e) {
+      return false;
+    }
+  } else { // fs
+    var full_path = join_paths(mount.source, path)
+    try {
+      var st = fd.stat(full_path)
+      return st.isDirectory
+    } catch (e) {
+      return false
+    }
+  }
+}
+
+// Resolve a path to a specific mount and relative path
+// Returns { mount, path } or throws/returns null
+function resolve(path, must_exist) {
+  path = normalize_path(path)
+  
+  // Check for named mount
+  if (path.startsWith("@")) {
+    var idx = path.indexOf("/")
+    var mount_name = ""
+    var rel_path = ""
+    
+    if (idx == -1) {
+      mount_name = path.substring(1)
+      rel_path = ""
+    } else {
+      mount_name = path.substring(1, idx)
+      rel_path = path.substring(idx + 1)
+    }
+    
+    // Find named mount
+    var mount = null
+    for (var m of mounts) {
+      if (m.name == mount_name) {
+        mount = m
+        break
+      }
+    }
+    
+    if (!mount) {
+      throw new Error("Unknown mount point: @" + mount_name)
+    }
+    
+    return { mount: mount, path: rel_path }
+  }
+  
+  // Search path
+  for (var mount of mounts) {
+    if (mount_exists(mount, path)) {
+      return { mount: mount, path: path }
+    }
+  }
+  
+  if (must_exist) {
+    throw new Error("File not found in any mount: " + path)
+  }
+}
+
+// Mount a source
+function mount(source, name) {
+  // Check if source exists
+  var st = fd.stat(source)
+  
+  var mount_info = {
+    source: source,
+    name: name || null,
+    type: 'fs',
+    handle: null,
+    zip_blob: null
+  }
+  
+  if (st.isDirectory) {
+    mount_info.type = 'fs'
+  } else if (st.isFile) {
+    var blob = fd.slurp(source)
+    
+    // Try QOP first (it's likely faster to fail?) or Zip?
+    // QOP open checks magic.
+    var qop_archive = null
+    try {
+        qop_archive = qop.open(blob)
+    } catch(e) {}
+
+    if (qop_archive) {
+        mount_info.type = 'qop'
+        mount_info.handle = qop_archive
+        mount_info.zip_blob = blob // keep blob alive
+    } else {
+        var zip = miniz.read(blob)
+        if (!zip || typeof zip.count != 'function') {
+          throw new Error("Invalid archive file (not zip or qop): " + source)
+        }
+        
+        mount_info.type = 'zip'
+        mount_info.handle = zip
+        mount_info.zip_blob = blob // keep blob alive
+    }
+  } else {
+    throw new Error("Unsupported mount source type: " + source)
+  }
+  
+  mounts.push(mount_info)
+}
+
+// Unmount
+function unmount(name_or_source) {
+  for (var i = 0; i < mounts.length; i++) {
+    if (mounts[i].name == name_or_source || mounts[i].source == name_or_source) {
+      mounts.splice(i, 1)
+      return
+    }
+  }
+  throw new Error("Mount not found: " + name_or_source)
+}
+
+// Read file
+function slurp(path) {
+  var res = resolve(path, true)
+  if (!res) throw new Error("File not found: " + path)
+  
+  if (res.mount.type == 'zip') {
+    return res.mount.handle.slurp(res.path)
+  } else if (res.mount.type == 'qop') {
+    var data = res.mount.handle.read(res.path)
+    if (!data) throw new Error("File not found in qop: " + path)
+    return data
+  } else {
+    var full_path = join_paths(res.mount.source, res.path)
+    return fd.slurp(full_path)
+  }
+}
+
+// Write file
+function slurpwrite(path, data) {
+  var full_path = writepath + "/" + path
+  
+  var f = fd.open(full_path, 'w')
+  fd.write(f, data)
+  fd.close(f)
+}
+
+// Check existence
+function exists(path) {
+  var res = resolve(path, false)
+  if (path.startsWith("@")) {
+    return mount_exists(res.mount, res.path)
+  }
+  return res != null
+}
+
+// Stat
+function stat(path) {
+  var res = resolve(path, true)
+  if (!res) throw new Error("File not found: " + path)
+  
+  if (res.mount.type == 'zip') {
+    var mod = res.mount.handle.mod(res.path)
+    return {
+      filesize: 0, 
+      modtime: mod * 1000,
+      isDirectory: false 
+    }
+  } else if (res.mount.type == 'qop') {
+    var s = res.mount.handle.stat(res.path)
+    if (!s) throw new Error("File not found in qop: " + path)
+    return {
+        filesize: s.size,
+        modtime: s.modtime,
+        isDirectory: s.isDirectory
+    }
+  } else {
+    var full_path = join_paths(res.mount.source, res.path)
+    var s = fd.stat(full_path)
+    return {
+      filesize: s.size,
+      modtime: s.mtime,
+      isDirectory: s.isDirectory
+    }
+  }
+}
+
+// Get search paths
+function searchpath() {
+  return mounts.slice()
+}
+
+// Mount a package using the shop system
+function mount_package(name) {
+  if (name == null) {
+    mount('.', null)
+    return
+  }
+  
+  var shop = use('internal/shop')
+  var dir = shop.get_package_dir(name)
+
+  if (!dir) {
+    throw new Error("Package not found: " + name)
+  }
+
+  mount(dir, name)
+}
+
+// New functions for qjs_io compatibility
+
+function match(str, pattern) {
+  return wildstar.match(pattern, str, wildstar.WM_PATHNAME | wildstar.WM_PERIOD | wildstar.WM_WILDSTAR)
+}
+
+function rm(path) {
+  var res = resolve(path, true)
+  if (res.mount.type != 'fs') throw new Error("Cannot delete from non-fs mount")
+  
+  var full_path = join_paths(res.mount.source, res.path)
+  var st = fd.stat(full_path)
+  if (st.isDirectory) fd.rmdir(full_path)
+  else fd.unlink(full_path)
+}
+
+function mkdir(path) {
+  var full = join_paths(writepath, path)
+  fd.mkdir(full)
+}
+
+function set_writepath(path) {
+  writepath = path
+}
+
+function basedir() {
+  return fd.getcwd()
+}
+
+function prefdir(org, app) {
+   return "./"
+}
+
+function realdir(path) {
+   var res = resolve(path, false)
+   if (!res) return null
+   return join_paths(res.mount.source, res.path)
+}
+
+function enumerate(path, recurse) {
+    if (path == null) path = ""
+    
+    var res = resolve(path, true)
+    var results = []
+    
+    function visit(curr_full, rel_prefix) {
+       var list = fd.readdir(curr_full)
+       if (!list) return
+       
+       for (var item of list) {
+          var item_rel = rel_prefix ? rel_prefix + "/" + item : item
+          results.push(item_rel)
+          
+          if (recurse) {
+             var st = fd.stat(join_paths(curr_full, item))
+             if (st.isDirectory) {
+                visit(join_paths(curr_full, item), item_rel)
+             }
+          }
+       }
+    }
+    
+    if (res.mount.type == 'fs') {
+        var full = join_paths(res.mount.source, res.path)
+        var st = fd.stat(full)
+        if (st && st.isDirectory) {
+           visit(full, "")
+        }
+    } else if (res.mount.type == 'qop') {
+        var all = res.mount.handle.list()
+        var prefix = res.path ? res.path + "/" : ""
+        var prefix_len = prefix.length
+        
+        // Use a set to avoid duplicates if we are simulating directories
+        var seen = {}
+        
+        for (var p of all) {
+            if (p.startsWith(prefix)) {
+                var rel = p.substring(prefix_len)
+                if (rel.length == 0) continue
+                
+                if (!recurse) {
+                    var slash = rel.indexOf('/')
+                    if (slash != -1) {
+                        rel = rel.substring(0, slash)
+                    }
+                }
+                
+                if (!seen[rel]) {
+                    seen[rel] = true
+                    results.push(rel)
+                }
+            }
+        }
+    }
+    
+    return results
+}
+
+function globfs(globs, dir) {
+   if (dir == null) dir = ""
+   var res = resolve(dir, true)
+   var results = []
+   
+   function check_neg(path) {
+        for (var g of globs) {
+            if (g.startsWith("!") && wildstar.match(g.substring(1), path, wildstar.WM_WILDSTAR)) return true;
+        }
+        return false;
+    }
+    
+   function check_pos(path) {
+        for (var g of globs) {
+            if (!g.startsWith("!") && wildstar.match(g, path, wildstar.WM_WILDSTAR)) return true;
+        }
+        return false;
+    }
+
+   function visit(curr_full, rel_prefix) {
+       if (rel_prefix && check_neg(rel_prefix)) return
+
+       var list = fd.readdir(curr_full)
+       if (!list) return
+       
+       for (var item of list) {
+          var item_rel = rel_prefix ? rel_prefix + "/" + item : item
+          
+          var child_full = join_paths(curr_full, item)
+          var st = fd.stat(child_full)
+          
+          if (st.isDirectory) {
+              if (!check_neg(item_rel)) {
+                 visit(child_full, item_rel)
+              }
+          } else {
+              if (!check_neg(item_rel) && check_pos(item_rel)) {
+                  results.push(item_rel)
+              }
+          }
+       }
+   }
+   
+   if (res.mount.type == 'fs') {
+        var full = join_paths(res.mount.source, res.path)
+        var st = fd.stat(full)
+        if (st && st.isDirectory) {
+           visit(full, "")
+        }
+   } else if (res.mount.type == 'qop') {
+        var all = res.mount.handle.list()
+        var prefix = res.path ? res.path + "/" : ""
+        var prefix_len = prefix.length
+        
+        for (var p of all) {
+            if (p.startsWith(prefix)) {
+                var rel = p.substring(prefix_len)
+                if (rel.length == 0) continue
+                
+                if (!check_neg(rel) && check_pos(rel)) {
+                    results.push(rel)
+                }
+            }
+        }
+   }
+   
+   return results
+}
+
+// Exports
+cellfs.mount = mount
+cellfs.mount_package = mount_package
+cellfs.unmount = unmount
+cellfs.slurp = slurp
+cellfs.slurpwrite = slurpwrite
+cellfs.exists = exists
+cellfs.is_directory = is_directory
+cellfs.stat = stat
+cellfs.searchpath = searchpath
+cellfs.match = match
+cellfs.enumerate = enumerate
+cellfs.globfs = globfs
+cellfs.rm = rm
+cellfs.mkdir = mkdir
+cellfs.writepath = set_writepath
+cellfs.basedir = basedir
+cellfs.prefdir = prefdir
+cellfs.realdir = realdir
+
+cellfs.mount('.')
+
+return cellfs

clean.ce

@@ -0,0 +1,26 @@
+// cell clean - Remove build artifacts from global shop
+
+var fd = use('fd')
+var shop = use('internal/shop')
+
+var build_dir = shop.get_shop_path() + '/build'
+
+if (!fd.is_dir(build_dir)) {
+  log.console("No build directory found at " + build_dir)
+  $stop()
+  return
+}
+
+log.console("Cleaning build artifacts...")
+
+// Remove the build directory
+try {
+  fd.rm(build_dir)
+  log.console("Build directory removed: " + build_dir)
+} catch (e) {
+  log.error(e)
+}
+
+log.console("Clean complete!")
+
+$stop()

clone.ce

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

config.ce

@@ -0,0 +1,246 @@
+// cell config - Manage system and actor configurations
+
+var toml = use('toml')
+var pkg = use('package')
+
+function print_help() {
+  log.console("Usage: cell config <command> [options]")
+  log.console("")
+  log.console("Commands:")
+  log.console("  get <key>                    Get a configuration value")
+  log.console("  set <key> <value>            Set a configuration value")
+  log.console("  list                         List all configurations")
+  log.console("  actor <name> get <key>       Get actor-specific config")
+  log.console("  actor <name> set <key> <val> Set actor-specific config")
+  log.console("  actor <name> list            List actor configurations")
+  log.console("")
+  log.console("Examples:")
+  log.console("  cell config get system.ar_timer")
+  log.console("  cell config set system.net_service 0.2")
+  log.console("  cell config actor prosperon/_sdl_video set resolution 1920x1080")
+  log.console("  cell config actor extramath/spline set precision high")
+  log.console("")
+  log.console("System keys:")
+  log.console("  system.ar_timer         - Seconds before idle actor reclamation")
+  log.console("  system.actor_memory     - MB of memory an actor can use (0=unbounded)")
+  log.console("  system.net_service      - Seconds per network service pull")
+  log.console("  system.reply_timeout    - Seconds to hold callback for replies (0=unbounded)")
+  log.console("  system.actor_max        - Max number of simultaneous actors")
+  log.console("  system.stack_max        - MB of memory each actor's stack can grow to")
+}
+
+// Parse a dot-notation key into path segments
+function parse_key(key) {
+  return key.split('.')
+}
+
+// Get a value from nested object using path
+function get_nested(obj, path) {
+  var current = obj
+  for (var segment of path) {
+    if (!current || typeof current != 'object') return null
+    current = current[segment]
+  }
+  return current
+}
+
+// Set a value in nested object using path
+function set_nested(obj, path, value) {
+  var current = obj
+  for (var i = 0; i < path.length - 1; i++) {
+    var segment = path[i]
+    if (!current[segment] || typeof current[segment] != 'object') {
+      current[segment] = {}
+    }
+    current = current[segment]
+  }
+  current[path[path.length - 1]] = value
+}
+
+// Parse value string into appropriate type
+function parse_value(str) {
+  // Boolean
+  if (str == 'true') return true
+  if (str == 'false') return false
+  
+  // Number (including underscores)
+  var num_str = str.replace(/_/g, '')
+  if (/^-?\d+$/.test(num_str)) return parseInt(num_str)
+  if (/^-?\d*\.\d+$/.test(num_str)) return parseFloat(num_str)
+  
+  // String
+  return str
+}
+
+// Format value for display
+function format_value(val) {
+  if (typeof val == 'string') return '"' + val + '"'
+  if (typeof val == 'number' && val >= 1000) {
+    // Add underscores to large numbers
+    return val.toString().replace(/\B(?=(\d{3})+(?!\d))/g, '_')
+  }
+  return text(val)
+}
+
+// Print configuration tree recursively
+function print_config(obj, prefix = '') {
+  for (var key in obj) {
+    var val = obj[key]
+    var full_key = prefix ? prefix + '.' + key : key
+    
+    if (isa(val, object))
+      print_config(val, full_key)
+    else
+      log.console(full_key + ' = ' + format_value(val))
+  }
+}
+
+// Main command handling
+if (args.length == 0) {
+  print_help()
+  $stop()
+  return
+}
+
+var config = pkg.load_config()
+if (!config) {
+  log.error("Failed to load cell.toml")
+  $stop()
+  return
+}
+
+var command = args[0]
+
+switch (command) {
+  case 'help':
+  case '-h':
+  case '--help':
+    print_help()
+    break
+    
+  case 'list':
+    log.console("# Cell Configuration")
+    log.console("")
+    print_config(config)
+    break
+    
+  case 'get':
+    if (args.length < 2) {
+      log.error("Usage: cell config get <key>")
+      $stop()
+      return
+    }
+    var key = args[1]
+    var path = parse_key(key)
+    var value = get_nested(config, path)
+    
+    if (value == null) {
+      log.error("Key not found: " + key)
+    } else if (isa(value, object)) {
+      // Print all nested values
+      print_config(value, key)
+    } else {
+      log.console(key + ' = ' + format_value(value))
+    }
+    break
+    
+  case 'set':
+    if (args.length < 3) {
+      log.error("Usage: cell config set <key> <value>")
+      $stop()
+      return
+    }
+    var key = args[1]
+    var value_str = args[2]
+    var path = parse_key(key)
+    var value = parse_value(value_str)
+    
+    // Validate system keys
+    if (path[0] == 'system') {
+      var valid_system_keys = [
+        'ar_timer', 'actor_memory', 'net_service', 
+        'reply_timeout', 'actor_max', 'stack_max'
+      ]
+      if (!valid_system_keys.includes(path[1])) {
+        log.error("Invalid system key. Valid keys: " + valid_system_keys.join(', '))
+        $stop()
+        return
+      }
+    }
+    
+    set_nested(config, path, value)
+    pkg.save_config(config)
+    log.console("Set " + key + " = " + format_value(value))
+    break
+    
+  case 'actor':
+    // Handle actor-specific configuration
+    if (args.length < 3) {
+      log.error("Usage: cell config actor <name> <command> [options]")
+      $stop()
+      return
+    }
+    
+    var actor_name = args[1]
+    var actor_cmd = args[2]
+    
+    // Initialize actors section if needed
+    config.actors = config.actors || {}
+    config.actors[actor_name] = config.actors[actor_name] || {}
+    
+    switch (actor_cmd) {
+      case 'list':
+        if (array(config.actors[actor_name]).length == 0) {
+          log.console("No configuration for actor: " + actor_name)
+        } else {
+          log.console("# Configuration for actor: " + actor_name)
+          log.console("")
+          print_config(config.actors[actor_name], 'actors.' + actor_name)
+        }
+        break
+        
+      case 'get':
+        if (args.length < 4) {
+          log.error("Usage: cell config actor <name> get <key>")
+          $stop()
+          return
+        }
+        var key = args[3]
+        var path = parse_key(key)
+        var value = get_nested(config.actors[actor_name], path)
+        
+        if (value == null) {
+          log.error("Key not found for actor " + actor_name + ": " + key)
+        } else {
+          log.console('actors.' + actor_name + '.' + key + ' = ' + format_value(value))
+        }
+        break
+        
+      case 'set':
+        if (args.length < 5) {
+          log.error("Usage: cell config actor <name> set <key> <value>")
+          $stop()
+          return
+        }
+        var key = args[3]
+        var value_str = args[4]
+        var path = parse_key(key)
+        var value = parse_value(value_str)
+        
+        set_nested(config.actors[actor_name], path, value)
+        pkg.save_config(config)
+        log.console("Set actors." + actor_name + "." + key + " = " + format_value(value))
+        break
+        
+      default:
+        log.error("Unknown actor command: " + actor_cmd)
+        log.console("Valid commands: list, get, set")
+    }
+    break
+    
+  default:
+    log.error("Unknown command: " + command)
+    print_help()
+}
+
+$stop()

crypto.c

@@ -0,0 +1,246 @@
+#include "cell.h"
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "monocypher.h"
+
+/*
+  Crypto Module Documentation
+  
+  This module provides cryptographic functions using the Monocypher library.
+  All inputs and outputs are Blobs.
+  
+  Functions:
+  
+  - keypair() -> { public: Blob(256 bits), private: Blob(256 bits) }
+    Generates a new random X25519 keypair.
+    
+  - shared(public_key, private_key) -> Blob(256 bits)
+    Computes a shared secret from your private key and another's public key (X25519).
+    Input keys must be 256 bits (32 bytes).
+    
+  - blake2(data, [hash_size_bytes=32]) -> Blob
+    Computes the BLAKE2b hash of the data.
+    Default hash size is 32 bytes (256 bits). Supports 1-64 bytes.
+    
+  - sign(secret_key, message) -> Blob(512 bits)
+    Signs a message using EdDSA. 
+    secret_key must be 512 bits (64 bytes). 
+    (Note: If you have a 32-byte seed, extend it first or use appropriate key generation).
+    Returns a 64-byte signature.
+    
+  - verify(signature, public_key, message) -> bool
+    Verifies an EdDSA signature.
+    signature: 512 bits (64 bytes).
+    public_key: 256 bits (32 bytes).
+    Returns true if valid, false otherwise.
+    
+  - lock(key, nonce, message, [ad]) -> Blob
+    Encrypts and authenticates a message using XChaCha20-Poly1305.
+    key: 256 bits (32 bytes).
+    nonce: 192 bits (24 bytes).
+    ad: Optional associated data (Blob).
+    Returns a blob containing the ciphertext followed by the 16-byte MAC.
+    
+  - unlock(key, nonce, ciphertext_with_mac, [ad]) -> Blob or null
+    Decrypts and verifies a message.
+    key: 256 bits (32 bytes).
+    nonce: 192 bits (24 bytes).
+    ciphertext_with_mac: Must include the 16-byte MAC at the end.
+    ad: Optional associated data (Blob).
+    Returns the plaintext Blob if successful, or null if verification fails.
+*/
+
+// Helper to get blob data and check exact bit length
+static void *get_blob_check_bits(JSContext *js, JSValue val, size_t expected_bits, const char *name) {
+    size_t bits;
+    void* result = js_get_blob_data_bits(js, &bits, val);
+    if (result == -1) {
+        return NULL; // Exception already thrown by js_get_blob_data_bits
+    }
+
+    if (bits != expected_bits) {
+        JS_ThrowTypeError(js, "%s: expected %zu bits, got %zu", name, expected_bits, bits);
+        return NULL;
+    }
+    return result;
+}
+
+// Helper to get any blob data (checking it is a stoned blob)
+static void *get_blob_any(JSContext *js, JSValue val, size_t *out_bits, const char *name) {
+    void *result = js_get_blob_data_bits(js, out_bits, val);
+    if (result == -1)
+        return NULL;
+    return result;
+}
+
+
+JSValue js_crypto_shared(JSContext *js, JSValue self, int argc, JSValue *argv)
+{
+    if (argc < 2) {
+        return JS_ThrowTypeError(js, "crypto.shared: expected public_key, private_key");
+    }
+
+    uint8_t *pub = get_blob_check_bits(js, argv[0], 256, "crypto.shared public_key");
+    if (!pub) return JS_EXCEPTION;
+
+    uint8_t *priv = get_blob_check_bits(js, argv[1], 256, "crypto.shared private_key");
+    if (!priv) return JS_EXCEPTION;
+
+    uint8_t shared[32];
+    crypto_x25519(shared, priv, pub);
+
+    return js_new_blob_stoned_copy(js, shared, 32);
+}
+
+JSValue js_crypto_blake2(JSContext *js, JSValue self, int argc, JSValue *argv)
+{
+    if (argc < 1)
+        return JS_ThrowTypeError(js, "crypto.blake2: expected data blob");
+    
+    size_t data_bits;
+    uint8_t *data = get_blob_any(js, argv[0], &data_bits, "crypto.blake2 data");
+    if (!data) return JS_EXCEPTION;
+    
+    int32_t hash_len = 32;
+    if (argc > 1) {
+        if (JS_ToInt32(js, &hash_len, argv[1]))
+            return JS_EXCEPTION;
+        if (hash_len < 1 || hash_len > 64)
+            return JS_ThrowRangeError(js, "crypto.blake2: hash length must be between 1 and 64 bytes");
+    }
+    
+    uint8_t hash[64];
+    // Use (bits + 7) / 8 to get byte length covering all bits
+    crypto_blake2b(hash, hash_len, data, (data_bits + 7) / 8);
+    
+    return js_new_blob_stoned_copy(js, hash, hash_len);
+}
+
+JSValue js_crypto_sign(JSContext *js, JSValue self, int argc, JSValue *argv) {
+    if (argc < 2) return JS_ThrowTypeError(js, "crypto.sign: expected secret_key, message");
+    
+    uint8_t *sk = get_blob_check_bits(js, argv[0], 512, "crypto.sign secret_key");
+    if (!sk) return JS_EXCEPTION;
+    
+    size_t msg_bits;
+    uint8_t *msg = get_blob_any(js, argv[1], &msg_bits, "crypto.sign message");
+    if (!msg) return JS_EXCEPTION;
+    
+    uint8_t sig[64];
+    crypto_eddsa_sign(sig, sk, msg, (msg_bits + 7) / 8);
+    
+    return js_new_blob_stoned_copy(js, sig, 64);
+}
+
+JSValue js_crypto_verify(JSContext *js, JSValue self, int argc, JSValue *argv) {
+    if (argc < 3) return JS_ThrowTypeError(js, "crypto.verify: expected signature, public_key, message");
+    
+    uint8_t *sig = get_blob_check_bits(js, argv[0], 512, "crypto.verify signature");
+    if (!sig) return JS_EXCEPTION;
+    
+    uint8_t *pk = get_blob_check_bits(js, argv[1], 256, "crypto.verify public_key");
+    if (!pk) return JS_EXCEPTION;
+    
+    size_t msg_bits;
+    uint8_t *msg = get_blob_any(js, argv[2], &msg_bits, "crypto.verify message");
+    if (!msg) return JS_EXCEPTION;
+    
+    int ret = crypto_eddsa_check(sig, pk, msg, (msg_bits + 7) / 8);
+    return JS_NewBool(js, ret == 0);
+}
+
+JSValue js_crypto_lock(JSContext *js, JSValue self, int argc, JSValue *argv) {
+    if (argc < 3) return JS_ThrowTypeError(js, "crypto.lock: expected key, nonce, message, [ad]");
+    
+    uint8_t *key = get_blob_check_bits(js, argv[0], 256, "crypto.lock key");
+    if (!key) return JS_EXCEPTION;
+    
+    uint8_t *nonce = get_blob_check_bits(js, argv[1], 192, "crypto.lock nonce");
+    if (!nonce) return JS_EXCEPTION;
+    
+    size_t msg_bits;
+    uint8_t *msg = get_blob_any(js, argv[2], &msg_bits, "crypto.lock message");
+    if (!msg) return JS_EXCEPTION;
+    size_t msg_len = (msg_bits + 7) / 8;
+    
+    size_t ad_len = 0;
+    uint8_t *ad = NULL;
+    if (argc > 3 && !JS_IsNull(argv[3])) {
+        size_t ad_bits;
+        ad = get_blob_any(js, argv[3], &ad_bits, "crypto.lock ad");
+        if (!ad) return JS_EXCEPTION;
+        ad_len = (ad_bits + 7) / 8;
+    }
+    
+    size_t out_len = msg_len + 16;
+    uint8_t *out = malloc(out_len);
+    if (!out) return JS_ThrowOutOfMemory(js);
+    
+    // Output: [Ciphertext (msg_len)] [MAC (16)]
+    crypto_aead_lock(out, out + msg_len, key, nonce, ad, ad_len, msg, msg_len);
+    
+    JSValue ret = js_new_blob_stoned_copy(js, out, out_len);
+    free(out);
+    return ret;
+}
+
+JSValue js_crypto_unlock(JSContext *js, JSValue self, int argc, JSValue *argv) {
+    if (argc < 3) return JS_ThrowTypeError(js, "crypto.unlock: expected key, nonce, ciphertext, [ad]");
+    
+    uint8_t *key = get_blob_check_bits(js, argv[0], 256, "crypto.unlock key");
+    if (!key) return JS_EXCEPTION;
+    
+    uint8_t *nonce = get_blob_check_bits(js, argv[1], 192, "crypto.unlock nonce");
+    if (!nonce) return JS_EXCEPTION;
+    
+    size_t cipher_bits;
+    uint8_t *cipher = get_blob_any(js, argv[2], &cipher_bits, "crypto.unlock ciphertext");
+    if (!cipher) return JS_EXCEPTION;
+    
+    size_t cipher_len = (cipher_bits + 7) / 8;
+    if (cipher_len < 16) return JS_ThrowTypeError(js, "crypto.unlock: ciphertext too short (min 16 bytes)");
+    
+    size_t msg_len = cipher_len - 16;
+    
+    size_t ad_len = 0;
+    uint8_t *ad = NULL;
+    if (argc > 3 && !JS_IsNull(argv[3])) {
+        size_t ad_bits;
+        ad = get_blob_any(js, argv[3], &ad_bits, "crypto.unlock ad");
+        if (!ad) return JS_EXCEPTION;
+        ad_len = (ad_bits + 7) / 8;
+    }
+    
+    uint8_t *out = malloc(msg_len > 0 ? msg_len : 1);
+    if (!out) return JS_ThrowOutOfMemory(js);
+    
+    // MAC is at cipher + msg_len
+    const uint8_t *mac = cipher + msg_len;
+    
+    if (crypto_aead_unlock(out, mac, key, nonce, ad, ad_len, cipher, msg_len) != 0) {
+        free(out);
+        return JS_NULL;
+    }
+    
+    JSValue ret = js_new_blob_stoned_copy(js, out, msg_len);
+    free(out);
+    return ret;
+}
+
+static const JSCFunctionListEntry js_crypto_funcs[] = {
+  JS_CFUNC_DEF("shared", 2, js_crypto_shared),
+  JS_CFUNC_DEF("blake2", 1, js_crypto_blake2),
+  JS_CFUNC_DEF("sign", 2, js_crypto_sign),
+  JS_CFUNC_DEF("verify", 3, js_crypto_verify),
+  JS_CFUNC_DEF("lock", 3, js_crypto_lock),
+  JS_CFUNC_DEF("unlock", 3, js_crypto_unlock),
+};
+
+JSValue js_crypto_use(JSContext *js)
+{
+  JSValue obj = JS_NewObject(js);
+  JS_SetPropertyFunctionList(js, obj, js_crypto_funcs, sizeof(js_crypto_funcs)/sizeof(js_crypto_funcs[0]));
+  return obj;
+}

debug/debug.c

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

debug/js.c

@@ -0,0 +1,111 @@
+#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.
+JSC_CCALL(os_calc_mem,
+  JSMemoryUsage mu;
+  JS_ComputeMemoryUsage(JS_GetRuntime(js),&mu);
+  ret = JS_NewObject(js);
+  JS_SetPropertyStr(js,ret,"malloc_size",number2js(js,mu.malloc_size));
+  JS_SetPropertyStr(js,ret,"malloc_limit",number2js(js,mu.malloc_limit));
+  JS_SetPropertyStr(js,ret,"memory_used_size",number2js(js,mu.memory_used_size));
+  JS_SetPropertyStr(js,ret,"malloc_count",number2js(js,mu.malloc_count));
+  JS_SetPropertyStr(js,ret,"memory_used_count",number2js(js,mu.memory_used_count));
+  JS_SetPropertyStr(js,ret,"atom_count",number2js(js,mu.atom_count));
+  JS_SetPropertyStr(js,ret,"atom_size",number2js(js,mu.atom_size));
+  JS_SetPropertyStr(js,ret,"str_count",number2js(js,mu.str_count));
+  JS_SetPropertyStr(js,ret,"str_size",number2js(js,mu.str_size));
+  JS_SetPropertyStr(js,ret,"obj_count",number2js(js,mu.obj_count));
+  JS_SetPropertyStr(js,ret,"obj_size",number2js(js,mu.obj_size));
+  JS_SetPropertyStr(js,ret,"prop_count",number2js(js,mu.prop_count));
+  JS_SetPropertyStr(js,ret,"prop_size",number2js(js,mu.prop_size));
+  JS_SetPropertyStr(js,ret,"shape_count",number2js(js,mu.shape_count));
+  JS_SetPropertyStr(js,ret,"shape_size",number2js(js,mu.shape_size));
+  JS_SetPropertyStr(js,ret,"js_func_count",number2js(js,mu.js_func_count));
+  JS_SetPropertyStr(js,ret,"js_func_size",number2js(js,mu.js_func_size));
+  JS_SetPropertyStr(js,ret,"js_func_code_size",number2js(js,mu.js_func_code_size));
+  JS_SetPropertyStr(js,ret,"js_func_pc2line_count",number2js(js,mu.js_func_pc2line_count));
+  JS_SetPropertyStr(js,ret,"js_func_pc2line_size",number2js(js,mu.js_func_pc2line_size));
+  JS_SetPropertyStr(js,ret,"c_func_count",number2js(js,mu.c_func_count));
+  JS_SetPropertyStr(js,ret,"array_count",number2js(js,mu.array_count));
+  JS_SetPropertyStr(js,ret,"fast_array_count",number2js(js,mu.fast_array_count));
+  JS_SetPropertyStr(js,ret,"fast_array_elements",number2js(js,mu.fast_array_elements));
+  JS_SetPropertyStr(js,ret,"binary_object_count",number2js(js,mu.binary_object_count));
+  JS_SetPropertyStr(js,ret,"binary_object_size",number2js(js,mu.binary_object_size));
+)
+
+// Evaluate a string of JavaScript code in the current QuickJS context.
+JSC_SSCALL(os_eval,
+  if (!str2) return JS_ThrowReferenceError(js, "Second argument should be the script.");
+  if (!str) return JS_ThrowReferenceError(js, "First argument should be the name of the script.");
+  ret = JS_Eval(js,str2,strlen(str2),str, 0);
+)
+
+// Compile a string of JavaScript code into a function object.
+JSC_SSCALL(js_compile,
+  if (!str2) return JS_ThrowReferenceError(js, "Second argument should be the script.");
+  if (!str) return JS_ThrowReferenceError(js, "First argument should be the name of the script.");
+  ret = JS_Eval(js, str2, strlen(str2), str, JS_EVAL_FLAG_COMPILE_ONLY | JS_EVAL_FLAG_BACKTRACE_BARRIER);
+)
+
+// Evaluate a function object in the current QuickJS context.
+JSC_CCALL(js_eval_compile,
+  JS_DupValue(js,argv[0]);
+  ret = JS_EvalFunction(js, argv[0]);
+)
+
+// Compile a function object into a bytecode blob.
+JSC_CCALL(js_compile_blob,
+  size_t size;
+  uint8_t *data = JS_WriteObject(js, &size, argv[0], JS_WRITE_OBJ_BYTECODE);
+  if (!data) {
+    return JS_ThrowInternalError(js, "Failed to serialize bytecode");
+  }
+  ret = js_new_blob_stoned_copy(js, data, size);
+  js_free(js, data);
+)
+
+// Compile a bytecode blob into a function object.
+JSC_CCALL(js_compile_unblob,
+  size_t size;
+  void *data = js_get_blob_data(js, &size, argv[0]);
+  if (data == -1) return JS_EXCEPTION;
+  if (!data) return JS_ThrowReferenceError(js, "No data present in blob.");
+  
+  return JS_ReadObject(js, data, size, JS_READ_OBJ_BYTECODE);
+)
+
+// Disassemble a function object into a string.
+JSC_CCALL(js_disassemble,
+  return js_debugger_fn_bytecode(js, argv[0]);
+)
+
+// Return metadata about a given function.
+JSC_CCALL(js_fn_info,
+  return js_debugger_fn_info(js, argv[0]);
+)
+
+static const JSCFunctionListEntry js_js_funcs[] = {
+  MIST_FUNC_DEF(os, calc_mem, 0),
+  MIST_FUNC_DEF(os, mem_limit, 1),
+  MIST_FUNC_DEF(os, gc_threshold, 1),
+  MIST_FUNC_DEF(os, max_stacksize, 1),
+  MIST_FUNC_DEF(os, gc, 0),
+  MIST_FUNC_DEF(os, eval, 2),
+  MIST_FUNC_DEF(js, compile, 2),
+  MIST_FUNC_DEF(js, eval_compile, 1),
+  MIST_FUNC_DEF(js, compile_blob, 1),
+  MIST_FUNC_DEF(js, compile_unblob, 1),
+  MIST_FUNC_DEF(js, disassemble, 1),
+  MIST_FUNC_DEF(js, fn_info, 1),
+};
+
+JSValue js_js_use(JSContext *js) {
+  JSValue mod = JS_NewObject(js);
+  JS_SetPropertyFunctionList(js,mod,js_js_funcs,countof(js_js_funcs));
+  return mod;
+}

docs/.pages

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

docs/actors.md

@@ -0,0 +1,230 @@
+# Actors and Modules
+
+Cell 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:
+
+- Has its own **isolated memory** — actors never share state
+- Runs to completion each **turn** — no preemption
+- Performs its own **garbage collection**
+- Communicates only through **message passing**
+
+This isolation makes concurrent programming safer and more predictable.
+
+## Modules (.cm)
+
+A module is a script that **returns a value**. The returned value is cached and frozen (made stone).
+
+```javascript
+// math_utils.cm
+var math = use('math/radians')
+
+function distance(x1, y1, x2, y2) {
+  var dx = x2 - x1
+  var dy = y2 - y1
+  return math.sqrt(dx * dx + dy * dy)
+}
+
+function midpoint(x1, y1, x2, y2) {
+  return {
+    x: (x1 + x2) / 2,
+    y: (y1 + y2) / 2
+  }
+}
+
+return {
+  distance: distance,
+  midpoint: midpoint
+}
+```
+
+**Key properties:**
+
+- **Must return a value** — it's an error not to
+- **Executed once per actor** — subsequent `use()` calls return the cached value
+- **Return value is stone** — immutable, safe to share
+- Modules can import other modules with `use()`
+
+### Using Modules
+
+```javascript
+var utils = use('math_utils')
+var d = utils.distance(0, 0, 3, 4)  // 5
+```
+
+## Actors (.ce)
+
+An actor is a script that **does not return a value**. It runs as an independent unit of execution.
+
+```javascript
+// worker.ce
+log.console("Worker started")
+
+$on_message = function(msg) {
+  log.console("Received:", msg)
+  // Process message...
+}
+```
+
+**Key properties:**
+
+- **Must not return a value** — it's an error to return
+- Has access to **actor intrinsics** (functions starting with `$`)
+- Runs until explicitly stopped or crashes
+
+## Actor Intrinsics
+
+Actors have access to special functions prefixed with `$`:
+
+### $me
+
+Reference to the current actor.
+
+```javascript
+log.console($me)  // actor reference
+```
+
+### $stop()
+
+Stop the current actor.
+
+```javascript
+$stop()
+```
+
+### $send(actor, message, callback)
+
+Send a message to another actor.
+
+```javascript
+$send(other_actor, {type: "ping", data: 42}, function(reply) {
+  log.console("Got reply:", reply)
+})
+```
+
+Messages are automatically **splatted** — flattened to plain data without prototypes.
+
+### $start(callback, program)
+
+Start a new actor from a script.
+
+```javascript
+$start(function(new_actor) {
+  log.console("Started:", new_actor)
+}, "worker")
+```
+
+### $delay(callback, seconds)
+
+Schedule a callback after a delay.
+
+```javascript
+$delay(function() {
+  log.console("5 seconds later")
+}, 5)
+```
+
+### $clock(callback)
+
+Get called every frame/tick.
+
+```javascript
+$clock(function(dt) {
+  // Called each tick with delta time
+})
+```
+
+### $receiver(callback)
+
+Set up a message receiver.
+
+```javascript
+$receiver(function(message, reply) {
+  // Handle incoming message
+  reply({status: "ok"})
+})
+```
+
+### $portal(callback, port)
+
+Open a network port.
+
+```javascript
+$portal(function(connection) {
+  // Handle new connection
+}, 8080)
+```
+
+### $contact(callback, record)
+
+Connect to a remote address.
+
+```javascript
+$contact(function(connection) {
+  // Connected
+}, {host: "example.com", port: 80})
+```
+
+### $time_limit(requestor, seconds)
+
+Wrap a requestor with a timeout.
+
+```javascript
+$time_limit(my_requestor, 10)  // 10 second timeout
+```
+
+## Module Resolution
+
+When you call `use('name')`, Cell searches:
+
+1. **Current package** — files relative to package root
+2. **Dependencies** — packages declared in `cell.toml`
+3. **Core** — built-in Cell modules
+
+```javascript
+// From within package 'myapp':
+use('utils')           // myapp/utils.cm
+use('helper/math')     // myapp/helper/math.cm
+use('json')            // core json module
+use('otherlib/foo')    // dependency 'otherlib', file foo.cm
+```
+
+Files starting with underscore (`_helper.cm`) are private to the package.
+
+## Example: Simple Actor System
+
+```javascript
+// main.ce - Entry point
+var config = use('config')
+
+log.console("Starting application...")
+
+$start(function(worker) {
+  $send(worker, {task: "process", data: [1, 2, 3]})
+}, "worker")
+
+$delay(function() {
+  log.console("Shutting down")
+  $stop()
+}, 10)
+```
+
+```javascript
+// worker.ce - Worker actor
+$receiver(function(msg, reply) {
+  if (msg.task == "process") {
+    var result = array(msg.data, x => x * 2)
+    reply({result: result})
+  }
+})
+```
+
+```javascript
+// config.cm - Shared configuration
+return {
+  debug: true,
+  timeout: 30
+}
+```

docs/api/Cmdline.md

@@ -1,29 +0,0 @@
-# Cmdline
-#### cmds
-**array**
-
-[
- {
-  "flag": "l",
-  "doc": "Set log level."
- }
-]
-
-#### orders
-**object**
-
-
-
-#### register_cmd(flag, fn, doc)
-
-
-
-#### register_order(order, fn, doc, usage = "")
-
-
-
-#### print_order(fn)
-
-
-
-

docs/api/Color.md

@@ -1,140 +0,0 @@
-# Color
-#### white
-**array**
-
-[
- 1,
- 1,
- 1,
- 1
-]
-
-#### black
-**array**
-
-[
- 0,
- 0,
- 0,
- 1
-]
-
-#### blue
-**array**
-
-[
- 0.32941176470588235,
- 0.43137254901960786,
- 1,
- 1
-]
-
-#### green
-**array**
-
-[
- 0.47058823529411764,
- 1,
- 0.0392156862745098,
- 1
-]
-
-#### yellow
-**array**
-
-[
- 0.984313725490196,
- 1,
- 0.16862745098039217,
- 1
-]
-
-#### red
-**array**
-
-[
- 1,
- 0.1411764705882353,
- 0.0784313725490196,
- 1
-]
-
-#### teal
-**array**
-
-[
- 0.3764705882352941,
- 0.9882352941176471,
- 0.9294117647058824,
- 1
-]
-
-#### gray
-**array**
-
-[
- 0.7098039215686275,
- 0.7098039215686275,
- 0.7098039215686275,
- 1
-]
-
-#### cyan
-**array**
-
-[
- 0,
- 1,
- 1,
- 1
-]
-
-#### purple
-**array**
-
-[
- 0.6352941176470588,
- 0.36470588235294116,
- 0.8901960784313725,
- 1
-]
-
-#### editor
-**object**
-
-
-
-#### tohtml(v)
-
-
-
-#### Arkanoid
-**object**
-
-
-
-#### Gameboy
-**object**
-
-
-
-#### Apple
-**object**
-
-
-
-#### Debug
-**object**
-
-
-
-#### Editor
-**object**
-
-
-
-#### normalize(c)
-
-
-
-

docs/api/ColorMap.md

@@ -1,35 +0,0 @@
-# ColorMap
-#### makemap(map)
-
-
-
-#### Jet
-**object**
-
-[object Object]
-
-#### BlueRed
-**object**
-
-[object Object]
-
-#### Inferno
-**object**
-
-[object Object]
-
-#### Bathymetry
-**object**
-
-[object Object]
-
-#### Viridis
-**object**
-
-[object Object]
-
-#### sample(t, map = this)
-
-Sample a given colormap at the given percentage (0 to 1).
-
-

docs/api/Ease.md

@@ -1,58 +0,0 @@
-# Ease
-#### linear(t)
-
-
-
-#### in(t)
-
-
-
-#### out(t)
-
-
-
-#### inout(t)
-
-
-
-#### quad
-**object**
-
-
-
-#### cubic
-**object**
-
-
-
-#### quart
-**object**
-
-
-
-#### quint
-**object**
-
-
-
-#### expo
-**object**
-
-
-
-#### bounce
-**object**
-
-
-
-#### sine
-**object**
-
-
-
-#### elastic
-**object**
-
-
-
-

docs/api/Event.md

@@ -1,23 +0,0 @@
-# Event
-#### events
-**object**
-
-
-
-#### observe(name, obj, fn)
-
-
-
-#### unobserve(name, obj)
-
-
-
-#### rm_obj(obj)
-
-
-
-#### notify(name, ...args)
-
-
-
-

docs/api/Gizmos.md

@@ -1,6 +0,0 @@
-# Gizmos
-#### pick_gameobject_points(worldpos, gameobject, points)
-
-
-
-

docs/api/Mum.md

@@ -1,173 +0,0 @@
-# Mum
-#### padding
-**array**
-
-[
- 0,
- 0
-]
-
-#### offset
-**array**
-
-[
- 0,
- 0
-]
-
-#### font
-**string**
-
-
-
-#### selectable
-**boolean**
-
-
-
-#### selected
-**boolean**
-
-
-
-#### font_size
-**number**
-
-
-
-#### text_align
-**string**
-
-
-
-#### scale
-**number**
-
-
-
-#### angle
-**number**
-
-
-
-#### anchor
-**array**
-
-[
- 0,
- 1
-]
-
-#### hovered
-**object**
-
-
-
-#### text_shadow
-**object**
-
-
-
-#### text_outline
-**number**
-
-
-
-#### color
-**array**
-
-[
- 1,
- 1,
- 1,
- 1
-]
-
-#### margin
-**array**
-
-[
- 0,
- 0
-]
-
-#### width
-**number**
-
-
-
-#### height
-**number**
-
-
-
-#### max_width
-**number**
-
-
-
-#### max_height
-**number**
-
-
-
-#### image_repeat
-**boolean**
-
-
-
-#### image_repeat_offset
-**array**
-
-[
- 0,
- 0
-]
-
-#### debug
-**boolean**
-
-
-
-#### make(def)
-
-
-
-#### prestart()
-
-
-
-#### start()
-
-
-
-#### extend(def)
-
-
-
-#### text(def)
-
-
-
-#### button(def)
-
-
-
-#### window(def)
-
-
-
-#### image(def)
-
-
-
-#### column(def)
-
-
-
-#### debug_colors
-**object**
-
-
-
-

docs/api/Register.md

@@ -1,56 +0,0 @@
-# Register
-#### registries
-**array**
-
-[
- {},
- {
-  "doc": "Called once per frame."
- },
- {},
- {},
- {},
- {},
- {}
-]
-
-#### add_cb(name)
-
-
-
-#### appupdate
-**object**
-
-
-
-#### update
-**object**
-
-Called once per frame.
-
-#### physupdate
-**object**
-
-
-
-#### gui
-**object**
-
-
-
-#### debug
-**object**
-
-
-
-#### draw
-**object**
-
-
-
-#### screengui
-**object**
-
-
-
-

docs/api/Resources.md

@@ -1,78 +0,0 @@
-# Resources
-#### replpath(str, path)
-
-
-
-#### replstrs(path)
-
-
-
-#### scripts
-**array**
-
-[
- "jsoc",
- "jsc",
- "jso",
- "js"
-]
-
-#### images
-**array**
-
-[
- "png",
- "gif",
- "jpg",
- "jpeg"
-]
-
-#### sounds
-**array**
-
-[
- "wav",
- "flac",
- "mp3",
- "qoa"
-]
-
-#### is_image(path)
-
-
-
-#### find_image(file)
-
-
-
-#### find_sound(file)
-
-
-
-#### find_script(file)
-
-
-
-#### is_sound(path)
-
-
-
-#### is_animation(path)
-
-
-
-#### is_path(str)
-
-
-
-#### texture
-**object**
-
-
-
-#### gif
-**object**
-
-
-
-

docs/api/Spline.md

@@ -1,67 +0,0 @@
-# Spline
-#### sample_angle(type, points, angle)
-
-
-
-#### bezier_loop(cp)
-
-
-
-#### bezier_node_count(cp)
-
-
-
-#### is_bezier(t)
-
-
-
-#### is_catmull(t)
-
-
-
-#### bezier2catmull(b)
-
-
-
-#### catmull2bezier(c)
-
-Given a set of control points C for a camtull-rom type curve, return a set of cubic bezier points to give the same curve.
-
-#### catmull_loop(cp)
-
-
-
-#### catmull_caps(cp)
-
-Given a set of control points cp, return the necessary caps added to the spline.
-
-#### type
-**object**
-
-
-
-#### bezier_tan_partner(points, i)
-
-
-
-#### bezier_cp_mirror(points, i)
-
-
-
-#### bezier_point_handles(points, i)
-
-
-
-#### bezier_nodes(points)
-
-
-
-#### bezier_is_node(points, i)
-
-
-
-#### bezier_is_handle(points, i)
-
-
-
-

docs/api/SpriteAnim.md

@@ -1,27 +0,0 @@
-# SpriteAnim
-Functions to create Primum animations from varying sources.
-#### make(path)
-
-
-
-#### gif(path)
-
-Convert a gif.
-
-#### strip(path, frames, time=0.05)
-
-Given a path and number of frames, converts a horizontal strip animation, where each cell is the same width.
-
-#### aseprite(path)
-
-Given an aseprite json metadata, returns an object of animations defined in the aseprite file.
-
-#### validate(anim)
-
-
-
-#### find(path)
-
-Given a path, find the relevant animation for the file.
-
-

docs/api/Tween.md

@@ -1,15 +0,0 @@
-# Tween
-#### default
-**object**
-
-
-
-#### start(obj, target, tvals, options)
-
-
-
-#### make(obj, target, tvals, options)
-
-
-
-

docs/api/Vector.md

@@ -1,46 +0,0 @@
-# Vector
-#### length(v)
-
-
-
-#### norm(v)
-
-
-
-#### project(a, b)
-
-
-
-#### dot(a, b)
-
-
-
-#### random()
-
-
-
-#### angle_between(a,b)
-
-
-
-#### angle(v)
-
-
-
-#### rotate(v,angle)
-
-
-
-#### equal(v1, v2, tol)
-
-
-
-#### reflect(vec, plane)
-
-
-
-#### reflect_point(vec, point)
-
-
-
-

docs/api/actor.md

@@ -1,34 +0,0 @@
-# actor
-#### spawn(script, config, callback)
-
-Create a new actor, using this actor as the master, initializing it with 'script' and with data (as a JSON or Nota file) from 'config'.
-
-#### rm_pawn(pawn)
-
-
-
-#### timers
-**array**
-
-[]
-
-#### kill()
-
-Remove this actor and all its padawans from existence.
-
-#### interval(fn, seconds)
-
-
-
-#### delay(fn, seconds)
-
-Call 'fn' after 'seconds' with 'this' set to the actor.
-
-#### padawans
-**array**
-
-[
- {}
-]
-
-

docs/api/ai.md

@@ -1,22 +0,0 @@
-# ai
-#### race(list)
-
-
-
-#### sequence(list)
-
-
-
-#### parallel(list)
-
-
-
-#### dofor(secs, fn)
-
-
-
-#### wait(secs = 1)
-
-
-
-

docs/api/allsprites.md

@@ -1,2 +0,0 @@
-# allsprites
-

docs/api/app.md

@@ -1,6 +0,0 @@
-# app
-#### die()
-
-
-
-

docs/api/assert.md

@@ -1 +0,0 @@
-scripts/debug.js:205: [2024-07-03 12:13:11] warn, script: Cannot print the API of something that isn't an object.

docs/api/audio.md

@@ -1,17 +0,0 @@
-# audio
-#### channels
-**number**
-
-
-
-#### buffer_frames
-**number**
-
-
-
-#### samplerate
-**number**
-
-
-
-

docs/api/bbox.md

@@ -1,46 +0,0 @@
-# bbox
-#### overlap(box1, box2)
-
-
-
-#### fromcwh(c, wh)
-
-
-
-#### frompoints(points)
-
-
-
-#### topoints(bb)
-
-
-
-#### tocwh(bb)
-
-
-
-#### towh(bb)
-
-
-
-#### pointin(bb, p)
-
-
-
-#### move(bb, pos)
-
-
-
-#### expand(oldbb, x)
-
-
-
-#### blwh(bl,wh)
-
-Bounding box from (bottom left, width height)
-
-#### fromobjs(objs)
-
-
-
-

docs/api/check_registers.md

@@ -1 +0,0 @@
-scripts/debug.js:205: [2024-07-03 12:13:11] warn, script: Cannot print the API of something that isn't an object.

docs/api/cmd_args.md

@@ -1 +0,0 @@
-scripts/debug.js:205: [2024-07-03 12:13:11] warn, script: Cannot print the API of something that isn't an object.

docs/api/component.md

@@ -1,22 +0,0 @@
-# component
-#### sprite(obj)
-
-
-
-#### edge2d(obj)
-
-
-
-#### circle2d(obj)
-
-
-
-#### poly2d(obj)
-
-
-
-#### seg2d(obj)
-
-
-
-

docs/api/console.md

@@ -1,68 +0,0 @@
-# console
-#### print()
-
-
-
-#### rec()
-
-
-
-#### stdout_lvl
-**number**
-
-
-
-#### transcript
-**string**
-
-
-
-#### say(msg)
-
-Write raw text to console, plus a newline.
-
-#### log(msg)
-
-
-
-#### pprint(msg, lvl = 0)
-
-
-
-#### spam(msg)
-
-
-
-#### debug(msg)
-
-
-
-#### info(msg)
-
-Output info level message.
-
-#### warn(msg)
-
-Output warn level message.
-
-#### error(msg)
-
-Output error level message, and print stacktrace.
-
-#### panic(msg)
-
-
-
-#### stackstr(skip = 0)
-
-
-
-#### stack(skip = 0)
-
-Output a stacktrace to console.
-
-#### trace(skip = 0)
-
-
-
-

docs/api/convert.md

@@ -1,14 +0,0 @@
-# convert
-#### romanize(num)
-
-
-
-#### deromanize(str)
-
-
-
-#### buf2hex(buffer)
-
-
-
-

docs/api/convertYAMLtoJSON.md

@@ -1 +0,0 @@
-scripts/debug.js:205: [2024-07-03 12:13:11] warn, script: Cannot print the API of something that isn't an object.

docs/api/debug.md

@@ -1,50 +0,0 @@
-# debug
-#### fn_break(fn,obj = globalThis)
-
-
-
-#### draw_phys
-**boolean**
-
-
-
-#### draw_bb
-**boolean**
-
-
-
-#### draw_gizmos
-**boolean**
-
-
-
-#### draw_names
-**boolean**
-
-
-
-#### draw()
-
-
-
-#### inputs
-**object**
-
-
-
-#### gif
-**object**
-
-
-
-#### api
-**object**
-
-
-
-#### log
-**object**
-
-
-
-

docs/api/deep_copy.md

@@ -1 +0,0 @@
-scripts/debug.js:205: [2024-07-03 12:13:11] warn, script: Cannot print the API of something that isn't an object.

docs/api/dspsound.md

@@ -1,74 +0,0 @@
-# dspsound
-#### noise()
-
-
-
-#### pink()
-
-
-
-#### red()
-
-
-
-#### pitchshift()
-
-
-
-#### noise_gate()
-
-
-
-#### limiter()
-
-
-
-#### compressor()
-
-
-
-#### crush()
-
-
-
-#### lpf()
-
-
-
-#### hpf()
-
-
-
-#### delay()
-
-
-
-#### fwd_delay()
-
-
-
-#### source()
-
-
-
-#### mix()
-
-
-
-#### master()
-
-
-
-#### plugin_node()
-
-
-
-#### midi()
-
-
-
-#### mod()
-
-
-
-

docs/api/eachobj.md

@@ -1 +0,0 @@
-scripts/debug.js:205: [2024-07-03 12:13:10] warn, script: Cannot print the API of something that isn't an object.

docs/api/ediff.md

@@ -1 +0,0 @@
-scripts/debug.js:205: [2024-07-03 12:13:11] warn, script: Cannot print the API of something that isn't an object.

docs/api/editor.md

@@ -1,33 +0,0 @@
-script:0: [2024-07-03 12:05:54] error, script: ReferenceError :: 'editor' is not defined
-    at <eval> (<input>)
-    at <anonymous> (scripts/debug.js:193)
-    at <anonymous> (scripts/std.js:385)
-    at cmd_args (scripts/std.js:458)
-    at <eval> (C eval)
-
-Initializing cpSpace - Chipmunk v7.0.3 (Debug Enabled)
-Compile with -DNDEBUG defined to disable debug mode and runtime assertion checks
-USE REPORT
-scripts/base.js    5.142 ms
-scripts/render.js    1.197 ms
-scripts/debug.js    521.4 us
-scripts/input.js    1.055 ms
-scripts/std.js    1.175 ms
-scripts/diff.js    194.4 us
-scripts/color.js    856.8 us
-scripts/gui.js    597.1 us
-scripts/tween.js    516.6 us
-scripts/ai.js    128.0 us
-scripts/physics.js    94.48 us
-scripts/geometry.js    189.4 us
-scripts/spline.js    253.1 us
-scripts/components.js    1.761 ms
-scripts/actor.js    185.2 us
-scripts/entity.js    2.157 ms
-scripts/widget.js    444.3 us
-scripts/mum.js    76.63 us
-scripts/editor.js    16.03 ms
-
-ENTITY REPORT
-
-scripts/engine.js:501: [2024-07-03 12:05:56] info, script: QUITTING

docs/api/entity.md

@@ -1,33 +0,0 @@
-script:0: [2024-07-03 12:13:12] error, script: TypeError :: cannot read property 'doc' of undefined
-    at <anonymous> (scripts/debug.js:179)
-    at <anonymous> (scripts/debug.js:223)
-    at <anonymous> (scripts/std.js:385)
-    at cmd_args (scripts/std.js:458)
-    at <eval> (C eval)
-
-Initializing cpSpace - Chipmunk v7.0.3 (Debug Enabled)
-Compile with -DNDEBUG defined to disable debug mode and runtime assertion checks
-USE REPORT
-scripts/base.js    5.200 ms
-scripts/render.js    1.284 ms
-scripts/debug.js    516.9 us
-scripts/input.js    970.4 us
-scripts/std.js    1.103 ms
-scripts/diff.js    230.1 us
-scripts/color.js    1.148 ms
-scripts/gui.js    665.1 us
-scripts/tween.js    498.5 us
-scripts/ai.js    125.5 us
-scripts/physics.js    93.55 us
-scripts/geometry.js    212.2 us
-scripts/spline.js    252.9 us
-scripts/components.js    1.780 ms
-scripts/actor.js    188.5 us
-scripts/entity.js    2.101 ms
-scripts/widget.js    452.2 us
-scripts/mum.js    70.77 us
-scripts/editor.js    17.66 ms
-
-ENTITY REPORT
-
-scripts/engine.js:501: [2024-07-03 12:13:13] info, script: QUITTING

docs/api/entityreport.md

@@ -1,2 +0,0 @@
-# entityreport
-

docs/api/esc.md

@@ -1,12 +0,0 @@
-# esc
-Functions and constants for ANSI escape sequences.
-#### reset
-**string**
-
-
-
-#### color(v)
-
-
-
-

docs/api/find_ext.md

@@ -1 +0,0 @@
-scripts/debug.js:205: [2024-07-03 12:13:10] warn, script: Cannot print the API of something that isn't an object.

docs/api/fps.md

@@ -1 +0,0 @@
-scripts/debug.js:205: [2024-07-03 12:13:11] warn, script: Cannot print the API of something that isn't an object.

docs/api/frame_t.md

@@ -1 +0,0 @@
-scripts/debug.js:205: [2024-07-03 12:13:10] warn, script: Cannot print the API of something that isn't an object.

docs/api/frames.md

@@ -1 +0,0 @@
-scripts/debug.js:205: [2024-07-03 12:13:10] warn, script: Cannot print the API of something that isn't an object.

docs/api/game.md

@@ -1,58 +0,0 @@
-# game
-#### engine_start(s)
-
-
-
-#### startengine
-**number**
-
-
-
-#### timescale
-**number**
-
-
-
-#### all_objects(fn, startobj = world)
-
-
-
-#### find_object(fn, startobj = world)
-
-
-
-#### tags
-**object**
-
-
-
-#### tag_add(tag, obj)
-
-
-
-#### tag_rm(tag, obj)
-
-
-
-#### tag_clear_guid(guid)
-
-
-
-#### objects_with_tag(tag)
-
-
-
-#### texture(path, force = false)
-
-
-
-#### loadurs()
-
-
-
-#### ur
-**object**
-
-
-
-

docs/api/gen_notify.md

@@ -1 +0,0 @@
-scripts/debug.js:205: [2024-07-03 12:13:14] warn, script: Cannot print the API of something that isn't an object.

docs/api/gggstart.md

@@ -1 +0,0 @@
-scripts/debug.js:205: [2024-07-03 12:13:10] warn, script: Cannot print the API of something that isn't an object.

docs/api/gui.md

@@ -1,39 +0,0 @@
-# gui
-#### scissor()
-
-
-
-#### text()
-
-
-
-#### font_set()
-
-
-
-#### scissor_win()
-
-
-
-#### input_lmouse_pressed()
-
-
-
-#### input_s_pressed()
-
-
-
-#### input_w_pressed()
-
-
-
-#### input_enter_pressed()
-
-
-
-#### controls
-**object**
-
-
-
-

docs/api/input.md

@@ -1,75 +0,0 @@
-# input
-#### show_keyboard()
-
-
-
-#### keyboard_shown()
-
-
-
-#### mouse_mode()
-
-
-
-#### mouse_cursor()
-
-
-
-#### cursor_img()
-
-
-
-#### keycodes
-**object**
-
-
-
-#### codekeys
-**object**
-
-
-
-#### mouse
-**object**
-
-[object Object]
-
-#### keyboard
-**object**
-
-
-
-#### state2str(state)
-
-
-
-#### print_pawn_kbm(pawn)
-
-
-
-#### procdown()
-
-
-
-#### print_md_kbm(pawn)
-
-
-
-#### has_bind(pawn, bind)
-
-
-
-#### action
-**object**
-
-
-
-#### tabcomplete(val, list)
-
-
-
-#### do_uncontrol(pawn)
-
-
-
-

docs/api/inputpanel.md

@@ -1,108 +0,0 @@
-# inputpanel
-#### title
-**string**
-
-
-
-#### value
-**string**
-
-
-
-#### on
-**boolean**
-
-
-
-#### pos
-**array**
-
-[
- 20,
- 460
-]
-
-#### wh
-**array**
-
-[
- 100,
- 100
-]
-
-#### anchor
-**array**
-
-[
- 0,
- 1
-]
-
-#### padding
-**array**
-
-[
- 5,
- -15
-]
-
-#### gui()
-
-
-
-#### guibody()
-
-
-
-#### open()
-
-
-
-#### start()
-
-
-
-#### close()
-
-
-
-#### action()
-
-
-
-#### closeonsubmit
-**boolean**
-
-
-
-#### submit()
-
-
-
-#### submit_check()
-
-
-
-#### keycb()
-
-
-
-#### caret
-**number**
-
-
-
-#### reset_value()
-
-
-
-#### input_backspace_pressrep()
-
-
-
-#### inputs
-**object**
-
-
-
-

docs/api/io.md

@@ -1,84 +0,0 @@
-# io
-Functions for filesystem input/output commands.
-#### exists()
-
-Returns true if a file exists.
-
-#### ls()
-
-List contents of the game directory.
-
-#### cp(f1,f2)
-
-Copy file f1 to f2.
-
-#### mv()
-
-Rename file f1 to f2.
-
-#### rm(f)
-
-Remove file f.
-
-#### chdir()
-
-
-
-#### mkdir()
-
-Make dir.
-
-#### chmod(file,mode)
-
-
-
-#### slurp(path)
-
-Returns the contents of given file as a string.
-
-#### slurpbytes(path)
-
-Return the contents of a file as a byte array.
-
-#### slurpwrite(path, c)
-
-Write a given string to a given file.
-
-#### save_qoa()
-
-
-
-#### pack_start()
-
-
-
-#### pack_add()
-
-
-
-#### pack_end()
-
-
-
-#### mod()
-
-
-
-#### dumpfolder
-**string**
-
-
-
-#### mkpath(dir)
-
-
-
-#### extensions(ext)
-
-
-
-#### glob(pat)
-
-Glob files in game directory.
-
-

docs/api/joint.md

@@ -1,42 +0,0 @@
-# joint
-#### pin()
-
-
-
-#### pivot()
-
-
-
-#### gear()
-
-
-
-#### rotary()
-
-
-
-#### damped_rotary()
-
-
-
-#### damped_spring()
-
-
-
-#### groove()
-
-
-
-#### slide()
-
-
-
-#### ratchet()
-
-
-
-#### motor()
-
-
-
-

docs/api/json.md

@@ -1,15 +0,0 @@
-# json
-json implementation.
-#### encode(value, replacer, space = 1)
-
-Encode a value to json.
-
-#### decode(text, reviver)
-
-Decode a json string to a value.
-
-#### readout(obj)
-
-Encode an object fully, including function definitions.
-
-

docs/api/listpanel.md

@@ -1,33 +0,0 @@
-# listpanel
-#### assets
-**array**
-
-[]
-
-#### allassets
-**array**
-
-[]
-
-#### mumlist
-**object**
-
-
-
-#### submit_check()
-
-
-
-#### start()
-
-
-
-#### keycb()
-
-
-
-#### guibody()
-
-
-
-

docs/api/nota.md

@@ -1,10 +0,0 @@
-# nota
-#### encode()
-
-
-
-#### decode()
-
-
-
-

docs/api/notifypanel.md

@@ -1,20 +0,0 @@
-# notifypanel
-#### title
-**string**
-
-
-
-#### msg
-**string**
-
-
-
-#### action()
-
-
-
-#### guibody()
-
-
-
-

docs/api/os.md

@@ -1,149 +0,0 @@
-# os
-#### cwd()
-
-Get the absolute path of the current working directory.
-
-#### env()
-
-Return the value of the environment variable v.
-
-#### sys()
-
-
-
-#### system()
-
-
-
-#### quit()
-
-
-
-#### exit()
-
-
-
-#### reindex_static()
-
-
-
-#### gc()
-
-
-
-#### eval()
-
-
-
-#### make_body()
-
-
-
-#### make_circle2d()
-
-
-
-#### make_poly2d()
-
-
-
-#### make_seg2d()
-
-
-
-#### make_texture()
-
-
-
-#### make_tex_data()
-
-
-
-#### make_font()
-
-
-
-#### make_model()
-
-
-
-#### make_transform()
-
-
-
-#### make_emitter()
-
-
-
-#### make_buffer()
-
-
-
-#### make_line_prim()
-
-
-
-#### make_cylinder()
-
-
-
-#### make_cone()
-
-
-
-#### make_disk()
-
-
-
-#### make_torus()
-
-
-
-#### make_sphere()
-
-
-
-#### make_klein_bottle()
-
-
-
-#### make_trefoil_knot()
-
-
-
-#### make_hemisphere()
-
-
-
-#### make_plane()
-
-
-
-#### make_video()
-
-
-
-#### platform
-**string**
-
-
-
-#### user
-**string**
-
-
-
-#### home
-**string**
-
-
-
-#### prefpath()
-
-
-
-#### openurl(url)
-
-
-
-

docs/api/performance.md

@@ -1,34 +0,0 @@
-# performance
-#### barecall()
-
-
-
-#### unpack_num()
-
-
-
-#### unpack_array()
-
-
-
-#### pack_num()
-
-
-
-#### pack_string()
-
-
-
-#### unpack_string()
-
-
-
-#### unpack_32farr()
-
-
-
-#### call_fn_n()
-
-
-
-

docs/api/physics.md

@@ -1,33 +0,0 @@
-    at <anonymous> (scripts/engine.js:198)
-    at <eval> (C eval)
-    at get iterations (native)
-    at <anonymous> (scripts/debug.js:185)
-    at <anonymous> (scripts/debug.js:223)
-    at <anonymous> (scripts/std.js:385)
-    at cmd_args (scripts/std.js:458)
-    at <eval> (C eval)
-
-USE REPORT
-scripts/base.js    5.646 ms
-scripts/render.js    1.282 ms
-scripts/debug.js    598.0 us
-scripts/input.js    1.005 ms
-scripts/std.js    1.606 ms
-scripts/diff.js    214.2 us
-scripts/color.js    989.1 us
-scripts/gui.js    931.0 us
-scripts/tween.js    631.2 us
-scripts/ai.js    130.4 us
-scripts/physics.js    100.2 us
-scripts/geometry.js    186.1 us
-scripts/spline.js    286.5 us
-scripts/components.js    2.147 ms
-scripts/actor.js    236.0 us
-scripts/entity.js    2.627 ms
-scripts/widget.js    496.0 us
-scripts/mum.js    75.69 us
-scripts/editor.js    18.19 ms
-
-ENTITY REPORT
-
-scripts/engine.js:501: [2024-07-03 12:13:09] info, script: QUITTING

docs/api/physlag.md

@@ -1 +0,0 @@
-scripts/debug.js:195: [2024-07-03 12:13:10] warn, script: Cannot print the API of 'physlag', as it was not found.

docs/api/player.md

@@ -1,68 +0,0 @@
-# player
-#### 0
-**object**
-
-[object Object]
-
-#### 1
-**object**
-
-[object Object]
-
-#### 2
-**object**
-
-[object Object]
-
-#### 3
-**object**
-
-[object Object]
-
-#### players
-**array**
-
-A list of current players.
-
-#### input(fn, ...args)
-
-
-
-#### mouse_input(type, ...args)
-
-
-
-#### char_input(c)
-
-
-
-#### raw_input(cmd, state, ...args)
-
-
-
-#### obj_controlled(obj)
-
-
-
-#### print_pawns()
-
-Print out a list of the current pawn control stack.
-
-#### create()
-
-
-
-#### pawns
-**array**
-
-[]
-
-#### control(pawn)
-
-Control a provided object, if the object has an 'inputs' object.
-
-#### uncontrol(pawn)
-
-Uncontrol a previously controlled object.
-
-

docs/api/poly2d.md

@@ -1,33 +0,0 @@
-    at <anonymous> (scripts/engine.js:198)
-    at <eval> (C eval)
-    at get radius (native)
-    at <anonymous> (scripts/debug.js:185)
-    at <anonymous> (scripts/debug.js:223)
-    at <anonymous> (scripts/std.js:385)
-    at cmd_args (scripts/std.js:458)
-    at <eval> (C eval)
-
-USE REPORT
-scripts/base.js    5.789 ms
-scripts/render.js    2.126 ms
-scripts/debug.js    709.5 us
-scripts/input.js    1.222 ms
-scripts/std.js    1.344 ms
-scripts/diff.js    233.6 us
-scripts/color.js    1.017 ms
-scripts/gui.js    747.8 us
-scripts/tween.js    625.2 us
-scripts/ai.js    173.2 us
-scripts/physics.js    124.2 us
-scripts/geometry.js    221.7 us
-scripts/spline.js    321.3 us
-scripts/components.js    2.191 ms
-scripts/actor.js    230.6 us
-scripts/entity.js    4.996 ms
-scripts/widget.js    607.5 us
-scripts/mum.js    94.18 us
-scripts/editor.js    22.40 ms
-
-ENTITY REPORT
-
-scripts/engine.js:501: [2024-07-03 12:13:09] info, script: QUITTING

docs/api/print.md

@@ -1 +0,0 @@
-scripts/debug.js:205: [2024-07-03 12:13:11] warn, script: Cannot print the API of something that isn't an object.

docs/api/process.md

@@ -1 +0,0 @@
-scripts/debug.js:205: [2024-07-03 12:13:10] warn, script: Cannot print the API of something that isn't an object.

docs/api/profcache.md

@@ -1,136 +0,0 @@
-# profcache
-#### scripts/base.js
-**array**
-
-[
- 5509269
-]
-
-#### scripts/render.js
-**array**
-
-[
- 1371390
-]
-
-#### scripts/debug.js
-**array**
-
-[
- 590951
-]
-
-#### scripts/input.js
-**array**
-
-[
- 1101579
-]
-
-#### scripts/std.js
-**array**
-
-[
- 1516994
-]
-
-#### scripts/diff.js
-**array**
-
-[
- 242594
-]
-
-#### scripts/color.js
-**array**
-
-[
- 1054188
-]
-
-#### scripts/gui.js
-**array**
-
-[
- 706472
-]
-
-#### scripts/tween.js
-**array**
-
-[
- 518110
-]
-
-#### scripts/ai.js
-**array**
-
-[
- 129610
-]
-
-#### scripts/physics.js
-**array**
-
-[
- 168777,
- 32773
-]
-
-#### scripts/geometry.js
-**array**
-
-[
- 216535
-]
-
-#### scripts/spline.js
-**array**
-
-[
- 284937
-]
-
-#### scripts/components.js
-**array**
-
-[
- 1904302
-]
-
-#### scripts/actor.js
-**array**
-
-[
- 196303
-]
-
-#### scripts/entity.js
-**array**
-
-[
- 2293362
-]
-
-#### scripts/widget.js
-**array**
-
-[
- 524872
-]
-
-#### scripts/mum.js
-**array**
-
-[
- 81892
-]
-
-#### scripts/editor.js
-**array**
-
-[
- 17107128
-]
-
-

docs/api/profile.md

@@ -1,34 +0,0 @@
-# profile
-#### now()
-
-
-
-#### best_t(t)
-
-
-
-#### report(start, msg = "[undefined report]")
-
-
-
-#### addreport(cache, line, start)
-
-
-
-#### printreport(cache, name)
-
-
-
-#### cpu(fn, times = 1, q = "unnamed")
-
-
-
-#### ms(t)
-
-
-
-#### secs(t)
-
-
-
-

docs/api/prosperon.md

@@ -1,138 +0,0 @@
-# prosperon
-#### phys2d_step()
-
-
-
-#### window_render()
-
-
-
-#### guid()
-
-
-
-#### version
-**string**
-
-
-
-#### revision
-**string**
-
-
-
-#### semver
-**object**
-
-Functions for semantic versioning numbers. Semantic versioning is given as a triple digit number, as MAJOR.MINOR.PATCH.
-
-#### iconified(icon)
-
-
-
-#### focus(focus)
-
-
-
-#### resize(dimensions)
-
-
-
-#### suspended(sus)
-
-
-
-#### mouseenter()
-
-
-
-#### mouseleave()
-
-
-
-#### touchpress(touches)
-
-
-
-#### touchrelease(touches)
-
-
-
-#### touchmove(touches)
-
-
-
-#### clipboardpaste(str)
-
-
-
-#### quit()
-
-
-
-#### keys
-**array**
-
-[]
-
-#### keydown(key, repeat)
-
-
-
-#### keyup(key)
-
-
-
-#### droppedfile(path)
-
-
-
-#### textinput(c)
-
-
-
-#### mousemove(pos, dx)
-
-
-
-#### mousescroll(dx)
-
-
-
-#### mousedown(b)
-
-
-
-#### mouseup(b)
-
-
-
-#### appupdate(...args)
-
-
-
-#### update(...args)
-
-
-
-#### physupdate(...args)
-
-
-
-#### gui(...args)
-
-
-
-#### debug(...args)
-
-
-
-#### draw(...args)
-
-
-
-#### screengui(...args)
-
-
-
-

docs/api/render.md

@@ -1,189 +0,0 @@
-# render
-Draw shapes in screen space.
-#### flushtext()
-
-
-
-#### camera_screen2world()
-
-
-
-#### viewport()
-
-
-
-#### end_pass()
-
-
-
-#### commit()
-
-
-
-#### glue_pass()
-
-
-
-#### text_size()
-
-
-
-#### text_ssbo()
-
-
-
-#### set_camera()
-
-
-
-#### pipeline()
-
-
-
-#### setuniv3()
-
-
-
-#### setuniv()
-
-
-
-#### spdraw()
-
-
-
-#### setuniproj()
-
-
-
-#### setuniview()
-
-
-
-#### setunivp()
-
-
-
-#### setunim4()
-
-
-
-#### setuniv2()
-
-
-
-#### setuniv4()
-
-
-
-#### setpipeline()
-
-
-
-#### screencolor()
-
-
-
-#### imgui_new()
-
-
-
-#### gfx_gui()
-
-
-
-#### imgui_end()
-
-
-
-#### imgui_init()
-
-
-
-#### poly_prim(verts)
-
-
-
-#### make_shader(shader)
-
-
-
-#### shader_apply_material(shader, material = {})
-
-
-
-#### sg_bind(shader, mesh = {}, material = {}, ssbo)
-
-
-
-#### device
-**object**
-
-Device resolutions given as [x,y,inches diagonal].
-
-#### init()
-
-
-
-#### circle(pos, radius, color)
-
-
-
-#### poly(points, color, transform)
-
-
-
-#### line(points, color = Color.white, thickness = 1, transform)
-
-
-
-#### point(pos,size,color = Color.blue)
-
-
-
-#### cross(pos, size, color = Color.red)
-
-Draw a cross centered at pos, with arm length size.
-
-#### arrow(start, end, color = Color.red, wingspan = 4, wingangle = 10)
-
-Draw an arrow from start to end, with wings of length wingspan at angle wingangle.
-
-#### coordinate(pos, size, color)
-
-
-
-#### boundingbox(bb, color = Color.white)
-
-
-
-#### rectangle(lowerleft, upperright, color)
-
-Draw a rectangle, with its corners at lowerleft and upperright.
-
-#### box(pos, wh, color = Color.white)
-
-
-
-#### window(pos, wh, color)
-
-
-
-#### text(str, pos, size = 1, color = Color.white, wrap = -1, anchor = [0,1], cursor = -1)
-
-
-
-#### image(tex, pos, scale = 1, rotation = 0, color = Color.white, dimensions = [tex.width, tex.height])
-
-
-
-#### fontcache
-**object**
-
-
-
-#### set_font(path, size)
-
-
-
-