initial fork

'

.cell/cell.toml

@@ -0,0 +1,17 @@
+sdl_video = "main"
+[dependencies]
+extramath = "https://gitea.pockle.world/john/extramath@master"
+[system]
+ar_timer = 60
+actor_memory = 0
+net_service = 0.1
+reply_timeout = 60
+actor_max = "10_000"
+stack_max = 0
+[actors]
+[actors.prosperon/sdl_video]
+main = true
+[actors.prosperon/prosperon]
+main = true
+[actors.prosperon]
+main = true

.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"

.github/docker/Dockerfile.alpine

@@ -0,0 +1,30 @@
+# Dockerfile.alpine
+FROM alpine:edge
+
+# Enable the edge and edge/community repositories.
+# If you already have those in your base image, you might not need these echo lines.
+RUN echo "https://dl-cdn.alpinelinux.org/alpine/edge/main" >> /etc/apk/repositories && \
+    echo "https://dl-cdn.alpinelinux.org/alpine/edge/community" >> /etc/apk/repositories
+
+# Update indexes and install packages
+RUN apk update && \
+    apk add --no-cache \
+      build-base \
+      binutils \
+      mold \
+      meson \
+      cmake \
+      ninja \
+      git \
+      pkgconf \
+      ccache \
+      nodejs \
+      npm \
+      zip \
+      alsa-lib-dev \
+      pulseaudio-dev \
+      libudev-zero-dev \
+      wayland-dev \
+      wayland-protocols \
+      mesa-dev \
+      sdl3

.github/docker/Dockerfile.linux

@@ -0,0 +1,32 @@
+FROM ubuntu:plucky
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    python3 python3-pip \
+    libasound2-dev \
+    libpulse-dev \
+    libudev-dev \
+    libwayland-dev \
+    wayland-protocols \
+    libxkbcommon-dev \
+    libx11-dev \
+    libxext-dev \
+    libxrandr-dev \
+    libxcursor-dev \
+    libxi-dev \
+    libxinerama-dev \
+    libxss-dev \
+    libegl1-mesa-dev \
+    libgl1-mesa-dev \
+    cmake \
+    ninja-build \
+    git \
+    build-essential \
+    binutils \
+    mold \
+    pkg-config \
+    meson \
+    ccache \
+    mingw-w64 \
+    wine \
+    npm nodejs zip && \
+    rm -rf /var/lib/apt/lists/*

.github/docker/Dockerfile.mingw

@@ -0,0 +1,15 @@
+FROM ubuntu:plucky
+
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+      mingw-w64 \
+      cmake \
+      ninja-build \
+      git \
+      build-essential \
+      binutils \
+      pkg-config \
+      zip \
+      ccache \
+      npm nodejs && \
+    rm -rf /var/lib/apt/lists/*

.github/workflows/build.yml

@@ -0,0 +1,304 @@
+name: Build and Deploy
+
+on:
+  push:
+    branches: [ "*" ]
+    tags:   [ "v*" ]
+  pull_request:
+
+jobs:
+  # ──────────────────────────────────────────────────────────────
+  #  LINUX BUILD
+  # ──────────────────────────────────────────────────────────────
+  build-linux:
+    runs-on: ubuntu-latest
+    container:
+      image: gitea.pockle.world/john/prosperon/linux:latest
+
+    steps:
+      - name: Check Out Code
+        uses: actions/checkout@v4
+        with: { fetch-depth: 0 }
+
+      - name: Build Prosperon (Linux)
+        run: |
+          meson setup build -Dbuildtype=release -Db_lto=true -Db_lto_mode=thin -Db_ndebug=true
+          meson compile -C build
+
+      - name: Test Prosperon (Linux)
+        env: { TRACY_NO_INVARIANT_CHECK: 1 }
+        run: |
+          meson test --print-errorlogs -C build
+
+      - name: Upload Test Log (Linux)
+        if: ${{ always() }}
+        uses: actions/upload-artifact@v3
+        with:
+          name: testlog-linux
+          path: build/meson-logs/testlog.txt
+
+      - name: Upload Artifact (Linux)
+        if: startsWith(github.ref, 'refs/tags/v')
+        uses: actions/upload-artifact@v3
+        with:
+          name: prosperon-artifacts-linux
+          path: build/prosperon
+          
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+          
+      - name: Log in to Gitea Registry
+        uses: docker/login-action@v3
+        with:
+          registry: gitea.pockle.world
+          username: ${{ secrets.USER_GITEA }}
+          password: ${{ secrets.TOKEN_GITEA }}
+      
+      - name: Determine Docker Tag
+        id: docker_tag
+        run: |
+          if [[ "${{ github.ref }}" =~ ^refs/tags/v.* ]]; then
+            TAG=$(echo "${{ github.ref }}" | sed 's#refs/tags/##')
+            echo "tag=$TAG" >> $GITHUB_OUTPUT
+          else
+            echo "tag=latest" >> $GITHUB_OUTPUT
+          fi
+      
+      - name: Build and Push Docker Image
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          file: ./Dockerfile
+          push: true
+          tags: gitea.pockle.world/john/prosperon:${{ steps.docker_tag.outputs.tag }}
+          platforms: linux/amd64
+
+  # ──────────────────────────────────────────────────────────────
+  #  WINDOWS BUILD (MSYS2 / CLANG64)
+  # ──────────────────────────────────────────────────────────────
+  build-windows:
+    runs-on: win-native
+    strategy:
+      matrix: { msystem: [ CLANG64 ] }
+
+    steps:
+      - name: Check Out Code
+        uses: actions/checkout@v4
+
+      - name: Setup MSYS2
+        uses: msys2/setup-msys2@v2
+        with:
+          msystem: ${{ matrix.msystem }}
+          update: true
+          cache: true
+          install: |
+            git zip gzip tar base-devel
+          pacboy: |
+            meson
+            cmake
+            toolchain
+
+      - name: Build Prosperon (Windows)
+        shell: msys2 {0}
+        run: |
+          meson setup build -Dbuildtype=release -Db_lto=true -Db_lto_mode=thin -Db_ndebug=true -Dtracy:only_localhost=true -Dtracy:no_broadcast=true
+          meson compile -C build
+
+      - name: Test Prosperon (Windows)
+        shell: msys2 {0}
+        env:
+          TRACY_NO_INVARIANT_CHECK: 1
+        run: |
+          meson test --print-errorlogs -C build
+
+      - name: Upload Test Log (Windows)
+        if: ${{ always() }}
+        uses: actions/upload-artifact@v3
+        with:
+          name: testlog-windows
+          path: build/meson-logs/testlog.txt
+
+      - name: Upload Artifact (Windows)
+        if: startsWith(github.ref, 'refs/tags/v')
+        uses: actions/upload-artifact@v3
+        with:
+          name: prosperon-artifacts-windows
+          path: build/prosperon.exe
+
+  # ──────────────────────────────────────────────────────────────
+  #  MACOS BUILD
+  # ──────────────────────────────────────────────────────────────
+  build-macos:
+    runs-on: macos-latest
+
+    steps:
+      - name: Check Out Code
+        uses: actions/checkout@v4
+        with: { fetch-depth: 0 }
+          
+      - name: Build Prosperon (macOS)
+        run: |
+          meson setup build -Dbuildtype=release -Db_lto=true -Db_lto_mode=thin -Db_ndebug=true
+          meson compile -C build
+          
+      - name: Test Prosperon (macOS)
+        run: |
+          meson test --print-errorlogs -C build
+
+      - name: Upload Test Log (macOS)
+        if: ${{ always() }}
+        uses: actions/upload-artifact@v3
+        with:
+          name: testlog-macos
+          path: build/meson-logs/testlog.txt
+
+      - name: Upload Artifact (macOS)
+        if: startsWith(github.ref, 'refs/tags/v')
+        uses: actions/upload-artifact@v3
+        with:
+          name: prosperon-artifacts-macos
+          path: build/prosperon
+
+  # ──────────────────────────────────────────────────────────────
+  #  PACKAGE CROSS-PLATFORM DIST
+  # ──────────────────────────────────────────────────────────────
+  package-dist:
+    needs: [ build-linux, build-windows, build-macos ]
+    if: startsWith(github.ref, 'refs/tags/v')
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Check Out Code
+        uses: actions/checkout@v3
+        with: { fetch-depth: 0 }
+
+      - name: Get Latest Tag
+        id: get_tag
+        run: |
+          TAG=$(git describe --tags --abbrev=0)
+          echo "tag=$TAG" >> $GITHUB_OUTPUT
+
+      - name: Download Linux Artifacts
+        uses: actions/download-artifact@v3
+        with:
+          name: prosperon-artifacts-linux
+          path: linux_artifacts
+
+      - name: Download Windows Artifacts
+        uses: actions/download-artifact@v3
+        with:
+          name: prosperon-artifacts-windows
+          path: windows_artifacts
+
+      - name: Download macOS Artifacts
+        uses: actions/download-artifact@v3
+        with:
+          name: prosperon-artifacts-macos
+          path: mac_artifacts
+
+      - name: Create Dist Folder
+        run: |
+          mkdir -p dist/linux dist/win dist/mac
+          cp README.md        dist/
+          cp license.txt      dist/
+          cp -r examples      dist/
+          cp linux_artifacts/*   dist/linux/
+          cp windows_artifacts/* dist/win/
+          cp mac_artifacts/*     dist/mac/
+
+      - name: Package Final Dist
+        run: |
+          TAG=${{ steps.get_tag.outputs.tag }}
+          zip -r "prosperon-${TAG}.zip" dist
+          echo "Created prosperon-${TAG}.zip"
+
+      - name: Upload Final Dist
+        uses: actions/upload-artifact@v3
+        with:
+          name: "prosperon-${{ steps.get_tag.outputs.tag }}"
+          path: "prosperon-${{ steps.get_tag.outputs.tag }}.zip"
+
+  # ──────────────────────────────────────────────────────────────
+  #  DEPLOY TO ITCH.IO   (single ZIP containing all OSes)
+  # ──────────────────────────────────────────────────────────────
+  deploy-itch:
+    needs: [ package-dist ]
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Check Out Code
+        uses: actions/checkout@v3
+        with: { fetch-depth: 0 }
+
+      - name: Get Latest Tag
+        id: get_tag
+        run: |
+          TAG=$(git describe --tags --abbrev=0)
+          echo "tag=$TAG" >> $GITHUB_OUTPUT
+
+      - name: Download Final Distribution
+        uses: actions/download-artifact@v3
+        with:
+          name: "prosperon-${{ steps.get_tag.outputs.tag }}"
+          path: dist
+
+      - name: Set up Butler
+        uses: jdno/setup-butler@v1
+
+      - name: Push to itch.io
+        run: |
+          butler push "dist/prosperon-${{ steps.get_tag.outputs.tag }}.zip" \
+            ${{ secrets.ITCHIO_USERNAME }}/prosperon:universal \
+            --userversion ${{ steps.get_tag.outputs.tag }}
+        env:
+          BUTLER_API_KEY: ${{ secrets.ITCHIO_API_KEY }}
+
+  # ──────────────────────────────────────────────────────────────
+  #  DEPLOY TO SELF-HOSTED GITEA
+  # ──────────────────────────────────────────────────────────────
+  deploy-gitea:
+    needs: [ package-dist ]
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Check Out Code
+        uses: actions/checkout@v3
+        with: { fetch-depth: 0 }
+
+      - name: Get Latest Tag & Commit Message
+        id: get_tag
+        run: |
+          TAG=$(git describe --tags --abbrev=0)
+          COMMIT_MSG=$(git log -1 --pretty=%B "$TAG")
+          echo "tag=$TAG"        >> $GITHUB_OUTPUT
+          echo "commit_msg=$COMMIT_MSG" >> $GITHUB_OUTPUT
+
+      - name: Download Final Distribution
+        uses: actions/download-artifact@v3
+        with:
+          name: "prosperon-${{ steps.get_tag.outputs.tag }}"
+          path: dist
+
+      - name: Create / Update Gitea Release
+        run: |
+          TAG=${{ steps.get_tag.outputs.tag }}
+          ZIP=dist/prosperon-${TAG}.zip
+          BODY=$(echo "${{ steps.get_tag.outputs.commit_msg }}" | jq -R -s '.')
+          RELEASE=$(curl -s -H "Authorization: token ${{ secrets.TOKEN_GITEA }}" \
+            "https://gitea.pockle.world/api/v1/repos/john/prosperon/releases/tags/$TAG" | jq -r '.id')
+
+          if [ "$RELEASE" = "null" ] || [ -z "$RELEASE" ]; then
+            RELEASE=$(curl -X POST \
+              -H "Authorization: token ${{ secrets.TOKEN_GITEA }}" \
+              -H "Content-Type: application/json" \
+              -d "{\"tag_name\":\"$TAG\",\"target_commitish\":\"${{ github.sha }}\",\"name\":\"$TAG\",\"body\":$BODY,\"draft\":false,\"prerelease\":false}" \
+              "https://gitea.pockle.world/api/v1/repos/john/prosperon/releases" | jq -r '.id')
+          fi
+
+          curl -X POST \
+            -H "Authorization: token ${{ secrets.TOKEN_GITEA }}" \
+            -H "Content-Type: application/octet-stream" \
+            --data-binary @"$ZIP" \
+            "https://gitea.pockle.world/api/v1/repos/john/prosperon/releases/$RELEASE/assets?name=prosperon-${TAG}.zip"
+        env:
+          TOKEN_GITEA: ${{ secrets.TOKEN_GITEA }}

.gitignore

@@ -6,25 +6,18 @@ 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/
+steam/
+subprojects/*/
+build_dbg/
+modules/

AGENTS.md

@@ -0,0 +1,26 @@
+# AGENTS.md
+
+## Project Overview
+This is a game engine developed using a QuickJS fork as its scripting language. It is an actor based system, based on Douglas Crockford's Misty. It is a Meson compiled project with a number of dependencies.
+
+## File Structure
+- `source/`: Contains the C source code
+- `scripts/`: Contains script code that is loaded on executable start, and modules
+- `shaders/`: Contains shaders that ship with the engine (for shader based backends)
+- `benchmarks/`: Benchmark programs for testing speed
+- `tests/`: Unit tests
+- `examples/`: Contains full game examples
+
+## Coding Practices
+- Use K&R style C
+- Javascript style prefers objects and prototypical inheritence over ES6 classes, liberal use of closures, and var everywhere
+
+## Instructions
+- When generating code, adhere to the coding practices outlined above.
+- When adding new features, ensure they align with the project's goals.
+- When fixing bugs, review the code carefully before making changes.
+- When writing unit tests, cover all important scenarios.
+
+## Compiling, running, and testing
+- To compile the code, run "make", which generates a prosperon executable in build_dbg/, and copy it into the root folder
+- Run a test by giving it as its command: so ./prosperon tests/overling.js would run the test overling.js, ./prosperon tests/nota.js runs the nota benchmark

CLAUDE.md

@@ -0,0 +1,405 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Build Commands
+
+### Build variants
+- `make` - Make and install debug version. Usually all that's needed.
+- `make fast` - Build optimized version  
+- `make release` - Build release version with LTO and optimizations
+- `make small` - Build minimal size version
+- `make web` - Build for web/emscripten platform
+- `make crosswin` - Cross-compile for Windows using mingw32
+
+### Testing
+After install with 'make', just run 'cell' and point it at the actor you want to launch. "cell tests/toml" runs the actor "tests/toml.js"
+
+## Scripting language
+This is called "cell", but it is is a variant of javascript and extremely similar.
+
+### Common development commands
+- `meson setup build_<variant>` - Configure build directory
+- `meson compile -C build_<variant>` - Compile in build directory
+- `./build_dbg/prosperon examples/<example>` - Run example from build directory
+- Copy prosperon to game directory and run: `cp build_dbg/prosperon <game-dir>/ && cd <game-dir> && ./prosperon`
+
+## Architecture Overview
+
+Prosperon is an actor-based game engine inspired by Douglas Crockford's Misty system. Key architectural principles:
+
+### Actor Model
+- Each actor runs on its own thread
+- Communication only through message passing (no shared JavaScript objects)
+- Hierarchical actor system with spawning/killing
+- Actor lifecycle: awake, update, draw, garbage collection
+
+### JavaScript Style Guide
+- Use `use()` function for imports (Misty-style, not ES6 import/export)
+- Prefer closures and javascript objects and prototypes over ES6 style classes
+- Follow existing JavaScript patterns in the codebase
+- Functions as first-class citizens
+- Do not use const or let; only var
+
+### Core Systems
+1. **Actor System** (scripts/core/engine.js)
+   - Message passing via `send()`, `$_.receive()`
+   - Actor spawning/management
+   - Register-based component system (update, draw, gui, etc.)
+   
+2. **Module System**
+   - `use()` function for loading modules
+   - Module paths: `scripts/modules/`, `scripts/modules/ext/`
+   - Custom QuickJS build with embedded C modules
+
+3. **Build System**
+   - Meson build configuration (Makefile is convenience wrapper)
+   - Multiple platform targets (Windows, macOS, Linux, Web)
+   - Custom QuickJS build in `subprojects/`
+   - Uses SDL3 for cross-platform support
+
+### Engine Entry Points
+- `source/prosperon.c` - Main C entry point
+- `scripts/core/engine.js` - JavaScript engine initialization for system
+- `scripts/core/base.js` has modifications to this Javascript runtime (for example, additions to the base Array, String, etc)
+
+### Subprojects
+- C code has many subprojects, who's source and sometimes documentation can be found in subprojects. subprojects/quickjs/doc has documentation for quickjs
+
+### Resource System
+- Scripts are bundled into `core.zip` during build
+- Runtime module loading via PhysFS
+- Resource paths checked in order: `/`, `scripts/modules/`, `scripts/modules/ext/`
+
+### Notable Dependencies
+- QuickJS (custom build) - JavaScript runtime
+- SDL3 - Platform abstraction
+- Chipmunk2D - Physics
+- ENet - Networking  
+- Soloud - Audio
+- Tracy - Profiling (when enabled)
+
+## Development Tips
+
+### Running Games
+```bash
+# Build first
+make debug
+
+# Run example from build directory
+./build_dbg/prosperon examples/chess
+
+# Or copy to game directory
+cp build_dbg/prosperon examples/chess/
+cd examples/chess
+./prosperon
+```
+
+### Documentation
+- Documentation is found in docs
+- Documentation for the JS modules loaded with 'use' is docs/api/modules
+- .md files directly in docs gives a high level overview
+- docs/dull is what this specific Javascript system is (including alterations from quickjs/es6)
+
+### Shader Development
+- Shaders are in `shaders/` directory as HLSL
+- Compile script: `shaders/compile.sh`
+- Outputs to platform-specific formats: `dxil/`, `msl/`, `spv/`
+
+### Example Games
+Located in `examples/` directory:
+- `chess` - Chess implementation (has its own Makefile)
+- `pong` - Classic pong game
+- `snake` - Snake game
+- `tetris` - Tetris clone
+- `bunnymark` - Performance test
+
+### Testing
+```bash
+# Run all tests
+meson test -C build_dbg
+
+# Run specific test  
+./build_dbg/prosperon tests/spawn_actor.js
+```
+
+### Debugging
+- Use debug build: `make debug`
+- Tracy profiler support when enabled
+- Console logging available via `log.console()`, `log.error()`, etc.
+- Log files written to `.prosperon/log.txt`
+
+# Project Structure Notes
+
+## Core JavaScript Modules
+
+- JavaScript modules are defined using the MISTUSE macro in jsffi.c
+- The `js_os_funcs`, `js_io_funcs`, etc. arrays define the available functions for each module
+- New functions are added with MIST_FUNC_DEF(module, function, args_count)
+
+## File I/O
+
+- `io.slurp(path)` - Reads a file as text
+- `io.slurpbytes(path)` - Reads a file as an ArrayBuffer
+- `io.slurpwrite(path, data)` - Writes data (string or ArrayBuffer) to a file
+- `io.exists(path)` - Checks if a file exists
+
+## Script Loading
+
+- The `use(path)` function in engine.js loads JavaScript modules
+- Script loading happens in prosperon.c and the engine.js script
+- jsffi.c contains the C hooks for the QuickJS JavaScript engine
+- Added functionality for bytecode compilation and loading:
+  - `os.compile_bytecode(source, filename)` - Compiles JS to bytecode, returns ArrayBuffer
+  - `os.eval_bytecode(bytecode)` - Evaluates bytecode from an ArrayBuffer
+  - `compile(scriptPath)` - Compiles a JS file to a .jso bytecode file
+  - Modified `use()` to check for .jso files before loading .js files
+
+## QuickJS Bytecode API
+
+- `JS_Eval` with JS_EVAL_FLAG_COMPILE_ONLY - Compiles without executing
+- `JS_WriteObject` with JS_WRITE_OBJ_BYTECODE - Serializes to bytecode
+- `JS_ReadObject` with JS_READ_OBJ_BYTECODE - Deserializes and loads bytecode
+- Bytecode files use .jso extension alongside .js files
+
+## Available JavaScript APIs
+
+### Core APIs
+- `actor` - Base prototype for all actor objects
+- `$_` - Special global for actor messaging
+- `prosperon` - Global engine interface
+- `console` - Logging and debugging interface
+
+### Framework APIs
+- `moth` - Higher-level game framework that simplifies Prosperon usage
+  - Handles window creation, game loop, and event dispatching
+  - Provides simple configuration via config.js 
+  - Auto-initializes systems like rendering and input
+  - Manages camera, resolution, and FPS automatically
+
+### Rendering
+- `draw2d` - 2D drawing primitives
+- `render` - Low-level rendering operations
+- `graphics` - Higher-level graphics utilities
+- `camera` - Camera controls and transformations
+- `sprite` - Sprite rendering and management
+
+### Physics and Math
+- `math` - Mathematical utilities
+- `geometry` - Geometric calculations and shapes
+- `transform` - Object transformations
+
+### Input and Events
+- `input` - Mouse, keyboard, and touch handling
+- `event` - Event management system
+
+### Networking
+- `enet` - Networking through ENet library
+- `http` - HTTP client capabilities
+
+### Audio
+- `sound` - Audio playback using SoLoud
+
+### Utility Modules
+- `time` - Time management and delays
+  - **Must be imported with `use('time')`**
+  - No `time.now()` function - use:
+    - `time.number()` - Number representation of current time
+    - `time.record()` - Struct representation of current time  
+    - `time.text()` - Text representation of current time
+- `io` - File I/O operations
+- `json` - JSON parsing and serialization
+- `util` - General utilities
+- `color` - Color manipulation
+- `miniz` - Compression utilities
+- `nota` - Structured data format
+- `wota` - Serialization format
+- `qr` - QR code generation/reading
+- `tween` - Animation tweening
+- `spline` - Spline calculations
+- `imgui` - Immediate mode GUI
+
+## Game Development Patterns
+
+### Project Structure
+- Game config is typically in `config.js`
+- Main entry point is `main.js`
+- Resource loading through `resources.js`
+
+### Actor Pattern Usage
+- Create actors with `actor.spawn(script, config)`
+- Start actors with `$_.start(callback, script)` - the system automatically sends a greeting, callback receives {type: 'greet', actor: actor_ref}
+  - No need to manually send greetings - `$_.start` handles this automatically
+- Manage actor hierarchy with overlings and underlings
+- Schedule actor tasks with `$_.delay()` method
+- Clean up with `kill()` and `garbage()`
+
+### Actor Messaging with Callbacks
+When sending a message with a callback, respond by sending to the message itself:
+```javascript
+// Sender side:
+send(actor, {type: 'status'}, response => {
+  log.console(response); // Handle the response
+});
+
+// Receiver side:
+$_.receiver(msg => {
+  if (msg.type === 'status') {
+    send(msg, {status: 'ok'}); // Send response to the message itself
+  }
+});
+```
+
+**Critical Rules for Message Callbacks**: 
+- **A message can only be used ONCE as a send target** - after sending a response to a message, it cannot be used again
+- If you need to send multiple updates (like progress), only the download request message should be used for the final response
+- Status requests should each get their own individual response
+- Actor objects and message headers are completely opaque - never try to access internal properties
+- Never access `msg.__HEADER__` or similar - the actor system handles routing internally
+- Use `$_.delay()` to schedule work and avoid blocking the message receiver
+
+### Game Loop Registration
+- Register functions like `update`, `draw`, `gui`, etc.
+- Set function.layer property to control execution order
+- Use `Register` system to manage callbacks
+
+### Program vs Module Pattern
+- Programs are actor scripts that don't return values, they execute top-to-bottom
+- Modules are files that return single values (usually objects) that get frozen
+- Programs can spawn other programs as underlings
+- Programs have lifecycle hooks: awake, update, draw, garbage, etc.
+
+## Technical Capabilities
+
+### Graphics Pipeline
+- Supports multiple render backends (Direct3D, Metal, Vulkan via SDL3)
+- Custom shader system with cross-platform compilation
+- Sprite batching for efficient 2D rendering
+- Camera systems for both 2D and 3D
+
+### Asset Support
+- Images: PNG, JPG, QOI, etc.
+- Audio: Various formats through SoLoud
+- Models: Basic 3D model support
+- Custom formats: Aseprite animations, etc.
+
+### Developer Tools
+- Built-in documentation system with `cell.DOC`
+- Tracy profiler integration for performance monitoring
+- Imgui debugging tools
+- Console logging with various severity levels
+
+## Misty Networking Patterns
+
+Prosperon implements the Misty actor networking model. Understanding these patterns is critical for building distributed applications.
+
+### Portal Reply Pattern
+Portals must reply with an actor object, not application data:
+```javascript
+// CORRECT: Portal replies with actor
+$_.portal(e => {
+  send(e, $_);  // Reply with server actor
+}, 5678);
+
+// WRONG: Portal sends application data  
+$_.portal(e => {
+  send(e, {type: 'game_start'});  // This breaks the pattern
+}, 5678);
+```
+
+### Two-Phase Connection Protocol
+Proper Misty networking follows a two-phase pattern:
+
+**Phase 1: Actor Connection**
+- Client contacts portal using `$_.contact()`
+- Portal replies with an actor object
+- This establishes the communication channel
+
+**Phase 2: Application Communication**
+- Client sends application messages to the received actor
+- Normal bidirectional messaging begins
+- Application logic handles game/service initialization
+
+### Message Handling Best Practices
+Messages should be treated as opaque objects with your application data:
+
+```javascript
+// CORRECT: Store actor references separately
+var players = {};
+$_.receiver(msg => {
+  if (msg.type === 'join_game' && msg.player_id) {
+    // Store the message for later response
+    players[msg.player_id] = msg;
+    // Later, respond to the stored message
+    send(players[msg.player_id], {type: 'game_start'});
+  }
+});
+
+// WRONG: Trying to access internal message properties
+$_.receiver(msg => {
+  var sender = msg.__HEADER__.replycc;  // Never do this!
+});
+```
+
+### Return ID Lifecycle
+- Each reply callback gets a unique return ID
+- Return IDs are consumed once and then deleted
+- Reusing message objects with return headers causes "Could not find return function" errors
+- Always create clean actor references for ongoing communication
+
+### Actor Object Transparency
+Actor objects must be completely opaque black boxes that work identically regardless of transport:
+
+```javascript
+// Actor objects work transparently for:
+// - Same-process communication (fastest - uses mailbox)
+// - Inter-process communication (uses mailbox) 
+// - Network communication (uses ENet)
+
+// The actor shouldn't know or care about the transport mechanism
+send(opponent, {type: 'move', from: [0,0], to: [1,1]});
+```
+
+**Key Implementation Details:**
+- `actor_send()` in `scripts/core/engine.js` handles routing based on available actor data
+- Actor objects sent in message data automatically get address/port populated when received over network
+- Three communication pathways: `os.mailbox_exist()` check → mailbox send → network send
+- Actor objects must contain all necessary routing information for transparent messaging
+
+### Common Networking Bugs
+1. **Portal sending application data**: Portal should only establish actor connections
+2. **Return ID collision**: Reusing messages with return headers for multiple sends
+3. **Mixed phases**: Trying to do application logic during connection establishment
+4. **Header pollution**: Using received message objects as actor references
+5. **Missing actor address info**: Actor objects in message data need network address population (fixed in engine.js:746-766)
+
+### Example: Correct Chess Networking
+```javascript
+// Server: Portal setup
+$_.portal(e => {
+  send(e, $_);  // Just reply with actor
+}, 5678);
+
+// Client: Two-phase connection
+$_.contact((actor, reason) => {
+  if (actor) {
+    opponent = actor;
+    send(opponent, {type: 'join_game'});  // Phase 2: app messaging
+  }
+}, {address: "localhost", port: 5678});
+
+// Server: Handle application messages
+$_.receiver(e => {
+  if (e.type === 'join_game') {
+    opponent = e.__HEADER__.replycc;
+    send(opponent, {type: 'game_start', your_color: 'black'});
+  }
+});
+```
+
+## Memory Management
+
+- When working with a conversational AI system like Claude, it's important to maintain a clean and focused memory
+- Regularly review and update memories to ensure they remain relevant and helpful
+- Delete or modify memories that are no longer accurate or useful
+- Prioritize information that can genuinely assist in future interactions

Dockerfile

@@ -0,0 +1,54 @@
+# Builder stage
+FROM ubuntu:plucky AS builder
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    python3 python3-pip \
+    libasound2-dev \
+    libpulse-dev \
+    libudev-dev \
+    libwayland-dev \
+    wayland-protocols \
+    libxkbcommon-dev \
+    libx11-dev \
+    libxext-dev \
+    libxrandr-dev \
+    libxcursor-dev \
+    libxi-dev \
+    libxinerama-dev \
+    libxss-dev \
+    libegl1-mesa-dev \
+    libgl1-mesa-dev \
+    cmake \
+    ninja-build \
+    git \
+    build-essential \
+    binutils \
+    pkg-config \
+    meson \
+    zip && \
+    rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+RUN git clone https://gitea.pockle.world/john/prosperon.git
+WORKDIR /app/prosperon
+RUN git checkout jsffi_refactor
+RUN meson setup build -Dbuildtype=release -Db_lto=true -Db_lto_mode=thin -Db_ndebug=true
+RUN meson compile -C build
+
+# Runtime stage
+FROM ubuntu:latest
+
+# Install minimal runtime dependencies (e.g., for dynamically linked libraries)
+RUN apt-get update && apt-get install -y libstdc++6 && rm -rf /var/lib/apt/lists/*
+
+# Copy the compiled prosperon binary from the build stage
+COPY --from=builder /app/prosperon/build/prosperon /usr/local/bin/prosperon
+
+# Create an entrypoint script
+RUN echo '#!/bin/bash' > /entrypoint.sh && \
+    echo '/usr/local/bin/prosperon "$@" &' >> /entrypoint.sh && \
+    echo 'tail -f /dev/null' >> /entrypoint.sh && \
+    chmod +x /entrypoint.sh
+
+WORKDIR /workdir
+ENTRYPOINT ["/entrypoint.sh"]

Makefile

@@ -1,18 +1,22 @@
 debug: FORCE
-	meson setup build_dbg -Dbuildtype=debugoptimized
-	meson compile -C build_dbg
+	meson setup build_dbg -Dbuildtype=debug
+	meson install --only-changed -C build_dbg
+	
+fast: FORCE
+	meson setup build_fast
+	meson install -C build_fast
 
 release: FORCE
-	meson setup -Dbuildtype=release -Db_lto=true -Db_ndebug=true -Db_pgo=use build_release
-	meson compile -C build_release
+	meson setup -Dbuildtype=release -Db_lto=true -Db_lto_mode=thin -Db_ndebug=true build_release
+	meson install -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
+	meson install -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
+	meson setup -Dbuildtype=minsize -Db_lto=true -Db_ndebug=true build_small
+	meson install -C build_small
 
 web: FORCE
 	meson setup -Deditor=false -Dbuildtype=minsize -Db_lto=true -Db_ndebug=true --cross-file emscripten.cross build_web

README.md

@@ -1,13 +1,7 @@
-![alt text](doc/prosperon_orb_horizontal.gif)
+Thank you for using Prosperon!
 
-The easily moddable, programming minded, 2D-first game engine. The aim is to make the fastest way to make games.
+Provided are prosperon builds for all available platforms. Simply run prosperon for your platform in a game folder to play!
 
-Using ...
-* Sokol for rendering
-* Chipmunk2D for physics
-* imgui for easy editor UI
-* Clay for game UI
+To get started, take a dive into the provided example games in the examples folder. You can either copy the prosperon executable into an example directory and run it there, or run `prosperon path/to/example` from the project root.
 
-Includes an implementation for Nota, and Kim.
-
-*Prosperon is useful, but is a work in progress. Breaking changes are frequent.*
+You can take a look through the docs folder for the prosperon manual to learn all about it. The manual is available on the web at [docs.prosperon.dev](https://docs.prosperon.dev).

benchmarks/nota.ce

@@ -0,0 +1,76 @@
+var nota = use('nota')
+var os = use('os')
+var io = use('io')
+
+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) {
+    const avg = arr.reduce((a, b) => a + b) / arr.length;
+    const min = Math.min(...arr);
+    const max = Math.max(...arr);
+    return { avg, min, max };
+}
+
+// Pretty print results
+log.console("\n=== Performance Test Results (100 iterations) ===");
+log.console("\nJSON Decoding (ms):");
+const 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):");
+const 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):");
+const 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):");
+const 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/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.
+const 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,185 @@
+//
+// benchmark_wota_nota_json.js
+//
+// Usage in QuickJS:
+//    qjs benchmark_wota_nota_json.js
+//
+// 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');
+//
+
+////////////////////////////////////////////////////////////////////////////////
+// 1. Setup "libraries" array to easily switch among Wota, Nota, and JSON
+////////////////////////////////////////////////////////////////////////////////
+
+const 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 }
+////////////////////////////////////////////////////////////////////////////////
+
+const benchmarks = [
+  {
+    name: "Empty object",
+    data: [{}, {}, {}, {}],
+    iterations: 10000
+  },
+  {
+    name: "Small Integers",
+    data: [0, 42, -1, 2023],
+    iterations: 100000
+  },
+  {
+    name: "Floating point",
+    data: [0.1, 1e-50, 3.14159265359],
+    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 integers)",
+    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 across all benchmarks, for each library.
+////////////////////////////////////////////////////////////////////////////////
+
+log.console("Benchmark: Wota vs Nota vs JSON");
+log.console("================================\n");
+
+for (let bench of benchmarks) {
+  log.console(`SCENARIO: ${bench.name}`);
+  log.console(`  Data length: ${bench.data.length} | Iterations: ${bench.iterations}\n`);
+  
+  for (let lib of libraries) {
+    let { encodeTime, decodeTime, totalSize } = runBenchmarkForLibrary(lib, bench);
+    
+    // We'll compute total operations = bench.iterations * bench.data.length
+    let totalOps = bench.iterations * bench.data.length;
+    let encOpsPerSec = (totalOps / encodeTime).toFixed(1);
+    let decOpsPerSec = (totalOps / decodeTime).toFixed(1);
+    
+    log.console(`  ${lib.name}:`);
+    log.console(`    Encode time: ${encodeTime.toFixed(3)}s  => ${encOpsPerSec} encodes/sec [${(encodeTime/bench.iterations)*1000000000} ns/try]`);
+    log.console(`    Decode time: ${decodeTime.toFixed(3)}s  => ${decOpsPerSec} decodes/sec [${(decodeTime/bench.iterations)*1000000000}/try]`);
+    log.console(`    Total size:  ${totalSize} bytes (or code units for JSON)`);
+    log.console("");
+  }
+  log.console("---------------------------------------------------------\n");
+}
+
+log.console("Benchmark complete.\n");
+
+os.exit()

docs/.pages

@@ -0,0 +1,12 @@
+nav:
+  - index.md
+  - tutorial.md
+  - actors.md
+  - rendering.md
+  - resources.md
+  - input.md
+  - exporting.md
+  - ...
+  - Appendix A - dull: dull
+  - Appendix B - api: api
+  

docs/actors.md

@@ -0,0 +1,77 @@
+# Programs: Programs and Modules
+
+Prosperon organizes your code into two broad categories: **modules** and **programs**. Modules are used to extend programs with new functionality, while programs are used to spawn actors.
+
+## Modules
+
+A **module** is any file that returns a single value. This return value is commonly an object, but it can be any data type (string, number, function, etc.). Once a module returns its value, Prosperon **freezes** that value, preventing accidental modification. The module is then cached so that subsequent imports of the same module don’t re-run the file—they reuse the cached result.
+
+### Importing a Module
+
+Use the built-in `use` function to import a module by file path (or by name if resolvable via Prosperon’s path settings). For example:
+
+```
+var myModule = use('scripts/modules/myModule')
+```
+
+`use('module')` returns the **exact** same object if called multiple times, since modules are cached and not re-run.
+
+Dull based modules are resolved by searching for them from the `prosperon.PATH` array. Engine modules are stored under `scripts/modules`, which is already added to the PATH for you.
+
+Prosperon can also load C based modules. If two modules have the same path resolution, the C based library will be imported.
+
+## Programs
+
+An **program** is a file that **does not** return a value. Instead, the file’s contents run top to bottom as soon as the program is spawned. Programs are your game’s “live” scripts: each program can hold its own state and logic, spawn sub-programs, schedule timed tasks, and eventually **kill** itself (or be killed) when it’s done.
+
+### Program Intrinsic Functions
+
+Certain functions are intrinsic to the program and cannot be overridden. They’re assigned to each new program instance at spawn time:
+
+1. **`spawn(script, config, callback)`**  
+   Creates (spawns) a new program from another script file.  
+   - **`script`**: Path to the program script (a file containing statements, not returning anything).  
+   - **`config`**: Optional object of extra properties to assign to the new program.  
+   - **`callback(underling, info)`**: Optional function invoked right after the program is instantiated but before it fully initializes.
+
+   The newly spawned program:
+   - Receives a reference to its parent (the `overling`) and can store child programs (the `underlings`).
+   - Automatically calls `awake()` if that function is defined, after basic setup completes.
+   - Registers any recognized event handlers (like `update`, `draw`, etc.) if they exist.
+
+2. **`kill()`**  
+   Destroys the program, all of its timers, and recursively kills any underling (child) programs. If the program has a parent, it is removed from the parent’s `underlings` set.  
+
+3. **`delay(fn, seconds)`**  
+   Runs the given function `fn` after `seconds`. This is implemented under the hood with a timer that automatically clears itself once it fires.  
+   - **Example**:  
+     ```js
+     this.delay(_ => {
+       log.console("3 seconds later!")
+     }, 3)
+     ```
+
+4. **`clear()`**  
+   Recursively kills all child programs, clearing your immediate `underlings` set. This is not called automatically. You can use it to manually clean up all children without necessarily killing the program itself.
+
+### The program Lifecycle
+
+Specific hooks can be set on a program when it is initialized.
+
+- **Awake**: If the new program defines `awake()`, Prosperon calls it after the script finishes its top-level execution. This is a common place to do initialization.
+- **Garbage**: When the program is killed, if it has a `garbage()` function, Prosperon calls it before final removal.  
+- **Then**: If the program has a `then()` function, Prosperon calls it at the very end of the kill process, allowing any final statements after your `garbage()` logic completes.
+- **Registration**: In addition, if the object has **any** function named the same thing as a hook created with **prosperon.on**, that function will be registered with it after initialization.
+
+### Overlings and Underlings
+
+Programs have access to its creator and other programs created underneath it, termed its overling and underlings.
+
+- **`this.overling`** is the parent program that spawned the current one.
+- **`this.underlings`** is a set of child programs that the current program has spawned.  
+
+Killing a parent automatically kills all of its underlings, which in turn can kill their own underlings, and so on.
+
+## Program Documentation
+
+Prosperon includes a module called `doc.js` which helps generate documentation for your modules and programs. Any function and value can be assigned a docstring, and prosperon will then be able to generate documentation for it via doc.js. Look under the module API for more info.

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 +1,11 @@
 # 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'.
+### toString() <sub>function</sub>
 
-#### rm_pawn(pawn)
+### spawn(script, config, callback) <sub>function</sub>
 
+### clear() <sub>function</sub>
 
+### kill() <sub>function</sub>
 
-#### 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**
-
-[
- {}
-]
-
-
+### delay(fn, seconds) <sub>function</sub>

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 +1,37 @@
 # console
-#### print()
 
+The console object provides various logging, debugging, and output methods.
 
+### print() <sub>function</sub>
 
-#### rec()
+### spam(msg) <sub>function</sub>
 
+Output a spam-level message for very verbose logging.
 
+### debug(msg) <sub>function</sub>
 
-#### stdout_lvl
-**number**
+Output a debug-level message.
 
-
-
-#### transcript
-**string**
-
-
-
-#### say(msg)
-
-Write raw text to console, plus a newline.
-
-#### log(msg)
-
-
-
-#### pprint(msg, lvl = 0)
-
-
-
-#### spam(msg)
-
-
-
-#### debug(msg)
-
-
-
-#### info(msg)
+### info(msg) <sub>function</sub>
 
 Output info level message.
 
-#### warn(msg)
+### warn(msg) <sub>function</sub>
 
 Output warn level message.
 
-#### error(msg)
+### log(msg) <sub>function</sub>
+
+Output directly to in game console.
+
+### error(e) <sub>function</sub>
 
 Output error level message, and print stacktrace.
 
-#### panic(msg)
-
-
-
-#### stackstr(skip = 0)
-
-
-
-#### stack(skip = 0)
-
-Output a stacktrace to console.
-
-#### trace(skip = 0)
-
+### panic(e) <sub>function</sub>
 
+Output a panic-level message and exit the program.
 
+### assert(op, str = `assertion failed [value '${op}']`) <sub>function</sub>
 
+If the condition is false, print an error and panic.

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

@@ -0,0 +1,5 @@
+# Appendix B - api
+
+This is a complete list of accessible functions and parameters that are built into Prosperon. For the most part, developers will concern themselves with the modules, all of which can be imported with `use`.
+
+Types document particular javascript objects with a specific object in their prototype chain, which can allow access to an underlying C data structure. A lot of these are used only internally by Prosperon, but brave developers can pick around in the module internals to see how they're used and do their own thing if they want!

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/modules/actor.md

@@ -0,0 +1,87 @@
+# actor
+
+
+A set of utilities for iterating over a hierarchy of actor-like objects, as well
+as managing tag-based lookups. Objects are assumed to have a "objects" property,
+pointing to children or sub-objects, forming a tree.
+
+
+### all_objects(fn, startobj) <sub>function</sub>
+
+
+Iterate over each object (and its sub-objects) in the hierarchy, calling fn for each one.
+
+
+**fn**: A callback function that receives each object. If it returns a truthy value, iteration stops and that value is returned.
+
+**startobj**: The root object at which iteration begins, default is the global "world".
+
+
+**Returns**: The first truthy value returned by fn, or undefined if none.
+
+
+### find_object(fn, startobj) <sub>function</sub>
+
+
+Intended to find a matching object within the hierarchy.
+
+
+**fn**: A callback or criteria to locate a particular object.
+
+**startobj**: The root object at which search begins, default "world".
+
+
+**Returns**: Not yet implemented.
+
+
+### tag_add(tag, obj) <sub>function</sub>
+
+
+Associate the given object with the specified tag. Creates a new tag set if it does not exist.
+
+
+**tag**: A string tag to associate with the object.
+
+**obj**: The object to add under this tag.
+
+
+**Returns**: None
+
+
+### tag_rm(tag, obj) <sub>function</sub>
+
+
+Remove the given object from the specified tag’s set, if it exists.
+
+
+**tag**: The tag to remove the object from.
+
+**obj**: The object to remove from the tag set.
+
+
+**Returns**: None
+
+
+### tag_clear_guid(obj) <sub>function</sub>
+
+
+Remove the object from all tag sets.
+
+
+**obj**: The object whose tags should be cleared.
+
+
+**Returns**: None
+
+
+### objects_with_tag(tag) <sub>function</sub>
+
+
+Retrieve all objects currently tagged with the specified tag.
+
+
+**tag**: A string tag to look up.
+
+
+**Returns**: An array of objects associated with the given tag.
+

docs/api/modules/camera.md

@@ -0,0 +1,46 @@
+# camera
+
+### list() <sub>function</sub>
+
+Return an array of available camera device IDs.
+
+
+
+**Returns**: An array of camera IDs, or undefined if no cameras are available.
+
+
+### open(id) <sub>function</sub>
+
+Open a camera device with the given ID.
+
+
+
+**id**: The camera ID to open.
+
+
+**Returns**: A camera object on success, or throws an error if the camera cannot be opened.
+
+
+### name(id) <sub>function</sub>
+
+Return the name of the camera with the given ID.
+
+
+
+**id**: The camera ID to query.
+
+
+**Returns**: A string with the camera's name, or throws an error if the name cannot be retrieved.
+
+
+### position(id) <sub>function</sub>
+
+Return the physical position of the camera with the given ID.
+
+
+
+**id**: The camera ID to query.
+
+
+**Returns**: A string indicating the camera position ("unknown", "front", or "back").
+

docs/api/modules/cmd.md

@@ -0,0 +1,7 @@
+# cmd
+
+### length <sub>number</sub>
+
+### name <sub>string</sub>
+
+### prototype <sub>object</sub>

docs/api/modules/color.md

@@ -0,0 +1,7 @@
+# color
+
+### Color <sub>object</sub>
+
+### esc <sub>object</sub>
+
+### ColorMap <sub>object</sub>

docs/api/modules/debug.md

@@ -0,0 +1,76 @@
+# debug
+
+### stack_depth() <sub>function</sub>
+
+Return the current stack depth.
+
+
+
+**Returns**: A number representing the stack depth.
+
+
+### build_backtrace() <sub>function</sub>
+
+Build and return a backtrace of the current call stack.
+
+
+
+**Returns**: An object representing the call stack backtrace.
+
+
+### closure_vars(fn) <sub>function</sub>
+
+Return the closure variables for a given function.
+
+
+
+**fn**: The function object to inspect.
+
+
+**Returns**: An object containing the closure variables.
+
+
+### local_vars(depth) <sub>function</sub>
+
+Return the local variables for a specific stack frame.
+
+
+
+**depth**: The stack frame depth to inspect.
+
+
+**Returns**: An object containing the local variables at the specified depth.
+
+
+### fn_info(fn) <sub>function</sub>
+
+Return metadata about a given function.
+
+
+
+**fn**: The function object to inspect.
+
+
+**Returns**: An object with metadata about the function.
+
+
+### backtrace_fns() <sub>function</sub>
+
+Return an array of functions in the current backtrace.
+
+
+
+**Returns**: An array of function objects from the call stack.
+
+
+### dump_obj(obj) <sub>function</sub>
+
+Return a string representation of a given object.
+
+
+
+**obj**: The object to dump.
+
+
+**Returns**: A string describing the object's contents.
+

docs/api/modules/dmon.md

@@ -0,0 +1,39 @@
+# dmon
+
+### watch() <sub>function</sub>
+
+Start watching the root directory, recursively.
+
+This function begins monitoring the specified directory and its subdirectories recursively for events such as file creation, deletion, modification, or movement. Events are queued and can be retrieved by calling poll.
+
+:throws: An error if dmon is already watching.
+
+
+**Returns**: None
+
+
+### unwatch() <sub>function</sub>
+
+Stop watching the currently monitored directory.
+
+This function halts filesystem monitoring for the directory previously set by watch. It clears the watch state, allowing a new watch to be started.
+
+:throws: An error if no directory is currently being watched.
+
+
+**Returns**: None
+
+
+### poll(callback) <sub>function</sub>
+
+Retrieve and process queued filesystem events.
+
+This function dequeues all pending filesystem events and invokes the provided callback for each one. The callback receives an event object with properties: 'action' (string: "create", "delete", "modify", or "move"), 'root' (string: watched directory), 'file' (string: affected file path), and 'old' (string: previous file path for move events, empty if not applicable).
+
+
+
+**callback**: A function to call for each event, receiving an event object as its argument.
+
+
+**Returns**: None
+

docs/api/modules/doc.md

@@ -0,0 +1,38 @@
+# doc
+
+
+Provides a consistent way to create documentation for prosperon elements. Objects are documented by adding docstrings directly to object-like things (functions, objects, ...), or to an object's own "doc object".
+
+Docstrings are set to the symbol `cell.DOC`
+
+```js
+// Suppose we have a module that returns a function
+function greet(name) { log.console("Hello, " + name) }
+
+// We can attach a docstring
+greet.doc = `
+Greets the user by name.
+`
+
+// A single function is a valid return!
+return greet
+```
+
+```js
+// Another way is to add a docstring object to an object
+var greet = {
+hello() { log.console('hello!') }
+}
+
+greet[cell.DOC] = {}
+greet[cell.DOC][cell.DOC] = 'An object full of different greeter functions'
+greet[cell.DOC].hello = 'A greeter that says, "hello!"'
+```
+
+
+**name**: The name of the person to greet.
+
+
+### writeDocFile(obj, title) <sub>function</sub>
+
+Return a markdown string for a given obj, with an optional title.

docs/api/modules/draw2d.md

@@ -0,0 +1,228 @@
+# draw2d
+
+
+A collection of 2D drawing functions that operate in screen space. Provides primitives
+for lines, rectangles, text, sprite drawing, etc.
+
+
+### point(pos, size, color) <sub>function</sub>
+
+
+
+
+**pos**: A 2D position ([x, y]) where the point should be drawn.
+
+**size**: The size of the point (not currently affecting rendering).
+
+**color**: The color of the point, defaults to Color.blue.
+
+
+**Returns**: None
+
+
+### line(points, color, thickness, pipeline) <sub>function</sub>
+
+
+
+
+**points**: An array of 2D positions representing the line vertices.
+
+**color**: The color of the line, default Color.white.
+
+**thickness**: The line thickness, default 1.
+
+**pipeline**: (Optional) A pipeline or rendering state object.
+
+
+**Returns**: None
+
+
+### cross(pos, size, color, thickness, pipe) <sub>function</sub>
+
+
+
+
+**pos**: The center of the cross as a 2D position ([x, y]).
+
+**size**: Half the size of each cross arm.
+
+**color**: The color of the cross, default Color.red.
+
+**thickness**: The thickness of each line, default 1.
+
+**pipe**: (Optional) A pipeline or rendering state object.
+
+
+**Returns**: None
+
+
+### arrow(start, end, color, wingspan, wingangle, pipe) <sub>function</sub>
+
+
+
+
+**start**: The start position of the arrow ([x, y]).
+
+**end**: The end (tip) position of the arrow ([x, y]).
+
+**color**: The color, default Color.red.
+
+**wingspan**: The length of each arrowhead 'wing', default 4.
+
+**wingangle**: Wing rotation in degrees, default 10.
+
+**pipe**: (Optional) A pipeline or rendering state object.
+
+
+**Returns**: None
+
+
+### rectangle(rect, color, pipeline) <sub>function</sub>
+
+
+
+
+**rect**: A rectangle object with {x, y, width, height}.
+
+**color**: The fill color, default Color.white.
+
+**pipeline**: (Optional) A pipeline or rendering state object.
+
+
+**Returns**: None
+
+
+### tile(image, rect, color, tile, pipeline) <sub>function</sub>
+
+
+:raises Error: If no image is provided.
+
+
+**image**: An image object or string path to a texture.
+
+**rect**: A rectangle specifying draw location/size ({x, y, width, height}).
+
+**color**: The color tint, default Color.white.
+
+**tile**: A tiling definition ({repeat_x, repeat_y}), default tile_def.
+
+**pipeline**: (Optional) A pipeline or rendering state object.
+
+
+**Returns**: None
+
+
+### slice9(image, rect, slice, color, info, pipeline) <sub>function</sub>
+
+
+:raises Error: If no image is provided.
+
+
+**image**: An image object or string path to a texture.
+
+**rect**: A rectangle specifying draw location/size, default [0, 0].
+
+**slice**: The pixel inset or spacing for the 9-slice (number or object).
+
+**color**: The color tint, default Color.white.
+
+**info**: A slice9 info object controlling tiling of edges/corners.
+
+**pipeline**: (Optional) A pipeline or rendering state object.
+
+
+**Returns**: None
+
+
+### image(image, rect, rotation, color, pipeline) <sub>function</sub>
+
+
+:raises Error: If no image is provided.
+
+
+**image**: An image object or string path to a texture.
+
+**rect**: A rectangle specifying draw location/size, default [0,0]; width/height default to image size.
+
+**rotation**: Rotation in degrees (not currently used).
+
+**color**: The color tint, default none.
+
+**pipeline**: (Optional) A pipeline or rendering state object.
+
+
+**Returns**: A sprite object that was created for this draw call.
+
+
+### images(image, rects, config) <sub>function</sub>
+
+
+:raises Error: If no image is provided.
+
+
+**image**: An image object or string path to a texture.
+
+**rects**: An array of rectangle objects ({x, y, width, height}) to draw.
+
+**config**: (Unused) Additional config data if needed.
+
+
+**Returns**: An array of sprite objects created and queued for rendering.
+
+
+### sprites(sprites, sort, pipeline) <sub>function</sub>
+
+
+
+
+**sprites**: An array of sprite objects to draw.
+
+**sort**: Sorting mode or order, default 0.
+
+**pipeline**: (Optional) A pipeline or rendering state object.
+
+
+**Returns**: None
+
+
+### circle(pos, radius, color, inner_radius, pipeline) <sub>function</sub>
+
+
+
+
+**pos**: Center of the circle ([x, y]).
+
+**radius**: The circle radius.
+
+**color**: The fill color of the circle, default none.
+
+**inner_radius**: (Unused) Possibly ring thickness, default 1.
+
+**pipeline**: (Optional) A pipeline or rendering state object.
+
+
+**Returns**: None
+
+
+### text(text, rect, font, size, color, wrap, pipeline) <sub>function</sub>
+
+
+
+
+**text**: The string to draw.
+
+**rect**: A rectangle specifying draw position (and possibly wrapping area).
+
+**font**: A font object or string path, default sysfont.
+
+**size**: (Unused) Possibly intended for scaling the font size.
+
+**color**: The text color, default Color.white.
+
+**wrap**: Pixel width for text wrapping, default 0 (no wrap).
+
+**pipeline**: (Optional) A pipeline or rendering state object.
+
+
+**Returns**: None
+

docs/api/modules/enet.md

@@ -0,0 +1,45 @@
+# enet
+
+### initialize() <sub>function</sub>
+
+
+Initialize the ENet library. Must be called before using any ENet functionality.
+Throws an error if initialization fails.
+
+
+
+**Returns**: None
+
+
+### deinitialize() <sub>function</sub>
+
+
+Deinitialize the ENet library, cleaning up all resources. Call this when you no longer
+need any ENet functionality.
+
+
+
+**Returns**: None
+
+
+### create_host(address) <sub>function</sub>
+
+
+Create an ENet host for either a client-like unbound host or a server bound to a specific
+address and port:
+
+- If no argument is provided, creates an unbound "client-like" host with default settings
+(maximum 32 peers, 2 channels, unlimited bandwidth).
+- If you pass an "ip:port" string (e.g. "127.0.0.1:7777"), it creates a server bound to
+that address. The server supports up to 32 peers, 2 channels, and unlimited bandwidth.
+
+Throws an error if host creation fails for any reason.
+
+omit to create an unbound client-like host.
+
+
+**address**: (optional) A string in 'ip:port' format to bind the host (server), or
+
+
+**Returns**: An ENetHost object.
+

docs/api/modules/event.md

@@ -0,0 +1,25 @@
+# event
+
+### push_event(event) <sub>function</sub>
+
+Push a custom user event into SDL's queue, passing a callback function.
+
+
+
+**event**: A function to call when this event is consumed.
+
+
+**Returns**: None
+
+
+### engine_input(callback) <sub>function</sub>
+
+Poll all system events (keyboard, mouse, etc.) and call the given function with each event object.
+
+
+
+**callback**: A function that executes on each event consumed from the poll.
+
+
+**Returns**: None
+

docs/api/modules/geometry.md

@@ -0,0 +1,221 @@
+# geometry
+
+
+A collection of geometry-related functions for circles, spheres, boxes, polygons,
+and rectangle utilities. Some functionality is implemented in C and exposed here.
+
+
+### rect_intersection(a, b) <sub>function</sub>
+
+
+Return the intersection of two rectangles. The result may be empty if no intersection.
+
+
+**a**: The first rectangle as {x, y, w, h}.
+
+**b**: The second rectangle as {x, y, w, h}.
+
+
+**Returns**: A rectangle that is the intersection of the two. May have zero width/height if no overlap.
+
+
+### rect_intersects(a, b) <sub>function</sub>
+
+
+
+
+**a**: Rectangle {x,y,w,h}.
+
+**b**: Rectangle {x,y,w,h}.
+
+
+**Returns**: A boolean indicating whether the two rectangles overlap.
+
+
+### rect_expand(a, b) <sub>function</sub>
+
+
+Merge or combine two rectangles, returning their bounding rectangle.
+
+
+**a**: Rectangle {x,y,w,h}.
+
+**b**: Rectangle {x,y,w,h}.
+
+
+**Returns**: A new rectangle that covers the bounds of both input rectangles.
+
+
+### rect_inside(inner, outer) <sub>function</sub>
+
+
+
+
+**inner**: A rectangle to test.
+
+**outer**: A rectangle that may contain 'inner'.
+
+
+**Returns**: True if 'inner' is completely inside 'outer', otherwise false.
+
+
+### rect_random(rect) <sub>function</sub>
+
+
+
+
+**rect**: A rectangle {x,y,w,h}.
+
+
+**Returns**: A random point within the rectangle (uniform distribution).
+
+
+### cwh2rect(center, wh) <sub>function</sub>
+
+
+Helper: convert a center point and width/height vector to a rect object.
+
+
+**center**: A 2D point [cx, cy].
+
+**wh**: A 2D size [width, height].
+
+
+**Returns**: A rectangle {x, y, w, h} with x,y set to center and w,h set to the given size.
+
+
+### rect_point_inside(rect, point) <sub>function</sub>
+
+
+
+
+**rect**: A rectangle {x,y,w,h}.
+
+**point**: A 2D point [px, py].
+
+
+**Returns**: True if the point lies inside the rectangle, otherwise false.
+
+
+### rect_pos(rect) <sub>function</sub>
+
+
+
+
+**rect**: A rectangle {x,y,w,h}.
+
+
+**Returns**: A 2D vector [x,y] giving the rectangle's position.
+
+
+### rect_move(rect, offset) <sub>function</sub>
+
+
+
+
+**rect**: A rectangle {x,y,w,h}.
+
+**offset**: A 2D vector to add to the rectangle's position.
+
+
+**Returns**: A new rectangle with updated x,y offset.
+
+
+### box(w, h) <sub>function</sub>
+
+
+Construct a box centered at the origin with the given width and height. This overrides the box object above.
+
+
+**w**: The width of the box.
+
+**h**: The height of the box.
+
+
+**Returns**: An array of four 2D points representing the corners of a rectangle centered at [0,0].
+
+
+### sphere <sub>object</sub>
+
+
+Sphere-related geometry functions:
+- volume(r): Return the volume of a sphere with radius r.
+- random(r, theta, phi): Return a random point on or inside a sphere.
+
+
+### circle <sub>object</sub>
+
+
+Circle-related geometry functions:
+- area(r): Return the area of a circle with radius r.
+- random(r, theta): Return a random 2D point on a circle; uses sphere.random internally and extracts x,z.
+
+
+### ngon(radius, n) <sub>function</sub>
+
+
+Generates a regular n-gon by calling geometry.arc with full 360 degrees.
+
+
+**radius**: The radius of the n-gon from center to each vertex.
+
+**n**: Number of sides/vertices.
+
+
+**Returns**: An array of 2D points forming a regular n-gon.
+
+
+### arc(radius, angle, n, start) <sub>function</sub>
+
+
+Generate an arc (or partial circle) of n points, each angle spread equally over 'angle' degrees from 'start'.
+
+
+**radius**: The distance from center to the arc points.
+
+**angle**: The total angle (in degrees) over which points are generated, capped at 360.
+
+**n**: Number of segments (if <=1, empty array is returned).
+
+**start**: Starting angle (in degrees), default 0.
+
+
+**Returns**: An array of 2D points along the arc.
+
+
+### corners2points(ll, ur) <sub>function</sub>
+
+
+Similar to box.points, but calculates differently.
+
+
+**ll**: Lower-left 2D coordinate.
+
+**ur**: Upper-right 2D coordinate (relative offset in x,y).
+
+
+**Returns**: A four-point array of corners [ll, lower-right, upper-right, upper-left].
+
+
+### sortpointsccw(points) <sub>function</sub>
+
+
+Sort an array of points in CCW order based on their angles from the centroid.
+
+
+**points**: An array of 2D points.
+
+
+**Returns**: A new array of the same points, sorted counterclockwise around their centroid.
+
+
+### points2cm(points) <sub>function</sub>
+
+
+
+
+**points**: An array of 2D points.
+
+
+**Returns**: The centroid (average x,y) of the given points.
+

docs/api/modules/graphics.md

@@ -0,0 +1,278 @@
+# graphics
+
+
+Provides functionality for loading and managing images, fonts, textures, and sprite meshes.
+Includes both JavaScript and C-implemented routines for creating geometry buffers, performing
+rectangle packing, etc.
+
+
+### make_sprite_mesh(sprites) <sub>function</sub>
+
+
+:param oldMesh (optional): An existing mesh object to reuse/resize if possible.
+Given an array of sprites, build a single geometry mesh for rendering them.
+
+
+**sprites**: An array of sprite objects, each containing .rect (or transform), .src (UV region), .color, etc.
+
+
+**Returns**: A GPU mesh object with pos, uv, color, and indices buffers for all sprites.
+
+
+### make_sprite_queue(sprites, camera, pipeline, sort) <sub>function</sub>
+
+
+Given an array of sprites, optionally sort them, then build a queue of pipeline commands.
+Each group with a shared image becomes one command.
+
+
+**sprites**: An array of sprite objects.
+
+**camera**: (unused in the C code example) Typically a camera or transform for sorting?
+
+**pipeline**: A pipeline object for rendering.
+
+**sort**: An integer or boolean for whether to sort sprites; if truthy, sorts by layer & texture.
+
+
+**Returns**: An array of pipeline commands: geometry with mesh references, grouped by image.
+
+
+### make_text_buffer(text, rect, angle, color, wrap, font) <sub>function</sub>
+
+
+Generate a GPU buffer mesh of text quads for rendering with a font, etc.
+
+
+**text**: The string to render.
+
+**rect**: A rectangle specifying position and possibly wrapping.
+
+**angle**: Rotation angle (unused or optional).
+
+**color**: A color for the text (could be a vec4).
+
+**wrap**: The width in pixels to wrap text, or 0 for no wrap.
+
+**font**: A font object created by graphics.make_font or graphics.get_font.
+
+
+**Returns**: A geometry buffer mesh (pos, uv, color, indices) for rendering text.
+
+
+### rectpack(width, height, sizes) <sub>function</sub>
+
+
+Perform a rectangle packing using the stbrp library. Return positions for each rect.
+
+
+**width**: The width of the area to pack into.
+
+**height**: The height of the area to pack into.
+
+**sizes**: An array of [w,h] pairs for the rectangles to pack.
+
+
+**Returns**: An array of [x,y] coordinates placing each rect, or null if they don't fit.
+
+
+### make_rtree() <sub>function</sub>
+
+
+Create a new R-Tree for geometry queries.
+
+
+**Returns**: An R-Tree object for quickly querying many rectangles or sprite bounds.
+
+
+### make_texture(data) <sub>function</sub>
+
+
+Convert raw image bytes into an SDL_Surface object.
+
+
+**data**: Raw image bytes (PNG, JPG, etc.) as an ArrayBuffer.
+
+
+**Returns**: An SDL_Surface object representing the decoded image in RAM, for use with GPU or software rendering.
+
+
+### make_gif(data) <sub>function</sub>
+
+
+Load a GIF, returning its frames. If it's a single-frame GIF, the result may have .surface only.
+
+
+**data**: An ArrayBuffer containing GIF data.
+
+
+**Returns**: An object with frames[], each frame having its own .surface. Some also have a .texture for GPU use.
+
+
+### make_aseprite(data) <sub>function</sub>
+
+
+Load an Aseprite/ASE file from an array of bytes, returning frames or animations.
+
+
+**data**: An ArrayBuffer containing Aseprite (ASE) file data.
+
+
+**Returns**: An object containing frames or animations, each with .surface. May also have top-level .surface for a single-layer case.
+
+
+### cull_sprites(sprites, camera) <sub>function</sub>
+
+
+Filter an array of sprites to only those visible in the provided camera’s view.
+
+
+**sprites**: An array of sprite objects (each has rect or transform).
+
+**camera**: A camera or bounding rectangle defining the view area.
+
+
+**Returns**: A new array of sprites that are visible in the camera's view.
+
+
+### rects_to_sprites(rects, image) <sub>function</sub>
+
+
+Convert an array of rect coords into sprite objects referencing a single image.
+
+
+**rects**: An array of rect coords or objects.
+
+**image**: An image object (with .texture).
+
+
+**Returns**: An array of sprite objects referencing the 'image' and each rect for UV or position.
+
+
+### make_surface(dimensions) <sub>function</sub>
+
+
+Create a blank surface in RAM.
+
+
+**dimensions**: The size object {width, height}, or an array [w,h].
+
+
+**Returns**: A blank RGBA surface with the given dimensions, typically for software rendering or icons.
+
+
+### make_cursor(opts) <sub>function</sub>
+
+
+
+
+**opts**: An object with {surface, hotx, hoty} or similar.
+
+
+**Returns**: An SDL_Cursor object referencing the given surface for a custom mouse cursor.
+
+
+### make_font(data, size) <sub>function</sub>
+
+
+Load a font from TTF/OTF data at the given size.
+
+
+**data**: TTF/OTF file data as an ArrayBuffer.
+
+**size**: Pixel size for rendering glyphs.
+
+
+**Returns**: A font object with surface, texture, and glyph data, for text rendering with make_text_buffer.
+
+
+### make_sprite() <sub>function</sub>
+
+
+Create a new sprite object, storing default properties.
+
+
+**Returns**: A new sprite object, which typically has .rect, .color, .layer, .image, etc.
+
+
+### make_line_prim(points, thickness, startCap, endCap, color) <sub>function</sub>
+
+
+Build a GPU mesh representing a thick polyline from an array of points, using parsl or a similar library under the hood.
+
+
+**points**: An array of [x,y] points forming the line.
+
+**thickness**: The thickness (width) of the polyline.
+
+**startCap**: (Unused) Possibly the type of cap for the start.
+
+**endCap**: (Unused) Possibly the type of cap for the end.
+
+**color**: A color to apply to the line.
+
+
+**Returns**: A geometry mesh object suitable for rendering the line via a pipeline command.
+
+
+### is_image(obj) <sub>function</sub>
+
+
+
+
+**obj**: An object to check.
+
+
+**Returns**: True if 'obj' has a .texture and a .rect property, indicating it's an image object.
+
+
+### texture(path) <sub>function</sub>
+
+
+Load or retrieve a cached image, converting it into a GPU texture. If 'path' is already an object, it’s returned directly.
+
+
+**path**: A string path to an image file or an already-loaded image object.
+
+
+**Returns**: An image object with {surface, texture, frames?, etc.} depending on the format.
+
+
+### tex_hotreload(file) <sub>function</sub>
+
+
+Reload the image for the given file, updating the cached copy in memory and GPU.
+
+
+**file**: The file path that was changed on disk.
+
+
+**Returns**: None
+
+
+### get_font(path, size) <sub>function</sub>
+
+
+Load a font from file if not cached, or retrieve from cache if already loaded.
+
+
+**path**: A string path to a font file, optionally with ".size" appended.
+
+**size**: Pixel size of the font, if not included in 'path'.
+
+
+**Returns**: A font object with .surface and .texture for rendering text.
+
+
+### queue_sprite_mesh(queue) <sub>function</sub>
+
+
+Builds a single geometry mesh for all sprite-type commands in the queue, storing first_index/num_indices
+so they can be rendered in one draw call.
+
+
+**queue**: An array of draw commands, some of which are {type:'sprite'} objects.
+
+
+**Returns**: An array of references to GPU buffers [pos,uv,color,indices].
+

docs/api/modules/input.md

@@ -0,0 +1,68 @@
+# input
+
+### mouse_show(show) <sub>function</sub>
+
+Show or hide the mouse cursor. Pass true to show, false to hide.
+
+
+
+**show**: Boolean. True to show, false to hide.
+
+
+**Returns**: None
+
+
+### mouse_lock(lock) <sub>function</sub>
+
+Capture or release the mouse, confining it within the window if locked.
+
+
+
+**lock**: Boolean. True to lock, false to unlock.
+
+
+**Returns**: None
+
+
+### cursor_set(cursor) <sub>function</sub>
+
+Set the given cursor (created by os.make_cursor) as the active mouse cursor.
+
+
+
+**cursor**: The cursor to set.
+
+
+**Returns**: None
+
+
+### keyname(keycode) <sub>function</sub>
+
+Given a numeric keycode, return the corresponding key name (e.g., from SDL).
+
+
+
+**keycode**: A numeric SDL keycode.
+
+
+**Returns**: A string with the key name.
+
+
+### keymod() <sub>function</sub>
+
+Return an object describing the current modifier keys, e.g. {shift:true, ctrl:true}.
+
+
+
+**Returns**: An object with boolean fields for each modifier key.
+
+
+### mousestate() <sub>function</sub>
+
+Return an object describing the current mouse state, including x,y coordinates
+and booleans for pressed buttons (left, middle, right, x1, x2).
+
+
+
+**Returns**: Object { x, y, left, middle, right, x1, x2 }
+

docs/api/modules/io.md

@@ -0,0 +1,243 @@
+# io
+
+### rm(path) <sub>function</sub>
+
+Remove the file or empty directory at the given path.
+
+
+
+**path**: The file or empty directory to remove. Must be empty if a directory.
+
+
+**Returns**: None
+
+
+### mkdir(path) <sub>function</sub>
+
+Create a directory at the given path.
+
+
+
+**path**: The directory path to create.
+
+
+**Returns**: None
+
+
+### stat(path) <sub>function</sub>
+
+Return an object describing file metadata for the given path. The object includes
+filesize, modtime, createtime, and accesstime. Throw an error if the path does not exist.
+
+
+
+**path**: The file or directory to retrieve metadata for.
+
+
+**Returns**: An object with metadata (filesize, modtime, createtime, accesstime).
+
+
+### globfs(patterns) <sub>function</sub>
+
+Return an array of files that do not match any of the provided glob patterns. It
+recursively enumerates the filesystem within PHYSFS. Each pattern is treated as an
+"ignore" rule, similar to .gitignore usage.
+
+
+
+**patterns**: An array of glob patterns to ignore. Any file matching one of these is skipped.
+
+
+**Returns**: An array of matching file paths.
+
+
+### match(pattern, string) <sub>function</sub>
+
+Return boolean indicating whether the given wildcard pattern matches the provided
+string. Dots must match dots. Case is not ignored.
+
+Patterns can incorporate:
+'?'  - Matches exactly one character (except leading dots or slashes).
+'*'  - Matches zero or more characters (excluding path separators).
+'**' - Matches zero or more characters, including path separators.
+'[abc]' - A bracket expression; matches any single character from the set. Ranges like [a-z], [0-9] also work.
+'[[:alpha:]]' - POSIX character classes can be used inside brackets.
+'\' - Backslash escapes the next character.
+'!'  - If placed immediately inside brackets (like [!abc]), it negates the set.
+
+
+
+**pattern**: The wildcard pattern to compare.
+
+**string**: The string to test against the wildcard pattern.
+
+
+**Returns**: True if matched, otherwise false.
+
+
+### exists(path) <sub>function</sub>
+
+Return a boolean indicating whether the file or directory at the given path exists.
+
+
+
+**path**: The file or directory path to check.
+
+
+**Returns**: True if the path exists, otherwise false.
+
+
+### mount(archiveOrDir, mountPoint) <sub>function</sub>
+
+Mount a directory or archive at the specified mount point. An undefined mount
+point mounts to '/'. Throw on error.
+
+
+
+**archiveOrDir**: The directory or archive to mount.
+
+**mountPoint**: The path at which to mount. If omitted or undefined, '/' is used.
+
+
+**Returns**: None
+
+
+### unmount(path) <sub>function</sub>
+
+Unmount a previously mounted directory or archive. Throw on error.
+
+
+
+**path**: The directory or archive mount point to unmount.
+
+
+**Returns**: None
+
+
+### slurp(path) <sub>function</sub>
+
+Read the entire file at the given path as a string. Throw on error.
+
+
+
+**path**: The file path to read from.
+
+
+**Returns**: A string with the file’s contents.
+
+
+### slurpbytes(path) <sub>function</sub>
+
+Read the entire file at the given path as a raw ArrayBuffer. Throw on error.
+
+
+
+**path**: The file path to read from.
+
+
+**Returns**: An ArrayBuffer containing the file’s raw bytes.
+
+
+### slurpwrite(data, path) <sub>function</sub>
+
+Write data (string or ArrayBuffer) to the given file path. Overwrite if it exists.
+Throw on error.
+
+
+
+**data**: The data to write (string or ArrayBuffer).
+
+**path**: The file path to write to.
+
+
+**Returns**: None
+
+
+### writepath(path) <sub>function</sub>
+
+Set the write directory. Subsequent writes will go here by default. Throw on error.
+
+
+
+**path**: The directory path to set as writable.
+
+
+**Returns**: None
+
+
+### basedir() <sub>function</sub>
+
+Return the application's base directory (where the executable is located).
+
+
+
+**Returns**: A string with the base directory path.
+
+
+### prefdir(org, app) <sub>function</sub>
+
+Get the user-and-app-specific path where files can be written.
+
+
+
+**org**: The name of your organization.
+
+**app**: The name of your application.
+
+
+**Returns**: A string with the user's directory path.
+
+
+### realdir(path) <sub>function</sub>
+
+Return the actual, real directory (on the host filesystem) that contains the given
+file path. Return undefined if not found.
+
+
+
+**path**: The file path whose real directory is requested.
+
+
+**Returns**: A string with the real directory path, or undefined.
+
+
+### open(path) <sub>function</sub>
+
+Open a file for writing, returning a file object that can be used for further
+operations. Throw on error.
+
+
+
+**path**: The file path to open for writing.
+
+
+**Returns**: A file object for subsequent write operations.
+
+
+### searchpath() <sub>function</sub>
+
+Return an array of all directories in the current paths.
+
+
+
+**Returns**: An array of directory paths in the search path.
+
+
+### enumerate(path, recurse) <sub>function</sub>
+
+Return an array of files within the given directory, optionally recursing into
+subdirectories.
+
+
+
+**path**: The directory to list.
+
+**recurse**: Whether to recursively include subdirectories (true or false).
+
+
+**Returns**: An array of file (and directory) paths found.
+
+
+### mount_core() <sub>function</sub>
+
+### is_directory() <sub>function</sub>

docs/api/modules/js.md

@@ -0,0 +1,175 @@
+# js
+
+
+Provides functions for introspecting and configuring the QuickJS runtime engine.
+Includes debug info, memory usage, GC controls, code evaluation, etc.
+
+
+### cycle_hook(callback) <sub>function</sub>
+
+
+or undefined to remove the callback.
+
+Register or remove a hook function that QuickJS calls once per execution cycle. If the callback
+is set, it receives a single argument (an optional object/value describing the cycle). If callback
+is undefined, the hook is removed.
+
+
+**callback**: A function to call each time QuickJS completes a "cycle" (internal VM loop),
+
+
+**Returns**: None
+
+
+### dump_shapes() <sub>function</sub>
+
+
+Use this for internal debugging of object shapes.
+
+
+**Returns**: A debug string describing the internal shape hierarchy used by QuickJS.
+
+
+### dump_atoms() <sub>function</sub>
+
+
+known by QuickJS. Helpful for diagnosing memory usage or potential key collisions.
+
+
+**Returns**: A debug string listing all currently registered atoms (internal property keys/symbols)
+
+
+### dump_class() <sub>function</sub>
+
+
+Shows how many objects of each class exist, useful for advanced memory or performance profiling.
+
+
+**Returns**: A debug string describing the distribution of JS object classes in the QuickJS runtime.
+
+
+### dump_objects() <sub>function</sub>
+
+
+useful for debugging memory leaks or object lifetimes.
+
+
+**Returns**: A debug string listing certain internal QuickJS objects and their references,
+
+
+### dump_type_overheads() <sub>function</sub>
+
+
+Displays memory usage breakdown for different internal object types.
+
+
+**Returns**: A debug string describing the overheads for various JS object types in QuickJS.
+
+
+### stack_info() <sub>function</sub>
+
+
+Internal debugging utility to examine call stack details.
+
+
+**Returns**: An object or string describing the runtime's current stack usage and capacity.
+
+
+### calc_mem(value) <sub>function</sub>
+
+
+
+Compute the approximate size of a single JS value in memory. This is a best-effort estimate.
+
+
+**value**: A JavaScript value to analyze.
+
+
+**Returns**: Approximate memory usage (in bytes) of that single value.
+
+
+### mem() <sub>function</sub>
+
+
+including total allocated bytes, object counts, and more.
+
+Retrieve an overview of the runtime’s memory usage.
+
+
+**Returns**: An object containing a comprehensive snapshot of memory usage for the current QuickJS runtime,
+
+
+### mem_limit(bytes) <sub>function</sub>
+
+
+
+Set the upper memory limit for the QuickJS runtime. Exceeding this limit may cause operations to
+fail or throw errors.
+
+
+**bytes**: The maximum memory (in bytes) QuickJS is allowed to use.
+
+
+**Returns**: None
+
+
+### gc_threshold(bytes) <sub>function</sub>
+
+
+
+Set the threshold (in bytes) for QuickJS to perform an automatic GC pass when memory usage surpasses it.
+
+
+**bytes**: The threshold (in bytes) at which the engine triggers automatic garbage collection.
+
+
+**Returns**: None
+
+
+### max_stacksize(bytes) <sub>function</sub>
+
+
+
+Set the maximum stack size for QuickJS. If exceeded, the runtime may throw a stack overflow error.
+
+
+**bytes**: The maximum allowed stack size (in bytes) for QuickJS.
+
+
+**Returns**: None
+
+
+### memstate() <sub>function</sub>
+
+
+
+Gives a quick overview of the memory usage, including malloc size and other allocations.
+
+
+**Returns**: A simpler memory usage object (malloc sizes, etc.) for the QuickJS runtime.
+
+
+### gc() <sub>function</sub>
+
+
+
+Force an immediate, full garbage collection pass, reclaiming unreachable memory.
+
+
+**Returns**: None
+
+
+### eval(src, filename) <sub>function</sub>
+
+
+
+Execute a string of JavaScript code in the current QuickJS context.
+
+
+**src**: A string of JavaScript source code to evaluate.
+
+**filename**: (Optional) A string for the filename or label, used in debugging or stack traces.
+
+
+**Returns**: The result of evaluating the given source code.
+

docs/api/modules/json.md

@@ -0,0 +1,15 @@
+# json
+
+### encode(val,space,replacer,whitelist) <sub>function</sub>
+
+Produce a JSON text from a Javascript object. If a record value, at any level, contains a json() method, it will be called, and the value it returns (usually a simpler record) will be JSONified.
+
+If the record does not have a json() method, and if whitelist is a record, then only the keys that are associated with true in the whitelist are included.
+
+If the space input is true, then line breaks and extra whitespace will be included in the text.
+
+### decode(text,reviver) <sub>function</sub>
+
+The text text is parsed, and the resulting value (usually a record or an array) is returned.
+
+The optional reviver input is a method that will be called for every key and value at every level of the result. Each value will be replaced by the result of the reviver function. This can be used to reform data-only records into method-bearing records, or to transform date strings into seconds.

docs/api/modules/loop.md

@@ -0,0 +1,3 @@
+# loop
+
+### step() <sub>function</sub>

docs/api/modules/math.md

@@ -0,0 +1,115 @@
+# math
+
+### dot() <sub>function</sub>
+
+Compute the dot product between two numeric arrays, returning a scalar. Extra elements are ignored.
+
+### project() <sub>function</sub>
+
+Project one vector onto another, returning a new array of the same dimension.
+
+### rotate() <sub>function</sub>
+
+Rotate a 2D point (or array of length 2) by the given angle (in turns) around an optional pivot.
+
+### midpoint() <sub>function</sub>
+
+Compute the midpoint of two arrays of numbers. Only the first two entries are used if 2D is intended.
+
+### reflect() <sub>function</sub>
+
+Reflect a vector across a plane normal. Both arguments must be numeric arrays.
+
+### distance() <sub>function</sub>
+
+Compute the Euclidean distance between two numeric arrays of matching length.
+
+### direction() <sub>function</sub>
+
+Compute the normalized direction vector from the first array to the second.
+
+### angle() <sub>function</sub>
+
+Given a 2D vector, return its angle from the X-axis in radians or some chosen units.
+
+### norm() <sub>function</sub>
+
+Return a normalized copy of the given numeric array. For 2D/3D/4D or arbitrary length.
+
+### angle_between() <sub>function</sub>
+
+Compute the angle between two vectors (2D/3D/4D).
+
+### lerp() <sub>function</sub>
+
+Linear interpolation between two numbers: lerp(a, b, t).
+
+### gcd() <sub>function</sub>
+
+Compute the greatest common divisor of two integers.
+
+### lcm() <sub>function</sub>
+
+Compute the least common multiple of two integers.
+
+### clamp() <sub>function</sub>
+
+Clamp a number between low and high. clamp(value, low, high).
+
+### angledist() <sub>function</sub>
+
+Compute the signed distance between two angles in 'turn' units, e.g. 0..1 range.
+
+### jitter() <sub>function</sub>
+
+Apply a random +/- percentage noise to a number. Example: jitter(100, 0.05) -> ~95..105.
+
+### mean() <sub>function</sub>
+
+Compute the arithmetic mean of an array of numbers.
+
+### sum() <sub>function</sub>
+
+Sum all elements of an array of numbers.
+
+### sigma() <sub>function</sub>
+
+Compute standard deviation of an array of numbers.
+
+### median() <sub>function</sub>
+
+Compute the median of an array of numbers.
+
+### length() <sub>function</sub>
+
+Return the length of a vector (i.e. sqrt of sum of squares).
+
+### from_to() <sub>function</sub>
+
+Return an array of points from a start to an end, spaced out by a certain distance.
+
+### rand() <sub>function</sub>
+
+Return a random float in [0,1).
+
+### randi() <sub>function</sub>
+
+Return a random 32-bit integer.
+
+### srand() <sub>function</sub>
+
+Seed the random number generator with the given integer, or with current time if none.
+
+### TAU <sub>number</sub>
+
+### deg2rad(deg) <sub>function</sub>
+
+### rad2deg(rad) <sub>function</sub>
+
+### turn2rad(x) <sub>function</sub>
+
+### rad2turn(x) <sub>function</sub>
+
+### turn2deg(x) <sub>function</sub>
+
+### deg2turn(x) <sub>function</sub>

docs/api/modules/miniz.md

@@ -0,0 +1,27 @@
+# miniz
+
+### read(data) <sub>function</sub>
+
+Create a zip reader from the given ArrayBuffer containing an entire ZIP archive.
+Return undefined if the data is invalid.
+
+
+
+**data**: An ArrayBuffer with the entire ZIP file.
+
+
+**Returns**: A 'zip reader' object with methods for reading from the archive (mod, exists, slurp).
+
+
+### write(path) <sub>function</sub>
+
+Create a zip writer that writes to the specified file path. Overwrites the file if
+it already exists. Return undefined on error.
+
+
+
+**path**: The file path where the ZIP archive will be written.
+
+
+**Returns**: A 'zip writer' object with methods for adding files to the archive (add_file).
+

docs/api/modules/nota.md

@@ -0,0 +1,30 @@
+# nota
+
+### encode(value) <sub>function</sub>
+
+Convert a JavaScript value into a NOTA-encoded ArrayBuffer.
+
+This function serializes JavaScript values (such as numbers, strings, booleans, arrays, objects, or ArrayBuffers) into the NOTA binary format. The resulting ArrayBuffer can be stored or transmitted and later decoded back into a JavaScript value.
+
+:throws: An error if no argument is provided.
+
+
+**value**: The JavaScript value to encode (e.g., number, string, boolean, array, object, or ArrayBuffer).
+
+
+**Returns**: An ArrayBuffer containing the NOTA-encoded data.
+
+
+### decode(buffer) <sub>function</sub>
+
+Decode a NOTA-encoded ArrayBuffer into a JavaScript value.
+
+This function deserializes a NOTA-formatted ArrayBuffer into its corresponding JavaScript representation, such as a number, string, boolean, array, object, or ArrayBuffer. If the input is invalid or empty, it returns undefined.
+
+
+
+**buffer**: An ArrayBuffer containing NOTA-encoded data to decode.
+
+
+**Returns**: The decoded JavaScript value (e.g., number, string, boolean, array, object, or ArrayBuffer), or undefined if no argument is provided.
+

docs/api/modules/os.md

@@ -0,0 +1,101 @@
+# os
+
+### make_transform() <sub>function</sub>
+
+Create a new transform object that can be used for 2D/3D positioning, scaling, and rotation.
+
+### clean_transforms() <sub>function</sub>
+
+Force an update on all transforms to remove dangling references or perform house-keeping.
+
+### platform() <sub>function</sub>
+
+Return a string with the underlying platform name, like 'Windows', 'Linux', or 'macOS'.
+
+### arch() <sub>function</sub>
+
+Return the CPU architecture string for this system (e.g. 'x64', 'arm64').
+
+### totalmem() <sub>function</sub>
+
+Return the total system RAM in bytes.
+
+### freemem() <sub>function</sub>
+
+Return the amount of free system RAM in bytes, if known.
+
+### hostname() <sub>function</sub>
+
+Return the system's hostname, or an empty string if not available.
+
+### version() <sub>function</sub>
+
+Return the OS or kernel version string, if the platform provides it.
+
+### kill() <sub>function</sub>
+
+Send a signal (e.g., 'SIGINT', 'SIGTERM', etc.) to the current process.
+
+### exit() <sub>function</sub>
+
+Exit the application with the specified exit code.
+
+### now() <sub>function</sub>
+
+Return current time (in seconds as a float) with high resolution.
+
+### openurl() <sub>function</sub>
+
+Open the provided URL in the default web browser, if possible.
+
+### make_timer() <sub>function</sub>
+
+Create a new timer object that will call a specified function after a certain delay.
+
+### update_timers() <sub>function</sub>
+
+Advance all timers by the provided time delta (in seconds).
+
+### sleep() <sub>function</sub>
+
+Block execution for the specified number of seconds.
+
+### battery_pct() <sub>function</sub>
+
+Return the battery level (percentage) or negative if unknown.
+
+### battery_voltage() <sub>function</sub>
+
+Return the current battery voltage in volts, if available.
+
+### battery_seconds() <sub>function</sub>
+
+Return the estimated remaining battery time in seconds, or negative if unknown.
+
+### power_state() <sub>function</sub>
+
+Return a string describing power status: 'on battery', 'charging', 'charged', etc.
+
+### on() <sub>function</sub>
+
+Register a global callback for certain engine-wide or system-level events.
+
+### rt_info() <sub>function</sub>
+
+Return internal QuickJS runtime info, such as object counts.
+
+### rusage() <sub>function</sub>
+
+Return resource usage stats for this process, if the platform supports it.
+
+### mallinfo() <sub>function</sub>
+
+Return detailed memory allocation info (arena size, free blocks, etc.) on some platforms.
+
+### env() <sub>function</sub>
+
+Fetch the value of a given environment variable, or undefined if it doesn't exist.
+
+### system() <sub>function</sub>
+
+Execute a shell command using the system() call. Returns the command's exit code.

docs/api/modules/packer.md

@@ -0,0 +1,44 @@
+# packer
+
+### getAllFiles(dir) <sub>function</sub>
+
+
+Return a list of all files in the given directory that are not matched by .prosperonignore,
+skipping directories.
+
+
+
+**dir**: The directory to search.
+
+
+**Returns**: An array of file paths found.
+
+
+### gatherStats(filePaths) <sub>function</sub>
+
+
+Analyze a list of files and categorize them as modules, programs, images, or other.
+
+
+
+**filePaths**: An array of file paths to analyze.
+
+
+**Returns**: An object { modules, programs, images, other, total } with counts.
+
+
+### pack(dir, outPath) <sub>function</sub>
+
+
+Create a ZIP archive of all files (skipping those matched by .prosperonignore) in the
+specified directory and write it to outPath. This uses the miniz module.
+
+
+
+**dir**: The directory to zip.
+
+**outPath**: The path (including filename) for the resulting ZIP file.
+
+
+**Returns**: None (synchronous). Throws an Error if the directory does not exist.
+

docs/api/modules/render.md

@@ -0,0 +1,96 @@
+# render
+
+### _main <sub>object</sub>
+
+A handle for low-level GPU operations via SDL GPU. Freed on GC.
+
+
+### device <sub>object</sub>
+
+### stencil_writer(...args) <sub>function</sub>
+
+### fillmask(ref) <sub>function</sub>
+
+Draw a fullscreen shape using a 'screenfill' shader to populate the stencil buffer with a given reference.
+
+
+
+**ref**: The stencil reference value to write.
+
+
+**Returns**: None
+
+
+### mask(image, pos, scale, rotation, ref) <sub>function</sub>
+
+Draw an image to the stencil buffer, marking its area with a specified reference value.
+
+
+
+**image**: A texture or string path (which is converted to a texture).
+
+**pos**: The translation (x, y) for the image placement.
+
+**scale**: Optional scaling applied to the texture.
+
+**rotation**: Optional rotation in radians (unused by default).
+
+**ref**: The stencil reference value to write.
+
+
+**Returns**: None
+
+
+### viewport(rect) <sub>function</sub>
+
+Set the GPU viewport to the specified rectangle.
+
+
+
+**rect**: A rectangle [x, y, width, height].
+
+
+**Returns**: None
+
+
+### scissor(rect) <sub>function</sub>
+
+Set the GPU scissor region to the specified rectangle (alias of render.viewport).
+
+
+
+**rect**: A rectangle [x, y, width, height].
+
+
+**Returns**: None
+
+
+### queue(cmd) <sub>function</sub>
+
+Enqueue one or more draw commands. These commands are batched until render_camera is called.
+
+
+
+**cmd**: Either a single command object or an array of command objects.
+
+
+**Returns**: None
+
+
+### setup_draw() <sub>function</sub>
+
+Switch the current queue to the primary scene render queue, then invoke 'prosperon.draw' if defined.
+
+
+
+**Returns**: None
+
+
+### setup_hud() <sub>function</sub>
+
+Switch the current queue to the HUD render queue, then invoke 'prosperon.hud' if defined.
+
+
+
+**Returns**: None
+

docs/api/modules/resources.md

@@ -0,0 +1,68 @@
+# resources
+
+### scripts <sub>object</sub>
+
+### images <sub>object</sub>
+
+### sounds <sub>object</sub>
+
+### fonts <sub>object</sub>
+
+### lib <sub>object</sub>
+
+### canonical(file) <sub>function</sub>
+
+### find_image(...args) <sub>function</sub>
+
+### find_sound(...args) <sub>function</sub>
+
+### find_script(...args) <sub>function</sub>
+
+### find_font(...args) <sub>function</sub>
+
+### getAllFiles(dir) <sub>function</sub>
+
+
+Return a list of recognized files in the given directory that are not matched by
+.prosperonignore, skipping directories. Recognized extensions include scripts,
+images, sounds, fonts, and libs.
+
+
+
+**dir**: The directory to search.
+
+
+**Returns**: An array of recognized file paths.
+
+
+### gatherStats(filePaths) <sub>function</sub>
+
+
+Analyze a list of recognized files and categorize them by scripts, images, sounds,
+fonts, libs, or other. Return a stats object with these counts and the total.
+
+
+
+**filePaths**: An array of file paths to analyze.
+
+
+**Returns**: { scripts, images, sounds, fonts, lib, other, total }
+
+
+### pack(dir, outPath) <sub>function</sub>
+
+
+Create a ZIP archive of all recognized files (skipping those matched by .prosperonignore)
+in the specified directory and write it to outPath. Recognized extensions are scripts,
+images, sounds, fonts, or libs.
+
+:raises Error: If the directory does not exist.
+
+
+**dir**: The directory to zip.
+
+**outPath**: The path (including filename) for the resulting ZIP file.
+
+
+**Returns**: None
+

docs/api/modules/sound.md

@@ -0,0 +1,11 @@
+# sound
+
+### undefined <sub>string</sub>
+
+### pcm(file) <sub>function</sub>
+
+### play(file) <sub>function</sub>
+
+### cry(file) <sub>function</sub>
+
+### music(file, fade = 0.5) <sub>function</sub>

docs/api/modules/spline.md

@@ -0,0 +1,9 @@
+# spline
+
+### catmull() <sub>function</sub>
+
+Perform Catmull-Rom spline sampling on an array of 2D points, returning an array of samples.
+
+### bezier() <sub>function</sub>
+
+Perform a Bezier spline (or catmull) sampling on 2D points, returning an array of sampled points.

docs/api/modules/time.md

@@ -0,0 +1,103 @@
+# time
+
+The main time object, handling date/time utilities in earth-seconds.
+
+### now() <sub>function</sub>
+
+Return the current system time in seconds (implemented in C extension).
+
+### computer_dst() <sub>function</sub>
+
+Return true if local system time is currently in DST (implemented in C extension).
+
+### computer_zone() <sub>function</sub>
+
+Return local time zone offset from UTC in hours (implemented in C extension).
+
+### second <sub>number</sub>
+
+Number of seconds in a (real) second (always 1).
+
+### minute <sub>number</sub>
+
+Number of seconds in a minute (60).
+
+### hour <sub>number</sub>
+
+Number of seconds in an hour (3600).
+
+### day <sub>number</sub>
+
+Number of seconds in a day (86400).
+
+### week <sub>number</sub>
+
+Number of seconds in a week (604800).
+
+### weekdays <sub>object</sub>
+
+Names of the days of the week, Sunday through Saturday.
+
+### monthstr <sub>object</sub>
+
+Full names of the months of the year, January through December.
+
+### epoch <sub>number</sub>
+
+Base epoch year, from which day 0 is calculated (default 1970).
+
+### hour2minute() <sub>function</sub>
+
+Return the ratio of hour to minute in seconds, e.g. 3600 / 60 => 60.
+
+### day2hour() <sub>function</sub>
+
+Return the ratio of day to hour in seconds, e.g. 86400 / 3600 => 24.
+
+### minute2second() <sub>function</sub>
+
+Return the ratio of minute to second in seconds, e.g. 60 / 1 => 60.
+
+### week2day() <sub>function</sub>
+
+Return the ratio of week to day in seconds, e.g. 604800 / 86400 => 7.
+
+### strparse <sub>object</sub>
+
+Mapping of format tokens (yyyy, mm, dd, etc.) to time fields (year, month, day...).
+
+### isleap(year) <sub>function</sub>
+
+Return true if a given year is leap, based on whether it has 366 days.
+
+### yearsize(y) <sub>function</sub>
+
+Given a year, return 365 or 366 depending on leap-year rules.
+
+### timecode(t, fps = 24) <sub>function</sub>
+
+Convert seconds into a "S:frames" timecode string, with optional FPS (default 24).
+
+### monthdays <sub>object</sub>
+
+An array of days in each month for a non-leap year.
+
+### zones <sub>object</sub>
+
+Table of recognized time zone abbreviations, with offsets (e.g., "-12" -> "IDLW").
+
+### record(num, zone = this.computer_zone() <sub>function</sub>
+
+Convert a timestamp (in seconds) into a record with fields like day, month, year, etc.
+
+### number(rec) <sub>function</sub>
+
+Convert a record back into a numeric timestamp (seconds).
+
+### fmt <sub>string</sub>
+
+Default format string for time.text(), containing tokens like 'yyyy', 'dd', 'hh', etc.
+
+### text(num, fmt = this.fmt, zone) <sub>function</sub>
+
+Format a numeric or record time into a string using a format pattern, e.g. 'hh:nn:ss'.

docs/api/modules/tween.md

@@ -0,0 +1,58 @@
+# tween
+
+### Tween <sub>object</sub>
+
+
+An object providing methods to create and control tweens with additional features
+like looping, custom easing, multiple stages, etc.
+
+Properties:
+- default: A template object with loop/time/ease/whole/cb properties.
+Methods:
+- start(obj, target, tvals, options): Create a tween over multiple target values.
+- make: Alias of start.
+
+
+### Ease <sub>object</sub>
+
+
+This object provides multiple easing functions that remap a 0..1 input to produce
+a smoothed or non-linear output. They can be used standalone or inside tweens.
+
+Available functions:
+- linear(t)
+- in(t), out(t), inout(t)
+- quad.in, quad.out, quad.inout
+- cubic.in, cubic.out, cubic.inout
+- quart.in, quart.out, quart.inout
+- quint.in, quint.out, quint.inout
+- expo.in, expo.out, expo.inout
+- bounce.in, bounce.out, bounce.inout
+- sine.in, sine.out, sine.inout
+- elastic.in, elastic.out, elastic.inout
+
+All easing functions expect t in [0..1] and return a remapped value in [0..1].
+
+
+### tween(from, to, time, fn, cb) <sub>function</sub>
+
+
+
+Creates a simple tween that linearly interpolates from "from" to "to" over "time"
+and calls "fn" with each interpolated value. Once finished, "fn" is called with "to",
+then "cb" is invoked if provided, and the tween is cleaned up.
+
+
+**from**: The starting object or value to interpolate from.
+
+**to**: The ending object or value to interpolate to.
+
+**time**: The total duration of the tween in milliseconds or some time unit.
+
+**fn**: A callback function that receives the interpolated value at each update.
+
+**cb**: (Optional) A callback invoked once the tween completes.
+
+
+**Returns**: A function that, when called, cleans up and stops the tween.
+

docs/api/modules/util.md

@@ -0,0 +1,192 @@
+# util
+
+
+A collection of general-purpose utility functions for object manipulation, merging,
+deep copying, safe property access, etc.
+
+
+### guid() <sub>function</sub>
+
+
+Return a random 32-character hexadecimal UUID-like string (not guaranteed RFC4122-compliant).
+
+
+**Returns**: A random 32-character string (hex).
+
+
+### insertion_sort(arr, cmp) <sub>function</sub>
+
+
+In-place insertion sort of an array using cmp(a,b)->Number for ordering.
+
+
+**arr**: The array to be sorted in-place.
+
+**cmp**: Comparison function cmp(a,b)->Number.
+
+
+**Returns**: The same array, sorted in-place.
+
+
+### deepfreeze(obj) <sub>function</sub>
+
+
+Recursively freeze an object and all of its nested objects so they cannot be modified.
+
+
+**obj**: The object to recursively freeze.
+
+
+**Returns**: None
+
+
+### dainty_assign(target, source) <sub>function</sub>
+
+
+Copy non-function properties from source into matching keys of target without overwriting
+keys that don't exist in target. Arrays are deep-copied, and objects are recursively assigned.
+
+
+**target**: The target object whose keys may be updated.
+
+**source**: The source object containing new values.
+
+
+**Returns**: None
+
+
+### get(obj, path, defValue) <sub>function</sub>
+
+
+Safely retrieve a nested property from obj at path (array or dot-string).
+Returns defValue if the property is undefined.
+
+
+**obj**: The object to traverse.
+
+**path**: A string like "a.b.c" or an array of path segments.
+
+**defValue**: The default value if the property is undefined.
+
+
+**Returns**: The nested property or defValue.
+
+
+### isEmpty(o) <sub>function</sub>
+
+
+Return true if the object has no own properties, otherwise false.
+
+
+**o**: The object to check.
+
+
+**Returns**: Boolean indicating if the object is empty.
+
+
+### dig(obj, path, def) <sub>function</sub>
+
+
+Ensure a nested path of objects exists inside obj; create objects if missing, and set
+the final path component to def.
+
+
+**obj**: The root object to modify.
+
+**path**: A dot-string specifying nested objects to create.
+
+**def**: The value to store in the final path component, default {}.
+
+
+**Returns**: The assigned final value.
+
+
+### access(obj, name) <sub>function</sub>
+
+
+Traverse obj by dot-separated path name, returning the final value or undefined
+if any step is missing.
+
+
+**obj**: The object to traverse.
+
+**name**: A dot-string path (e.g. "foo.bar.baz").
+
+
+**Returns**: The value at that path, or undefined if missing.
+
+
+### mergekey(o1, o2, k) <sub>function</sub>
+
+
+Helper for merge, updating key k from o2 into o1. Arrays are deep-copied and objects are
+recursively merged.
+
+
+**o1**: The target object.
+
+**o2**: The source object.
+
+**k**: The key to merge.
+
+
+**Returns**: None
+
+
+### merge(target, objs) <sub>function</sub>
+
+
+Merge all passed objects into target, copying or merging each key as needed.
+Arrays are deep-copied, objects are recursively merged, etc.
+
+
+**target**: The target object.
+
+**objs**: One or more objects to merge into target.
+
+
+**Returns**: The updated target object.
+
+
+### copy(proto, objs) <sub>function</sub>
+
+
+Create a new object with proto as its prototype, then mix in additional objects’ properties.
+
+
+**proto**: The prototype object for the new object.
+
+**objs**: One or more objects whose properties will be mixed in.
+
+
+**Returns**: The newly created object.
+
+
+### obj_lerp(a, b, t) <sub>function</sub>
+
+
+Linearly interpolate between two objects a and b by factor t, assuming each property
+supports .lerp().
+
+
+**a**: The start object (its properties must have .lerp()).
+
+**b**: The end object (matching properties).
+
+**t**: Interpolation factor (0..1).
+
+
+**Returns**: A new object with interpolated properties.
+
+
+### normalizeSpacing(spacing) <sub>function</sub>
+
+
+Normalize any spacing input into a {l, r, t, b} object.
+
+
+**spacing**: A number, an array of length 2 or 4, or an object with l/r/t/b.
+
+
+**Returns**: An object {l, r, t, b}.
+

docs/api/modules/video.md

@@ -0,0 +1,5 @@
+# video
+
+### make_video() <sub>function</sub>
+
+Decode a video file (MPEG, etc.) from an ArrayBuffer, returning a datastream object.

docs/api/nota.md

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