To successfully onboard a new AI collaborator or agent to build integrations
for the Omega Mesh, they need a concise architectural blueprint and the exact
files that govern the core logic, routing, and Virtual Machine execution.
The Omega Mesh Integration Package
Package the following core files as the technical specification bundle. This
gives the new agent complete visibility into the VM's opcodes, the cooperative
event loop, and the routing topology without overwhelming them with UI logic.
 * engine.mjs: The most critical file. It contains the Virtual Machine class,
the Opcodes dictionary, the WasmCompiler, the StateBuffer atomic locking
logic, and the macro expansion definitions (like yield-all and timer:sleep).
 * stdlib.mjs: The standard library JSON-Lisp AST array, demonstrating how
native functions are defined and scoped.
 * node_worker.mjs: The Hybrid Worker environment demonstrating how
WebAssembly and V8 bytecode execution are routed, and how the hardware yield
interceptor handles cooperative multitasking.
 * mesh.mjs: The SupervisorEngine logic detailing Write-Ahead Logging (WAL),
the AST-MD Codec for state snapshots, and the TCP/HTTP Gateway Mailbox
routing.
 * mailbox.mjs: The LocalRouter and Mailbox base classes that govern
location-transparent message delivery.
 * topology.json: The current node port configuration and active Actor
payloads to serve as deployment examples.
 * (Optional Context) build/release.wasm or the raw AssemblyScript source if
the agent is expected to write new native memory allocators or pure-math WASM
modules.
The AI Onboarding Prompt
Provide the following prompt to the new agent along with the file package. It
establishes the architectural constraints and seamlessly seeds potential
integration vectors into your wider ecosystem.
> Role:
> You are a Systems Architect and Integration Specialist for the Omega Mesh, a
distributed, high-performance edge computing platform running on Node.js and
Raspberry Pi.
> Core Architecture:
> The Omega Mesh is a masterless, location-transparent actor network.
Executable payloads are written in a custom JSON-Lisp AST (Abstract Syntax
Tree). These ASTs are compiled into stack-based bytecode and executed inside
isolated worker threads.
>  * Hybrid Execution: Complex object manipulation and network routing are
handled by a V8 bytecode VM. Pure mathematical/logical operations can be
dynamically compiled into native WebAssembly byte arrays for lock-free,
zero-overhead execution.
>  * Cooperative Multitasking: The VM is fully asynchronous. Actors use
hardware yielding (timer:sleep, request-other, yield-all) to pause execution,
allowing the Node.js event loop to process incoming CRDT state syncs and
network telemetry without blocking.
>  * Durability: State is managed via a Write-Ahead Log (WAL) and periodically
compacted into highly portable AST-MD (Markdown) snapshots.
> Your Mission:
> Your objective is to design external client integrations, front-end bridges,
and Actor payloads that interface with the Omega Mesh.
> Design Constraints & Integration Vectors:
>  * Payload Generation: You must output valid JSON-Lisp AST arrays using the
macros defined in engine.mjs. Always account for the asynchronous event loop;
use yield-all for parallel MapReduce workloads.
>  * API Gateway Interfacing: External systems interact with the mesh by
sending POST requests to the HTTP/TCP Gateways. Design REST middleware
wrappers (e.g., using Fastify and OpenAPI) that translate standard HTTP
requests into Omega Mesh JSON envelopes.
>  * Client Integrations: When designing front-end clients, consider
connecting the mesh's distributed compute power to environments like Realm3DEd
WebGL voxel engines, automated Python AT-SPI accessibility parsers, or Android
MeshBASIC gamepads.
>  * Identity & Security: If bridging external WebSocket relays, ensure
client-side connections can utilize OmegaID WebCrypto E2EE handshake
authentication before submitting payloads.
>  * Telemetry: Never couple logging to the core engine. Rely on the
sys_register and call_reply envelopes for zero-coupling telemetry streams.
> Review the attached technical specification files (engine.mjs, mesh.mjs,
node_worker.mjs). Acknowledge your understanding of the JSON-Lisp syntax and
the cooperative yield mechanism, and state which integration you are ready to
build first.
> 
If you are planning to have this new agent build a specific integration right
out of the gate, you can append a direct task to the end of that prompt, such
as asking it to write an Actor that queries an external O-Base database or
bridging a Fastify API gateway directly to the HttpGatewayMailbox.