// engine.mjs export const Opcodes = { CONST: 'OP_CONST', LOAD: 'OP_LOAD',
STORE: 'OP_STORE', SET: 'OP_SET', ADD: 'OP_ADD', SUB: 'OP_SUB', MUL: 'OP_MUL',
DIV: 'OP_DIV', MOD: 'OP_MOD', EQ: 'OP_EQ', NEQ: 'OP_NEQ', LT: 'OP_LT', LTE:
'OP_LTE', GT: 'OP_GT', GTE: 'OP_GTE', AND: 'OP_AND', OR: 'OP_OR', NOT:
'OP_NOT', JMP_FALSE: 'OP_JMP_FALSE', JMP: 'OP_JMP', MAKE_FUNC: 'OP_MAKE_FUNC',
CALL: 'OP_CALL', RET: 'OP_RET', ENTER_SCOPE: 'OP_ENTER_SCOPE', EXIT_SCOPE:
'OP_EXIT_SCOPE', YIELD: 'OP_YIELD', POP: 'OP_POP', HEAD: 'OP_HEAD', TAIL:
'OP_TAIL', CONS: 'OP_CONS', EMPTY: 'OP_EMPTY', GET_IDX: 'OP_GET_IDX', SET_IDX:
'OP_SET_IDX', RECORD: 'OP_RECORD', ARRAY: 'OP_ARRAY', TRY: 'OP_TRY', END_TRY:
'OP_END_TRY', THROW: 'OP_THROW', REGISTER_ISR: 'OP_REGISTER_ISR' }; export
const OpNames = Object.fromEntries(Object.entries(Opcodes).map(([k, v]) => [v,
k])); export class Env { constructor(parent = null) { this.vars = new Map();
this.parent = parent; } define(name, value) { this.vars.set(name, value); }
set(name, value) { if (this.vars.has(name)) { this.vars.set(name, value);
return true; } if (this.parent) return this.parent.set(name, value); throw new
ReferenceError(`Cannot set undefined variable: ${name}`); } get(name) { if
(this.vars.has(name)) return this.vars.get(name); if (this.parent) return
this.parent.get(name); throw new ReferenceError(`Undefined variable:
${name}`); } } export class TypeEnv extends Env {} export class StateBuffer {
constructor(sab) { this.int32 = new Int32Array(sab); } writeState(status,
value = 0) { Atomics.add(this.int32, 0, 1); Atomics.store(this.int32, 1,
status); Atomics.store(this.int32, 2, value); Atomics.add(this.int32, 0, 1); }
readState() { let seq1, seq2, status, value; do { seq1 = Atomics.load(this.int3
2, 0); if (seq1 % 2 !== 0) continue; status = Atomics.load(this.int32, 1);
value = Atomics.load(this.int32, 2); seq2 = Atomics.load(this.int32, 0); }
while (seq1 !== seq2); return { status, value }; } } export function
analyze(ast, env = new TypeEnv()) { if (!Array.isArray(ast)) return true;
const [
op, ...args] = ast; if (op === 'let') { const localEnv = new TypeEnv(env); for
(const [varName, expr] of args[0]) { analyze(expr, localEnv);
localEnv.define(varName, 'any'); } return analyze(args[1], localEnv); }
args.forEach(arg => { if (Array.isArray(arg) && arg[0] !== 'quote')
analyze(arg, env); }); return true; } export function compile(ast, bytecode =
[]) { if (!Array.isArray(ast)) { bytecode.push({ op: typeof ast === 'string' ?
Opcodes.LOAD : Opcodes.CONST, val: ast }); return bytecode; } const [op,
...args] = ast; if (op === 'str' || op === 'quote') { bytecode.push({ op:
Opcodes.CONST, val: args[0] }); return bytecode; } if (op === 'array') {
args.forEach(arg => compile(arg, bytecode)); bytecode.push({ op:
Opcodes.ARRAY, val: args.length }); return bytecode; } if (op === 'record') {
for (let i = 0; i < args.length; i += 2) { if (typeof args[i] === 'string')
bytecode.push({ op: Opcodes.CONST, val: args[i] }); else compile(args[i],
bytecode); compile(args[i + 1], bytecode); } bytecode.push({ op:
Opcodes.RECORD, val: args.length / 2 }); return bytecode; } if (op === 'get')
{ compile(args[0], bytecode); if (typeof args[1] === 'string') bytecode.push({
op: Opcodes.CONST, val: args[1] }); else compile(args[1], bytecode);
bytecode.push({ op: Opcodes.GET_IDX }); return bytecode; } if (op ===
'set-idx') { compile(args[0], bytecode); if (typeof args[1] === 'string')
bytecode.push({ op: Opcodes.CONST, val: args[1] }); else compile(args[1],
bytecode); compile(args[2], bytecode); bytecode.push({ op: Opcodes.SET_IDX });
return bytecode; } if (op === 'do') { args.forEach((arg, index) => {
compile(arg, bytecode); if (index < args.length - 1) bytecode.push({ op:
Opcodes.POP }); }); return bytecode; } if (op === 'let') { bytecode.push({ op:
Opcodes.ENTER_SCOPE }); for (const [varName, valueExpr] of args[0]) {
compile(valueExpr, bytecode); bytecode.push({ op: Opcodes.STORE, val: varName
}); } compile(args[1], bytecode); bytecode.push({ op: Opcodes.EXIT_SCOPE });
return bytecode; } if (op === 'try') { const [tryBody, errVar, 
catchBody] = args; const tryInst = { op: Opcodes.TRY, val: null };
bytecode.push(tryInst); compile(tryBody, bytecode); bytecode.push({ op:
Opcodes.END_TRY }); const jmpToEnd = { op: Opcodes.JMP, val: null };
bytecode.push(jmpToEnd); tryInst.val = bytecode.length; bytecode.push({ op:
Opcodes.ENTER_SCOPE }); bytecode.push({ op: Opcodes.STORE, val: errVar });
compile(catchBody, bytecode); bytecode.push({ op: Opcodes.EXIT_SCOPE });
jmpToEnd.val = bytecode.length; return bytecode; } if (op === 'throw') {
compile(args[0], bytecode); bytecode.push({ op: Opcodes.THROW }); return
bytecode; } if (op === 'for') { const [varName, startExpr, endExpr, body] =
args; bytecode.push({ op: Opcodes.ENTER_SCOPE }); compile(startExpr,
bytecode); bytecode.push({ op: Opcodes.STORE, val: varName }); const loopStart
= bytecode.length; bytecode.push({ op: Opcodes.LOAD, val: varName });
compile(endExpr, bytecode); bytecode.push({ op: Opcodes.LTE }); const
jmpFalseInst = { op: Opcodes.JMP_FALSE, val: null }; bytecode.push(jmpFalseInst
); compile(body, bytecode); bytecode.push({ op: Opcodes.POP });
bytecode.push({ op: Opcodes.LOAD, val: varName }, { op: Opcodes.CONST, val: 1
}, { op: Opcodes.ADD }, { op: Opcodes.SET, val: varName }, { op: Opcodes.POP
}); bytecode.push({ op: Opcodes.JMP, val: loopStart }); jmpFalseInst.val =
bytecode.length; bytecode.push({ op: Opcodes.EXIT_SCOPE }, { op:
Opcodes.CONST, val: null }); return bytecode; } if (op === 'if') {
compile(args[0], bytecode); const jmpFalse = { op: Opcodes.JMP_FALSE, val:
null }; bytecode.push(jmpFalse); compile(args[1], bytecode); const jmp = { op:
Opcodes.JMP, val: null }; bytecode.push(jmp); jmpFalse.val = bytecode.length;
compile(args[2], bytecode); jmp.val = bytecode.length; return bytecode; }
args.forEach(arg => compile(arg, bytecode)); const opMap = { '+': Opcodes.ADD,
'=': Opcodes.EQ, 'cons': Opcodes.CONS, 'register-isr': Opcodes.REGISTER_ISR };
if (opMap[op]) { bytecode.push({ op: opMap[op] }); } else { bytecode.push({
op: Opcodes.LOAD, val: op }, { op: Opcodes.CALL, argCount: ar
gs.length }); } return bytecode; } export function executeVMWorker(mainBytecode
, stateBuffer, gasLimit, onComplete) { const dataStack = []; const globalEnv =
new Env(); const callStack = [{ ip: 0, code: mainBytecode, env: globalEnv }];
const tryStack = []; let isrCodeObject = null; let instructionsRun = 0;
stateBuffer.writeState(1, 0); const handleThrow = (errorMsg) => { if
(tryStack.length === 0) { onComplete({ type: 'uncaught_error', data: errorMsg
}); stateBuffer.writeState(4, 0); return false; } const recovery =
tryStack.pop(); callStack.length = recovery.callDepth; dataStack.length =
recovery.dataDepth; const currentFrame = callStack[callStack.length - 1];
currentFrame.ip = recovery.catchIp; currentFrame.env = recovery.env;
dataStack.push(errorMsg); return true; }; while (callStack.length > 0) { if
(instructionsRun++ >= gasLimit) { onComplete({ type: 'out_of_gas', data:
dataStack[dataStack.length - 1] }); stateBuffer.writeState(3, 0); return; } if
(instructionsRun % 10 === 0) { const interruptSignal = Atomics.load(stateBuffer
.int32, 3); if (interruptSignal > 0) { Atomics.store(stateBuffer.int32, 3, 0);
if (isrCodeObject) { dataStack.push(interruptSignal); const isrEnv = new
Env(isrCodeObject.closureEnv); isrEnv.define(isrCodeObject.params[0],
dataStack.pop()); callStack.push({ ip: 0, code: isrCodeObject.code, env:
isrEnv }); continue; } else { onComplete({ type: 'interrupted', data:
interruptSignal }); stateBuffer.writeState(5, interruptSignal); return; } } }
const frame = callStack[callStack.length - 1]; if (frame.ip >=
frame.code.length) { callStack.pop(); continue; } const inst =
frame.code[frame.ip++]; switch (inst.op) { case Opcodes.CONST:
dataStack.push(inst.val); break; case Opcodes.LOAD: dataStack.push(frame.env.ge
t(inst.val)); break; case Opcodes.STORE: frame.env.define(inst.val,
dataStack.pop()); break; case Opcodes.SET: { const v = dataStack.pop();
frame.env.set(inst.val, v); dataStack.push(v); break; } case Opcodes.ENTER_SCOP
E: frame.env = new Env(frame.env); break; case Opcodes.EXIT_SCOPE: frame
.env = frame.env.parent; break; case Opcodes.JMP_FALSE: if (!dataStack.pop())
frame.ip = inst.val; break; case Opcodes.JMP: frame.ip = inst.val; break; case
Opcodes.POP: dataStack.pop(); break; case Opcodes.ARRAY: { const arr = new
Array(inst.val); for (let i = inst.val - 1; i >= 0; i--) arr[i] =
dataStack.pop(); dataStack.push(arr); break; } case Opcodes.RECORD: { const
rec = {}; for (let i = 0; i < inst.val; i++) { const v = dataStack.pop();
const k = dataStack.pop(); rec[k] = v; } dataStack.push(rec); break; } case
Opcodes.GET_IDX: { const k = dataStack.pop(); const t = dataStack.pop();
dataStack.push(t[k]); break; } case Opcodes.SET_IDX: { const v =
dataStack.pop(); const k = dataStack.pop(); const t = dataStack.pop(); t[k] =
v; dataStack.push(v); break; } case Opcodes.CONS: { const arr =
dataStack.pop(); const item = dataStack.pop(); dataStack.push([item, ...arr]);
break; } case Opcodes.TRY: tryStack.push({ catchIp: inst.val, callDepth:
callStack.length, dataDepth: dataStack.length, env: frame.env }); break; case
Opcodes.END_TRY: tryStack.pop(); break; case Opcodes.THROW: { const customErr
= dataStack.pop(); if (!handleThrow(customErr)) return; break; } case
Opcodes.ADD: dataStack.push(dataStack.pop() + dataStack.pop()); break; case
Opcodes.EQ: dataStack.push(dataStack.pop() === dataStack.pop()); break; case
Opcodes.LTE: { const r = dataStack.pop(); dataStack.push(dataStack.pop() <=
r); break; } case Opcodes.REGISTER_ISR: isrCodeObject = dataStack.pop();
break; } } onComplete({ type: 'completed', data: dataStack.pop() });
stateBuffer.writeState(2, 0); } 
 // node_worker.mjs import { workerData, parentPort } from 'worker_threads';
import { executeVMWorker, StateBuffer } from './engine.mjs'; if (workerData) {
const stateBuffer = new StateBuffer(workerData.sab); executeVMWorker(
workerData.bytecode, stateBuffer, workerData.gasLimit, (msg) =>
parentPort.postMessage(msg) // Pass the result back to the Main Thread
); }