cvm-server 0.10.0 → 0.12.0

package/main.cjs

@@ -2,9 +2,9 @@
 const mcp_js = require("@modelcontextprotocol/sdk/server/mcp.js");
 const stdio_js = require("@modelcontextprotocol/sdk/server/stdio.js");
 const zod = require("zod");
-const i$2 = require("typescript");
-const M$2 = require("fs");
-const c$1 = require("path");
+const s$1 = require("typescript");
+const b$2 = require("fs");
+const r = require("path");
 const mongodb = require("mongodb");
 const promises = require("fs/promises");
 const dotenv = require("dotenv");
@@ -26,47 +26,47 @@ function _interopNamespaceDefault(e2) {
   n2.default = e2;
   return Object.freeze(n2);
 }
-const i__namespace = /* @__PURE__ */ _interopNamespaceDefault(i$2);
-const M__namespace = /* @__PURE__ */ _interopNamespaceDefault(M$2);
-const c__namespace = /* @__PURE__ */ _interopNamespaceDefault(c$1);
+const s__namespace = /* @__PURE__ */ _interopNamespaceDefault(s$1);
+const b__namespace = /* @__PURE__ */ _interopNamespaceDefault(b$2);
+const r__namespace = /* @__PURE__ */ _interopNamespaceDefault(r);
 const dotenv__namespace = /* @__PURE__ */ _interopNamespaceDefault(dotenv);
-var f$1 = Object.defineProperty;
-var p$1 = (e2, t2, s2) => t2 in e2 ? f$1(e2, t2, { enumerable: true, configurable: true, writable: true, value: s2 }) : e2[t2] = s2;
-var T$1 = (e2, t2, s2) => p$1(e2, typeof t2 != "symbol" ? t2 + "" : t2, s2);
-var n$1 = /* @__PURE__ */ ((e2) => (e2.PUSH = "PUSH", e2.PUSH_UNDEFINED = "PUSH_UNDEFINED", e2.POP = "POP", e2.LOAD = "LOAD", e2.STORE = "STORE", e2.CONCAT = "CONCAT", e2.ARRAY_NEW = "ARRAY_NEW", e2.ARRAY_PUSH = "ARRAY_PUSH", e2.ARRAY_GET = "ARRAY_GET", e2.ARRAY_SET = "ARRAY_SET", e2.ARRAY_LEN = "ARRAY_LEN", e2.STRING_LEN = "STRING_LEN", e2.STRING_SUBSTRING = "STRING_SUBSTRING", e2.STRING_INDEXOF = "STRING_INDEXOF", e2.STRING_SPLIT = "STRING_SPLIT", e2.STRING_SLICE = "STRING_SLICE", e2.STRING_CHARAT = "STRING_CHARAT", e2.STRING_TOUPPERCASE = "STRING_TOUPPERCASE", e2.STRING_TOLOWERCASE = "STRING_TOLOWERCASE", e2.LENGTH = "LENGTH", e2.TO_STRING = "TO_STRING", e2.JSON_PARSE = "JSON_PARSE", e2.TYPEOF = "TYPEOF", e2.ADD = "ADD", e2.SUB = "SUB", e2.MUL = "MUL", e2.DIV = "DIV", e2.MOD = "MOD", e2.UNARY_MINUS = "UNARY_MINUS", e2.UNARY_PLUS = "UNARY_PLUS", e2.INC = "INC", e2.DEC = "DEC", e2.EQ = "EQ", e2.NEQ = "NEQ", e2.LT = "LT", e2.GT = "GT", e2.LTE = "LTE", e2.GTE = "GTE", e2.EQ_STRICT = "EQ_STRICT", e2.NEQ_STRICT = "NEQ_STRICT", e2.JUMP = "JUMP", e2.JUMP_IF = "JUMP_IF", e2.JUMP_IF_FALSE = "JUMP_IF_FALSE", e2.JUMP_IF_TRUE = "JUMP_IF_TRUE", e2.CALL = "CALL", e2.RETURN = "RETURN", e2.AND = "AND", e2.OR = "OR", e2.NOT = "NOT", e2.BREAK = "BREAK", e2.CONTINUE = "CONTINUE", e2.ITER_START = "ITER_START", e2.ITER_NEXT = "ITER_NEXT", e2.ITER_END = "ITER_END", e2.FS_LIST_FILES = "FS_LIST_FILES", e2.OBJECT_CREATE = "OBJECT_CREATE", e2.PROPERTY_GET = "PROPERTY_GET", e2.PROPERTY_SET = "PROPERTY_SET", e2.JSON_STRINGIFY = "JSON_STRINGIFY", e2.CC = "CC", e2.PRINT = "PRINT", e2.HALT = "HALT", e2))(n$1 || {});
+var E$1 = Object.defineProperty;
+var f$2 = (e2, t2, i2) => t2 in e2 ? E$1(e2, t2, { enumerable: true, configurable: true, writable: true, value: i2 }) : e2[t2] = i2;
+var u$2 = (e2, t2, i2) => f$2(e2, typeof t2 != "symbol" ? t2 + "" : t2, i2);
+var n = /* @__PURE__ */ ((e2) => (e2.PUSH = "PUSH", e2.PUSH_UNDEFINED = "PUSH_UNDEFINED", e2.POP = "POP", e2.DUP = "DUP", e2.DUP2 = "DUP2", e2.SWAP = "SWAP", e2.LOAD = "LOAD", e2.STORE = "STORE", e2.CONCAT = "CONCAT", e2.ARRAY_NEW = "ARRAY_NEW", e2.ARRAY_PUSH = "ARRAY_PUSH", e2.ARRAY_GET = "ARRAY_GET", e2.ARRAY_SET = "ARRAY_SET", e2.ARRAY_LEN = "ARRAY_LEN", e2.ARRAY_MAP_PROP = "ARRAY_MAP_PROP", e2.ARRAY_FILTER_PROP = "ARRAY_FILTER_PROP", e2.STRING_LEN = "STRING_LEN", e2.STRING_SUBSTRING = "STRING_SUBSTRING", e2.STRING_INDEXOF = "STRING_INDEXOF", e2.STRING_SPLIT = "STRING_SPLIT", e2.STRING_SLICE = "STRING_SLICE", e2.STRING_CHARAT = "STRING_CHARAT", e2.STRING_TOUPPERCASE = "STRING_TOUPPERCASE", e2.STRING_TOLOWERCASE = "STRING_TOLOWERCASE", e2.LENGTH = "LENGTH", e2.TO_STRING = "TO_STRING", e2.JSON_PARSE = "JSON_PARSE", e2.TYPEOF = "TYPEOF", e2.ADD = "ADD", e2.SUB = "SUB", e2.MUL = "MUL", e2.DIV = "DIV", e2.MOD = "MOD", e2.UNARY_MINUS = "UNARY_MINUS", e2.UNARY_PLUS = "UNARY_PLUS", e2.INC = "INC", e2.DEC = "DEC", e2.EQ = "EQ", e2.NEQ = "NEQ", e2.LT = "LT", e2.GT = "GT", e2.LTE = "LTE", e2.GTE = "GTE", e2.EQ_STRICT = "EQ_STRICT", e2.NEQ_STRICT = "NEQ_STRICT", e2.JUMP = "JUMP", e2.JUMP_IF = "JUMP_IF", e2.JUMP_IF_FALSE = "JUMP_IF_FALSE", e2.JUMP_IF_TRUE = "JUMP_IF_TRUE", e2.CALL = "CALL", e2.RETURN = "RETURN", e2.AND = "AND", e2.OR = "OR", e2.NOT = "NOT", e2.BREAK = "BREAK", e2.CONTINUE = "CONTINUE", e2.ITER_START = "ITER_START", e2.ITER_NEXT = "ITER_NEXT", e2.ITER_END = "ITER_END", e2.FS_LIST_FILES = "FS_LIST_FILES", e2.FS_READ_FILE = "FS_READ_FILE", e2.FS_WRITE_FILE = "FS_WRITE_FILE", e2.OBJECT_CREATE = "OBJECT_CREATE", e2.PROPERTY_GET = "PROPERTY_GET", e2.PROPERTY_SET = "PROPERTY_SET", e2.JSON_STRINGIFY = "JSON_STRINGIFY", e2.GET = "GET", e2.SET = "SET", e2.CC = "CC", e2.PRINT = "PRINT", e2.HALT = "HALT", e2))(n || {});
 function R(e2) {
-  const t2 = [], s2 = [];
-  let r = false;
-  const a2 = i__namespace.createSourceFile(
+  const t2 = [], i2 = [];
+  let r2 = false;
+  const a2 = s__namespace.createSourceFile(
     "program.ts",
     e2,
-    i__namespace.ScriptTarget.Latest,
+    s__namespace.ScriptTarget.Latest,
     true
   );
-  function S(c2) {
-    if (i__namespace.isFunctionDeclaration(c2) && c2.name && c2.name.text === "main" && (r = true, c2.parameters.length > 0 && t2.push("main() must not have parameters")), i__namespace.isCallExpression(c2) && i__namespace.isIdentifier(c2.expression)) {
-      const o2 = c2.expression.text;
-      ["setTimeout", "fetch", "require", "import"].includes(o2) && t2.push(`Unsupported function: ${o2}`);
+  function m2(o2) {
+    if (s__namespace.isFunctionDeclaration(o2) && o2.name && o2.name.text === "main" && (r2 = true, o2.parameters.length > 0 && t2.push("main() must not have parameters")), s__namespace.isCallExpression(o2) && s__namespace.isIdentifier(o2.expression)) {
+      const S = o2.expression.text;
+      ["setTimeout", "fetch", "require", "import"].includes(S) && t2.push(`Unsupported function: ${S}`);
     }
-    i__namespace.forEachChild(c2, S);
+    s__namespace.forEachChild(o2, m2);
   }
-  return S(a2), r || t2.push("Program must have a main() function"), t2.length === 0 && s2.push({ op: n$1.HALT }), {
-    bytecode: s2,
+  return m2(a2), r2 || t2.push("Program must have a main() function"), t2.length === 0 && i2.push({ op: n.HALT }), {
+    bytecode: i2,
     errors: t2,
-    hasMain: r
+    hasMain: r2
   };
 }
-let A$1 = class A {
+let p$2 = class p {
   constructor() {
-    T$1(this, "bytecode", []);
-    T$1(this, "contextStack", []);
+    u$2(this, "bytecode", []);
+    u$2(this, "contextStack", []);
   }
   /**
    * Emit an instruction and return its index
    */
-  emit(t2, s2) {
-    const r = this.bytecode.length;
-    return this.bytecode.push({ op: t2, arg: s2 }), r;
+  emit(t2, i2) {
+    const r2 = this.bytecode.length;
+    return this.bytecode.push({ op: t2, arg: i2 }), r2;
   }
   /**
    * Get the current address (next instruction index)
@@ -77,14 +77,14 @@ let A$1 = class A {
   /**
    * Patch a jump instruction with the target address
    */
-  patchJump(t2, s2) {
-    t2 >= 0 && t2 < this.bytecode.length && (this.bytecode[t2].arg = s2);
+  patchJump(t2, i2) {
+    t2 >= 0 && t2 < this.bytecode.length && (this.bytecode[t2].arg = i2);
   }
   /**
    * Patch multiple jump instructions with the same target
    */
-  patchJumps(t2, s2) {
-    t2.forEach((r) => this.patchJump(r, s2));
+  patchJumps(t2, i2) {
+    t2.forEach((r2) => this.patchJump(r2, i2));
   }
   /**
    * Push a new jump context onto the stack
@@ -109,9 +109,9 @@ let A$1 = class A {
    */
   findLoopContext() {
     for (let t2 = this.contextStack.length - 1; t2 >= 0; t2--) {
-      const s2 = this.contextStack[t2];
-      if (s2.type === "loop" || s2.type === "foreach")
-        return s2;
+      const i2 = this.contextStack[t2];
+      if (i2.type === "loop" || i2.type === "foreach")
+        return i2;
     }
     return null;
   }
@@ -134,423 +134,469 @@ let A$1 = class A {
     return [...this.contextStack];
   }
 };
-const P$1 = (e2, t2, { compileExpression: s2, compileStatement: r }) => {
-  s2(e2.expression);
-  const a2 = t2.emit(n$1.JUMP_IF_FALSE, -1), S = {
+const A$1 = (e2, t2, { compileExpression: i2, compileStatement: r2 }) => {
+  i2(e2.expression);
+  const a2 = t2.emit(n.JUMP_IF_FALSE, -1), m2 = {
     type: "if",
     endTargets: []
   };
-  if (e2.elseStatement ? S.elseTarget = a2 : S.endTargets.push(a2), t2.pushContext(S), r(e2.thenStatement), e2.elseStatement) {
-    const o2 = t2.emit(n$1.JUMP, -1);
-    S.endTargets.push(o2);
-    const m2 = t2.currentAddress();
-    t2.patchJump(a2, m2), r(e2.elseStatement);
-  }
-  const c2 = t2.popContext();
-  if (c2) {
-    const o2 = t2.currentAddress();
-    t2.patchJumps(c2.endTargets, o2);
-  }
-}, I = (e2, t2, { compileExpression: s2, compileStatement: r }) => {
+  if (e2.elseStatement ? m2.elseTarget = a2 : m2.endTargets.push(a2), t2.pushContext(m2), r2(e2.thenStatement), e2.elseStatement) {
+    const S = t2.emit(n.JUMP, -1);
+    m2.endTargets.push(S);
+    const c2 = t2.currentAddress();
+    t2.patchJump(a2, c2), r2(e2.elseStatement);
+  }
+  const o2 = t2.popContext();
+  if (o2) {
+    const S = t2.currentAddress();
+    t2.patchJumps(o2.endTargets, S);
+  }
+}, P$1 = (e2, t2, { compileExpression: i2, compileStatement: r2 }) => {
   const a2 = t2.currentAddress();
-  s2(e2.expression);
-  const c2 = {
+  i2(e2.expression);
+  const o2 = {
     type: "loop",
-    breakTargets: [t2.emit(n$1.JUMP_IF_FALSE, -1)],
+    breakTargets: [t2.emit(n.JUMP_IF_FALSE, -1)],
     continueTargets: [],
     endTargets: [],
     startAddress: a2
   };
-  t2.pushContext(c2), r(e2.statement), t2.emit(n$1.JUMP, a2);
-  const o2 = t2.popContext();
-  if (o2) {
-    const m2 = t2.currentAddress();
-    t2.patchJumps(o2.breakTargets || [], m2);
-  }
-}, h$2 = (e2, t2, { compileExpression: s2, compileStatement: r }) => {
-  const a2 = e2.initializer, S = e2.expression;
-  let c2;
-  if (i__namespace.isVariableDeclarationList(a2))
-    c2 = a2.declarations[0].name.getText();
-  else if (i__namespace.isIdentifier(a2))
-    c2 = a2.text;
+  t2.pushContext(o2), r2(e2.statement), t2.emit(n.JUMP, a2);
+  const S = t2.popContext();
+  if (S) {
+    const c2 = t2.currentAddress();
+    t2.patchJumps(S.breakTargets || [], c2);
+  }
+}, h$1 = (e2, t2, { compileExpression: i2, compileStatement: r2 }) => {
+  const a2 = e2.initializer, m2 = e2.expression;
+  let o2;
+  if (s__namespace.isVariableDeclarationList(a2))
+    o2 = a2.declarations[0].name.getText();
+  else if (s__namespace.isIdentifier(a2))
+    o2 = a2.text;
   else
     throw new Error("Unsupported for-of variable declaration");
-  s2(S), t2.emit(n$1.ITER_START);
-  const o2 = t2.currentAddress();
-  t2.emit(n$1.ITER_NEXT);
-  const m2 = t2.emit(n$1.JUMP_IF_FALSE, -1);
-  t2.emit(n$1.STORE, c2);
+  i2(m2), t2.emit(n.ITER_START);
+  const S = t2.currentAddress();
+  t2.emit(n.ITER_NEXT);
+  const c2 = t2.emit(n.JUMP_IF_FALSE, -1);
+  t2.emit(n.STORE, o2);
   const l2 = {
     type: "foreach",
-    breakTargets: [m2],
+    breakTargets: [c2],
     continueTargets: [],
     endTargets: [],
-    startAddress: o2,
-    iterVariable: c2
+    startAddress: S,
+    iterVariable: o2
   };
-  t2.pushContext(l2), r(e2.statement), t2.emit(n$1.JUMP, o2);
-  const u2 = t2.popContext();
-  if (u2) {
-    const E2 = t2.currentAddress();
-    t2.patchJumps(u2.breakTargets || [], E2), t2.emit(n$1.ITER_END);
-  }
-}, y$1 = (e2, t2, { compileStatement: s2 }) => {
-  e2.statements.forEach((r) => {
-    s2(r);
+  t2.pushContext(l2), r2(e2.statement), t2.emit(n.JUMP, S);
+  const T = t2.popContext();
+  if (T) {
+    const x2 = t2.currentAddress();
+    t2.patchJumps(T.breakTargets || [], x2), t2.emit(n.ITER_END);
+  }
+}, I = (e2, t2, { compileStatement: i2 }) => {
+  e2.statements.forEach((r2) => {
+    i2(r2);
   });
-}, N$1 = (e2, t2, { compileExpression: s2 }) => {
-  const r = e2.declarationList.declarations[0];
-  r.initializer && (s2(r.initializer), t2.emit(n$1.STORE, r.name.getText()));
-}, _$1 = (e2, t2, { compileExpression: s2 }) => {
-  const r = e2.expression;
-  if (i__namespace.isBinaryExpression(r)) {
-    const a2 = r.operatorToken.kind;
-    if (a2 === i__namespace.SyntaxKind.PlusEqualsToken || a2 === i__namespace.SyntaxKind.MinusEqualsToken || a2 === i__namespace.SyntaxKind.AsteriskEqualsToken || a2 === i__namespace.SyntaxKind.SlashEqualsToken || a2 === i__namespace.SyntaxKind.PercentEqualsToken) {
-      if (i__namespace.isIdentifier(r.left)) {
-        switch (t2.emit(n$1.LOAD, r.left.text), s2(r.right), a2) {
-          case i__namespace.SyntaxKind.PlusEqualsToken:
-            i__namespace.isStringLiteral(r.right) ? t2.emit(n$1.CONCAT) : t2.emit(n$1.ADD);
+}, _$1 = (e2, t2, { compileExpression: i2 }) => {
+  const r2 = e2.declarationList.declarations[0];
+  r2.initializer && (i2(r2.initializer), t2.emit(n.STORE, r2.name.getText()));
+}, g = (e2, t2, { compileExpression: i2 }) => {
+  const r2 = e2.expression;
+  if (s__namespace.isBinaryExpression(r2)) {
+    const a2 = r2.operatorToken.kind;
+    if (a2 === s__namespace.SyntaxKind.PlusEqualsToken || a2 === s__namespace.SyntaxKind.MinusEqualsToken || a2 === s__namespace.SyntaxKind.AsteriskEqualsToken || a2 === s__namespace.SyntaxKind.SlashEqualsToken || a2 === s__namespace.SyntaxKind.PercentEqualsToken) {
+      if (s__namespace.isIdentifier(r2.left)) {
+        switch (t2.emit(n.LOAD, r2.left.text), i2(r2.right), a2) {
+          case s__namespace.SyntaxKind.PlusEqualsToken:
+            t2.emit(n.ADD);
             break;
-          case i__namespace.SyntaxKind.MinusEqualsToken:
-            t2.emit(n$1.SUB);
+          case s__namespace.SyntaxKind.MinusEqualsToken:
+            t2.emit(n.SUB);
             break;
-          case i__namespace.SyntaxKind.AsteriskEqualsToken:
-            t2.emit(n$1.MUL);
+          case s__namespace.SyntaxKind.AsteriskEqualsToken:
+            t2.emit(n.MUL);
             break;
-          case i__namespace.SyntaxKind.SlashEqualsToken:
-            t2.emit(n$1.DIV);
+          case s__namespace.SyntaxKind.SlashEqualsToken:
+            t2.emit(n.DIV);
             break;
-          case i__namespace.SyntaxKind.PercentEqualsToken:
-            t2.emit(n$1.MOD);
+          case s__namespace.SyntaxKind.PercentEqualsToken:
+            t2.emit(n.MOD);
             break;
         }
-        t2.emit(n$1.STORE, r.left.text);
-      } else if (i__namespace.isElementAccessExpression(r.left))
+        t2.emit(n.STORE, r2.left.text);
+      } else if (s__namespace.isElementAccessExpression(r2.left))
         throw new Error("Compound assignment to array elements not yet supported");
       return;
-    } else if (a2 === i__namespace.SyntaxKind.EqualsToken) {
-      if (s2(r.right), i__namespace.isIdentifier(r.left))
-        t2.emit(n$1.STORE, r.left.text);
-      else if (i__namespace.isElementAccessExpression(r.left)) {
-        const S = `__temp_${t2.getBytecode().length}`;
-        t2.emit(n$1.STORE, S), s2(r.left.expression), s2(r.left.argumentExpression), t2.emit(n$1.LOAD, S), t2.emit(n$1.ARRAY_SET), t2.emit(n$1.POP);
-      } else if (i__namespace.isPropertyAccessExpression(r.left)) {
-        const S = `__temp_${t2.getBytecode().length}`;
-        t2.emit(n$1.STORE, S), s2(r.left.expression), t2.emit(n$1.PUSH, r.left.name.text), t2.emit(n$1.LOAD, S), t2.emit(n$1.PROPERTY_SET), t2.emit(n$1.POP);
+    } else if (a2 === s__namespace.SyntaxKind.EqualsToken) {
+      if (i2(r2.right), s__namespace.isIdentifier(r2.left))
+        t2.emit(n.STORE, r2.left.text);
+      else if (s__namespace.isElementAccessExpression(r2.left)) {
+        const m2 = `__temp_${t2.getBytecode().length}`;
+        t2.emit(n.STORE, m2), i2(r2.left.expression), i2(r2.left.argumentExpression), t2.emit(n.LOAD, m2), t2.emit(n.ARRAY_SET), t2.emit(n.POP);
+      } else if (s__namespace.isPropertyAccessExpression(r2.left)) {
+        const m2 = `__temp_${t2.getBytecode().length}`;
+        t2.emit(n.STORE, m2), i2(r2.left.expression), t2.emit(n.PUSH, r2.left.name.text), t2.emit(n.LOAD, m2), t2.emit(n.PROPERTY_SET), t2.emit(n.POP);
       }
       return;
     }
   }
-  i__namespace.isCallExpression(r) && i__namespace.isPropertyAccessExpression(r.expression) && r.expression.expression.getText() === "console" && r.expression.name.getText() === "log" ? (r.arguments.forEach((a2) => {
-    s2(a2);
-  }), t2.emit(n$1.PRINT)) : i__namespace.isCallExpression(r) && i__namespace.isIdentifier(r.expression) && r.expression.text === "CC" ? (r.arguments.length > 0 && s2(r.arguments[0]), t2.emit(n$1.CC), t2.emit(n$1.POP)) : i__namespace.isCallExpression(r) && i__namespace.isPropertyAccessExpression(r.expression) && r.expression.name.getText() === "push" ? (s2(r.expression.expression), r.arguments.length > 0 && s2(r.arguments[0]), t2.emit(n$1.ARRAY_PUSH)) : (i__namespace.isPostfixUnaryExpression(r) || i__namespace.isPrefixUnaryExpression(r)) && (s2(r), t2.emit(n$1.POP));
-}, g$1 = (e2, t2, { compileExpression: s2 }) => {
-  e2.expression ? s2(e2.expression) : t2.emit(n$1.PUSH, null), t2.emit(n$1.RETURN);
-}, k = (e2, t2, s2) => {
-  const r = t2.findLoopContext();
-  if (r) {
-    r.type === "foreach" && t2.emit(n$1.ITER_END);
-    const a2 = t2.emit(n$1.BREAK, -1);
-    r.breakTargets = r.breakTargets || [], r.breakTargets.push(a2);
+  s__namespace.isCallExpression(r2) && s__namespace.isPropertyAccessExpression(r2.expression) && r2.expression.expression.getText() === "console" && r2.expression.name.getText() === "log" ? (r2.arguments.forEach((a2) => {
+    i2(a2);
+  }), t2.emit(n.PRINT)) : s__namespace.isCallExpression(r2) && s__namespace.isIdentifier(r2.expression) && r2.expression.text === "CC" ? (r2.arguments.length > 0 && i2(r2.arguments[0]), t2.emit(n.CC), t2.emit(n.POP)) : s__namespace.isCallExpression(r2) && s__namespace.isPropertyAccessExpression(r2.expression) && r2.expression.name.getText() === "push" ? (i2(r2.expression.expression), r2.arguments.length > 0 && i2(r2.arguments[0]), t2.emit(n.ARRAY_PUSH)) : (s__namespace.isPostfixUnaryExpression(r2) || s__namespace.isPrefixUnaryExpression(r2), i2(r2), t2.emit(n.POP));
+}, y$1 = (e2, t2, { compileExpression: i2 }) => {
+  e2.expression ? i2(e2.expression) : t2.emit(n.PUSH, null), t2.emit(n.RETURN);
+}, N = (e2, t2, i2) => {
+  const r2 = t2.findLoopContext();
+  if (r2) {
+    r2.type === "foreach" && t2.emit(n.ITER_END);
+    const a2 = t2.emit(n.BREAK, -1);
+    r2.breakTargets = r2.breakTargets || [], r2.breakTargets.push(a2);
   } else
-    throw new Error("break statement not in loop");
-}, U = (e2, t2, s2) => {
-  const r = t2.findLoopContext();
-  if (r && r.startAddress !== void 0) {
-    const a2 = t2.emit(n$1.CONTINUE, r.startAddress);
-    r.continueTargets = r.continueTargets || [], r.continueTargets.push(a2);
+    i2.reportError(e2, "break statement not in loop");
+}, U = (e2, t2, i2) => {
+  const r2 = t2.findLoopContext();
+  if (r2 && r2.startAddress !== void 0) {
+    const a2 = t2.emit(n.CONTINUE, r2.startAddress);
+    r2.continueTargets = r2.continueTargets || [], r2.continueTargets.push(a2);
   } else
-    throw new Error("continue statement not in loop");
-}, L$1 = {
-  [i__namespace.SyntaxKind.IfStatement]: P$1,
-  [i__namespace.SyntaxKind.WhileStatement]: I,
-  [i__namespace.SyntaxKind.ForOfStatement]: h$2,
-  [i__namespace.SyntaxKind.Block]: y$1,
-  [i__namespace.SyntaxKind.VariableStatement]: N$1,
-  [i__namespace.SyntaxKind.ExpressionStatement]: _$1,
-  [i__namespace.SyntaxKind.ReturnStatement]: g$1,
-  [i__namespace.SyntaxKind.BreakStatement]: k,
-  [i__namespace.SyntaxKind.ContinueStatement]: U
-}, K = (e2, t2, s2) => {
-  t2.emit(n$1.PUSH, e2.text);
-}, d$1 = (e2, t2, s2) => {
-  t2.emit(n$1.PUSH, Number(e2.text));
-}, b$2 = (e2, t2, s2) => {
-  t2.emit(n$1.PUSH, true);
-}, F$1 = (e2, t2, s2) => {
-  t2.emit(n$1.PUSH, false);
-}, G$1 = (e2, t2, s2) => {
-  t2.emit(n$1.PUSH, null);
-}, D$1 = (e2, t2, s2) => {
-  e2.text === "undefined" ? t2.emit(n$1.PUSH_UNDEFINED) : t2.emit(n$1.LOAD, e2.text);
-}, H$1 = (e2, t2, { compileExpression: s2 }) => {
-  t2.emit(n$1.ARRAY_NEW), e2.elements.forEach((r) => {
-    s2(r), t2.emit(n$1.ARRAY_PUSH);
+    i2.reportError(e2, "continue statement not in loop");
+}, k = {
+  [s__namespace.SyntaxKind.IfStatement]: A$1,
+  [s__namespace.SyntaxKind.WhileStatement]: P$1,
+  [s__namespace.SyntaxKind.ForOfStatement]: h$1,
+  [s__namespace.SyntaxKind.Block]: I,
+  [s__namespace.SyntaxKind.VariableStatement]: _$1,
+  [s__namespace.SyntaxKind.ExpressionStatement]: g,
+  [s__namespace.SyntaxKind.ReturnStatement]: y$1,
+  [s__namespace.SyntaxKind.BreakStatement]: N,
+  [s__namespace.SyntaxKind.ContinueStatement]: U
+}, L = (e2, t2, i2) => {
+  t2.emit(n.PUSH, e2.text);
+}, F$1 = (e2, t2, i2) => {
+  t2.emit(n.PUSH, Number(e2.text));
+}, K$1 = (e2, t2, i2) => {
+  t2.emit(n.PUSH, true);
+}, b$1 = (e2, t2, i2) => {
+  t2.emit(n.PUSH, false);
+}, D$1 = (e2, t2, i2) => {
+  t2.emit(n.PUSH, null);
+}, d$3 = (e2, t2, i2) => {
+  e2.text === "undefined" ? t2.emit(n.PUSH_UNDEFINED) : t2.emit(n.LOAD, e2.text);
+}, G$1 = (e2, t2, { compileExpression: i2 }) => {
+  t2.emit(n.ARRAY_NEW), e2.elements.forEach((r2) => {
+    i2(r2), t2.emit(n.ARRAY_PUSH);
   });
-}, M$1 = (e2, t2, { compileExpression: s2 }) => {
-  s2(e2.expression);
-}, J$1 = (e2, t2, { compileExpression: s2 }) => {
-  e2.name.text === "length" ? (s2(e2.expression), t2.emit(n$1.LENGTH)) : (s2(e2.expression), t2.emit(n$1.PUSH, e2.name.text), t2.emit(n$1.PROPERTY_GET));
-}, Y$1 = (e2, t2, { compileExpression: s2, reportError: r }) => {
-  s2(e2.expression), e2.argumentExpression ? s2(e2.argumentExpression) : r(e2, "Element access requires an index expression"), t2.emit(n$1.ARRAY_GET);
-}, C = (e2, t2, { compileExpression: s2 }) => {
+}, H$1 = (e2, t2, { compileExpression: i2 }) => {
+  i2(e2.expression);
+}, M$2 = (e2, t2, { compileExpression: i2 }) => {
+  e2.name.text === "length" ? (i2(e2.expression), t2.emit(n.LENGTH)) : (i2(e2.expression), t2.emit(n.PUSH, e2.name.text), t2.emit(n.PROPERTY_GET));
+}, Y = (e2, t2, { compileExpression: i2, reportError: r2 }) => {
+  i2(e2.expression), e2.argumentExpression ? i2(e2.argumentExpression) : r2(e2, "Element access requires an index expression"), t2.emit(n.ARRAY_GET);
+}, J = (e2, t2, { compileExpression: i2 }) => {
   switch (e2.operator) {
-    case i__namespace.SyntaxKind.ExclamationToken:
-      s2(e2.operand), t2.emit(n$1.NOT);
+    case s__namespace.SyntaxKind.ExclamationToken:
+      i2(e2.operand), t2.emit(n.NOT);
       break;
-    case i__namespace.SyntaxKind.MinusToken:
-      s2(e2.operand), t2.emit(n$1.UNARY_MINUS);
+    case s__namespace.SyntaxKind.MinusToken:
+      i2(e2.operand), t2.emit(n.UNARY_MINUS);
       break;
-    case i__namespace.SyntaxKind.PlusToken:
-      s2(e2.operand), t2.emit(n$1.UNARY_PLUS);
+    case s__namespace.SyntaxKind.PlusToken:
+      i2(e2.operand), t2.emit(n.UNARY_PLUS);
       break;
-    case i__namespace.SyntaxKind.PlusPlusToken:
-      i__namespace.isIdentifier(e2.operand) && (t2.emit(n$1.PUSH, e2.operand.text), t2.emit(n$1.INC, false));
+    case s__namespace.SyntaxKind.PlusPlusToken:
+      s__namespace.isIdentifier(e2.operand) && (t2.emit(n.PUSH, e2.operand.text), t2.emit(n.INC, false));
       break;
-    case i__namespace.SyntaxKind.MinusMinusToken:
-      i__namespace.isIdentifier(e2.operand) && (t2.emit(n$1.PUSH, e2.operand.text), t2.emit(n$1.DEC, false));
+    case s__namespace.SyntaxKind.MinusMinusToken:
+      s__namespace.isIdentifier(e2.operand) && (t2.emit(n.PUSH, e2.operand.text), t2.emit(n.DEC, false));
       break;
   }
-}, w$1 = (e2, t2, { compileExpression: s2 }) => {
+}, w = (e2, t2, { compileExpression: i2 }) => {
   switch (e2.operator) {
-    case i__namespace.SyntaxKind.PlusPlusToken:
-      i__namespace.isIdentifier(e2.operand) && (t2.emit(n$1.PUSH, e2.operand.text), t2.emit(n$1.INC, true));
+    case s__namespace.SyntaxKind.PlusPlusToken:
+      s__namespace.isIdentifier(e2.operand) && (t2.emit(n.PUSH, e2.operand.text), t2.emit(n.INC, true));
       break;
-    case i__namespace.SyntaxKind.MinusMinusToken:
-      i__namespace.isIdentifier(e2.operand) && (t2.emit(n$1.PUSH, e2.operand.text), t2.emit(n$1.DEC, true));
+    case s__namespace.SyntaxKind.MinusMinusToken:
+      s__namespace.isIdentifier(e2.operand) && (t2.emit(n.PUSH, e2.operand.text), t2.emit(n.DEC, true));
       break;
   }
-};
-function x$1(e2, t2) {
-  return !!(i__namespace.isStringLiteral(e2) || i__namespace.isStringLiteral(t2) || i__namespace.isBinaryExpression(e2) && e2.operatorToken.kind === i__namespace.SyntaxKind.PlusToken && x$1(e2.left, e2.right) || i__namespace.isBinaryExpression(t2) && t2.operatorToken.kind === i__namespace.SyntaxKind.PlusToken && x$1(t2.left, t2.right));
-}
-const B$1 = (e2, t2, { compileExpression: s2 }) => {
-  const r = e2.operatorToken.kind;
-  switch (s2(e2.left), s2(e2.right), r) {
-    case i__namespace.SyntaxKind.PlusToken:
-      x$1(e2.left, e2.right) ? t2.emit(n$1.CONCAT) : t2.emit(n$1.ADD);
+}, B$1 = (e2, t2, { compileExpression: i2 }) => {
+  const r2 = e2.operatorToken.kind;
+  switch (i2(e2.left), i2(e2.right), r2) {
+    case s__namespace.SyntaxKind.PlusToken:
+      t2.emit(n.ADD);
       break;
-    case i__namespace.SyntaxKind.MinusToken:
-      t2.emit(n$1.SUB);
+    case s__namespace.SyntaxKind.MinusToken:
+      t2.emit(n.SUB);
       break;
-    case i__namespace.SyntaxKind.AsteriskToken:
-      t2.emit(n$1.MUL);
+    case s__namespace.SyntaxKind.AsteriskToken:
+      t2.emit(n.MUL);
       break;
-    case i__namespace.SyntaxKind.SlashToken:
-      t2.emit(n$1.DIV);
+    case s__namespace.SyntaxKind.SlashToken:
+      t2.emit(n.DIV);
       break;
-    case i__namespace.SyntaxKind.PercentToken:
-      t2.emit(n$1.MOD);
+    case s__namespace.SyntaxKind.PercentToken:
+      t2.emit(n.MOD);
       break;
-    case i__namespace.SyntaxKind.EqualsEqualsToken:
-      t2.emit(n$1.EQ);
+    case s__namespace.SyntaxKind.EqualsEqualsToken:
+      t2.emit(n.EQ);
       break;
-    case i__namespace.SyntaxKind.ExclamationEqualsToken:
-      t2.emit(n$1.NEQ);
+    case s__namespace.SyntaxKind.ExclamationEqualsToken:
+      t2.emit(n.NEQ);
       break;
-    case i__namespace.SyntaxKind.LessThanToken:
-      t2.emit(n$1.LT);
+    case s__namespace.SyntaxKind.LessThanToken:
+      t2.emit(n.LT);
       break;
-    case i__namespace.SyntaxKind.GreaterThanToken:
-      t2.emit(n$1.GT);
+    case s__namespace.SyntaxKind.GreaterThanToken:
+      t2.emit(n.GT);
       break;
-    case i__namespace.SyntaxKind.LessThanEqualsToken:
-      t2.emit(n$1.LTE);
+    case s__namespace.SyntaxKind.LessThanEqualsToken:
+      t2.emit(n.LTE);
       break;
-    case i__namespace.SyntaxKind.GreaterThanEqualsToken:
-      t2.emit(n$1.GTE);
+    case s__namespace.SyntaxKind.GreaterThanEqualsToken:
+      t2.emit(n.GTE);
       break;
-    case i__namespace.SyntaxKind.EqualsEqualsEqualsToken:
-      t2.emit(n$1.EQ_STRICT);
+    case s__namespace.SyntaxKind.EqualsEqualsEqualsToken:
+      t2.emit(n.EQ_STRICT);
       break;
-    case i__namespace.SyntaxKind.ExclamationEqualsEqualsToken:
-      t2.emit(n$1.NEQ_STRICT);
+    case s__namespace.SyntaxKind.ExclamationEqualsEqualsToken:
+      t2.emit(n.NEQ_STRICT);
       break;
-    case i__namespace.SyntaxKind.AmpersandAmpersandToken:
-      t2.emit(n$1.AND);
+    case s__namespace.SyntaxKind.AmpersandAmpersandToken:
+      t2.emit(n.AND);
       break;
-    case i__namespace.SyntaxKind.BarBarToken:
-      t2.emit(n$1.OR);
+    case s__namespace.SyntaxKind.BarBarToken:
+      t2.emit(n.OR);
       break;
   }
-}, q$1 = (e2, t2, { compileExpression: s2 }) => {
-  s2(e2.condition);
-  const r = t2.emit(n$1.JUMP_IF_FALSE, -1);
-  s2(e2.whenTrue);
-  const a2 = t2.emit(n$1.JUMP, -1), S = t2.currentAddress();
-  t2.patchJump(r, S), s2(e2.whenFalse);
-  const c2 = t2.currentAddress();
-  t2.patchJump(a2, c2);
-}, O = (e2, t2, { compileExpression: s2 }) => {
-  s2(e2.expression), t2.emit(n$1.TYPEOF);
-}, V$1 = (e2, t2, { compileExpression: s2 }) => {
-  if (i__namespace.isPropertyAccessExpression(e2.expression) && i__namespace.isIdentifier(e2.expression.expression) && e2.expression.expression.text === "fs" && e2.expression.name.text === "listFiles")
-    e2.arguments.length > 0 ? s2(e2.arguments[0]) : t2.emit(n$1.PUSH, "."), e2.arguments.length > 1 && s2(e2.arguments[1]), t2.emit(n$1.FS_LIST_FILES);
-  else if (i__namespace.isPropertyAccessExpression(e2.expression) && i__namespace.isIdentifier(e2.expression.expression) && e2.expression.expression.text === "JSON" && e2.expression.name.text === "parse")
-    e2.arguments.length > 0 && s2(e2.arguments[0]), t2.emit(n$1.JSON_PARSE);
-  else if (i__namespace.isPropertyAccessExpression(e2.expression) && i__namespace.isIdentifier(e2.expression.expression) && e2.expression.expression.text === "JSON" && e2.expression.name.text === "stringify")
-    e2.arguments.length > 0 ? s2(e2.arguments[0]) : t2.emit(n$1.PUSH_UNDEFINED), t2.emit(n$1.JSON_STRINGIFY);
-  else if (i__namespace.isIdentifier(e2.expression) && e2.expression.text === "CC")
-    e2.arguments.length > 0 && s2(e2.arguments[0]), t2.emit(n$1.CC);
-  else if (i__namespace.isPropertyAccessExpression(e2.expression)) {
-    const r = e2.expression.name.text;
-    if (r === "substring")
-      s2(e2.expression.expression), e2.arguments.length > 0 ? s2(e2.arguments[0]) : t2.emit(n$1.PUSH, 0), e2.arguments.length > 1 && s2(e2.arguments[1]), t2.emit(n$1.STRING_SUBSTRING);
-    else if (r === "indexOf")
-      s2(e2.expression.expression), e2.arguments.length > 0 ? s2(e2.arguments[0]) : t2.emit(n$1.PUSH, ""), t2.emit(n$1.STRING_INDEXOF);
-    else if (r === "split")
-      s2(e2.expression.expression), e2.arguments.length > 0 ? s2(e2.arguments[0]) : t2.emit(n$1.PUSH, ""), t2.emit(n$1.STRING_SPLIT);
-    else if (r === "slice")
-      s2(e2.expression.expression), e2.arguments.length > 0 ? s2(e2.arguments[0]) : t2.emit(n$1.PUSH, 0), e2.arguments.length > 1 && s2(e2.arguments[1]), t2.emit(n$1.STRING_SLICE);
-    else if (r === "charAt")
-      s2(e2.expression.expression), e2.arguments.length > 0 ? s2(e2.arguments[0]) : t2.emit(n$1.PUSH, 0), t2.emit(n$1.STRING_CHARAT);
-    else if (r === "toUpperCase")
-      s2(e2.expression.expression), t2.emit(n$1.STRING_TOUPPERCASE);
-    else if (r === "toLowerCase")
-      s2(e2.expression.expression), t2.emit(n$1.STRING_TOLOWERCASE);
-    else if (r === "toString")
-      s2(e2.expression.expression), t2.emit(n$1.TO_STRING);
+}, q = (e2, t2, { compileExpression: i2 }) => {
+  i2(e2.condition);
+  const r2 = t2.emit(n.JUMP_IF_FALSE, -1);
+  i2(e2.whenTrue);
+  const a2 = t2.emit(n.JUMP, -1), m2 = t2.currentAddress();
+  t2.patchJump(r2, m2), i2(e2.whenFalse);
+  const o2 = t2.currentAddress();
+  t2.patchJump(a2, o2);
+}, C$1 = (e2, t2, { compileExpression: i2 }) => {
+  i2(e2.expression), t2.emit(n.TYPEOF);
+}, O$1 = (e2, t2, { compileExpression: i2, reportError: r2 }) => {
+  if (s__namespace.isPropertyAccessExpression(e2.expression) && s__namespace.isIdentifier(e2.expression.expression) && e2.expression.expression.text === "fs") {
+    const a2 = e2.expression.name.text;
+    if (a2 === "listFiles")
+      e2.arguments.length > 0 ? i2(e2.arguments[0]) : t2.emit(n.PUSH, "."), e2.arguments.length > 1 && i2(e2.arguments[1]), t2.emit(n.FS_LIST_FILES);
+    else if (a2 === "readFile")
+      e2.arguments.length > 0 ? (i2(e2.arguments[0]), t2.emit(n.FS_READ_FILE)) : r2(e2, "fs.readFile() requires a path argument");
+    else if (a2 === "writeFile") {
+      if (e2.arguments.length < 2) {
+        r2(e2, "fs.writeFile() requires path and content arguments");
+        return;
+      }
+      i2(e2.arguments[0]), i2(e2.arguments[1]), t2.emit(n.FS_WRITE_FILE);
+    } else
+      r2(e2, `Unsupported fs method: ${a2}`);
+  } else if (s__namespace.isPropertyAccessExpression(e2.expression) && s__namespace.isIdentifier(e2.expression.expression) && e2.expression.expression.text === "JSON" && e2.expression.name.text === "parse")
+    e2.arguments.length > 0 && i2(e2.arguments[0]), t2.emit(n.JSON_PARSE);
+  else if (s__namespace.isPropertyAccessExpression(e2.expression) && s__namespace.isIdentifier(e2.expression.expression) && e2.expression.expression.text === "JSON" && e2.expression.name.text === "stringify")
+    e2.arguments.length > 0 ? i2(e2.arguments[0]) : t2.emit(n.PUSH_UNDEFINED), t2.emit(n.JSON_STRINGIFY);
+  else if (s__namespace.isIdentifier(e2.expression) && e2.expression.text === "CC")
+    e2.arguments.length > 0 && i2(e2.arguments[0]), t2.emit(n.CC);
+  else if (s__namespace.isPropertyAccessExpression(e2.expression)) {
+    const a2 = e2.expression.name.text;
+    if (a2 === "substring")
+      i2(e2.expression.expression), e2.arguments.length > 0 ? i2(e2.arguments[0]) : t2.emit(n.PUSH, 0), e2.arguments.length > 1 && i2(e2.arguments[1]), t2.emit(n.STRING_SUBSTRING);
+    else if (a2 === "indexOf")
+      i2(e2.expression.expression), e2.arguments.length > 0 ? i2(e2.arguments[0]) : t2.emit(n.PUSH, ""), t2.emit(n.STRING_INDEXOF);
+    else if (a2 === "split")
+      i2(e2.expression.expression), e2.arguments.length > 0 ? i2(e2.arguments[0]) : t2.emit(n.PUSH, ""), t2.emit(n.STRING_SPLIT);
+    else if (a2 === "slice")
+      i2(e2.expression.expression), e2.arguments.length > 0 ? i2(e2.arguments[0]) : t2.emit(n.PUSH, 0), e2.arguments.length > 1 && i2(e2.arguments[1]), t2.emit(n.STRING_SLICE);
+    else if (a2 === "charAt")
+      i2(e2.expression.expression), e2.arguments.length > 0 ? i2(e2.arguments[0]) : t2.emit(n.PUSH, 0), t2.emit(n.STRING_CHARAT);
+    else if (a2 === "toUpperCase")
+      i2(e2.expression.expression), t2.emit(n.STRING_TOUPPERCASE);
+    else if (a2 === "toLowerCase")
+      i2(e2.expression.expression), t2.emit(n.STRING_TOLOWERCASE);
+    else if (a2 === "toString")
+      i2(e2.expression.expression), t2.emit(n.TO_STRING);
     else
-      throw new Error(`Method call '${r}' is not supported`);
+      throw new Error(`Method call '${a2}' is not supported`);
   } else
     throw new Error("Unsupported call expression");
-}, Q = (e2, t2, { compileExpression: s2 }) => {
-  t2.emit(n$1.OBJECT_CREATE);
-  for (const r of e2.properties)
-    if (i__namespace.isPropertyAssignment(r)) {
+}, V = (e2, t2, { compileExpression: i2 }) => {
+  t2.emit(n.OBJECT_CREATE);
+  for (const r2 of e2.properties)
+    if (s__namespace.isPropertyAssignment(r2)) {
       let a2;
-      if (i__namespace.isIdentifier(r.name))
-        a2 = r.name.text;
-      else if (i__namespace.isStringLiteral(r.name))
-        a2 = r.name.text;
+      if (s__namespace.isIdentifier(r2.name))
+        a2 = r2.name.text;
+      else if (s__namespace.isStringLiteral(r2.name))
+        a2 = r2.name.text;
       else
         throw new Error("Computed property names are not supported");
-      t2.emit(n$1.PUSH, a2), s2(r.initializer), t2.emit(n$1.PROPERTY_SET);
-    } else if (i__namespace.isShorthandPropertyAssignment(r)) {
-      const a2 = r.name.text;
-      t2.emit(n$1.PUSH, a2), t2.emit(n$1.LOAD, a2), t2.emit(n$1.PROPERTY_SET);
+      t2.emit(n.PUSH, a2), i2(r2.initializer), t2.emit(n.PROPERTY_SET);
+    } else if (s__namespace.isShorthandPropertyAssignment(r2)) {
+      const a2 = r2.name.text;
+      t2.emit(n.PUSH, a2), t2.emit(n.LOAD, a2), t2.emit(n.PROPERTY_SET);
     } else
       throw new Error("Unsupported property type in object literal");
-}, j$2 = {
-  [i__namespace.SyntaxKind.StringLiteral]: K,
-  [i__namespace.SyntaxKind.NumericLiteral]: d$1,
-  [i__namespace.SyntaxKind.TrueKeyword]: b$2,
-  [i__namespace.SyntaxKind.FalseKeyword]: F$1,
-  [i__namespace.SyntaxKind.NullKeyword]: G$1,
-  [i__namespace.SyntaxKind.Identifier]: D$1,
-  [i__namespace.SyntaxKind.ArrayLiteralExpression]: H$1,
-  [i__namespace.SyntaxKind.BinaryExpression]: B$1,
-  [i__namespace.SyntaxKind.PrefixUnaryExpression]: C,
-  [i__namespace.SyntaxKind.PostfixUnaryExpression]: w$1,
-  [i__namespace.SyntaxKind.CallExpression]: V$1,
-  [i__namespace.SyntaxKind.PropertyAccessExpression]: J$1,
-  [i__namespace.SyntaxKind.ElementAccessExpression]: Y$1,
-  [i__namespace.SyntaxKind.ConditionalExpression]: q$1,
-  [i__namespace.SyntaxKind.TypeOfExpression]: O,
-  [i__namespace.SyntaxKind.ParenthesizedExpression]: M$1,
-  [i__namespace.SyntaxKind.ObjectLiteralExpression]: Q
+}, W$1 = {
+  [s__namespace.SyntaxKind.StringLiteral]: L,
+  [s__namespace.SyntaxKind.NumericLiteral]: F$1,
+  [s__namespace.SyntaxKind.TrueKeyword]: K$1,
+  [s__namespace.SyntaxKind.FalseKeyword]: b$1,
+  [s__namespace.SyntaxKind.NullKeyword]: D$1,
+  [s__namespace.SyntaxKind.Identifier]: d$3,
+  [s__namespace.SyntaxKind.ArrayLiteralExpression]: G$1,
+  [s__namespace.SyntaxKind.BinaryExpression]: B$1,
+  [s__namespace.SyntaxKind.PrefixUnaryExpression]: J,
+  [s__namespace.SyntaxKind.PostfixUnaryExpression]: w,
+  [s__namespace.SyntaxKind.CallExpression]: O$1,
+  [s__namespace.SyntaxKind.PropertyAccessExpression]: M$2,
+  [s__namespace.SyntaxKind.ElementAccessExpression]: Y,
+  [s__namespace.SyntaxKind.ConditionalExpression]: q,
+  [s__namespace.SyntaxKind.TypeOfExpression]: C$1,
+  [s__namespace.SyntaxKind.ParenthesizedExpression]: H$1,
+  [s__namespace.SyntaxKind.ObjectLiteralExpression]: V
 };
-function W$1(e2) {
-  const t2 = R(e2);
-  if (t2.errors.length > 0)
+function j$2(e2) {
+  const t2 = [], i2 = R(e2);
+  if (i2.errors.length > 0)
     return {
       success: false,
       bytecode: [],
-      errors: t2.errors
+      errors: i2.errors.map((c2) => ({
+        message: c2,
+        line: 0,
+        character: 0
+      }))
     };
-  const s2 = new A$1(), r = i__namespace.createSourceFile("program.ts", e2, i__namespace.ScriptTarget.Latest, true), a2 = {
-    compileStatement: S,
-    compileExpression: c2,
-    reportError: (o2, m2) => {
-      throw new Error(m2);
+  const r2 = new p$2(), a2 = s__namespace.createSourceFile("program.ts", e2, s__namespace.ScriptTarget.Latest, true), m2 = {
+    compileStatement: o2,
+    compileExpression: S,
+    reportError: (c2, l2) => {
+      const { line: T, character: x2 } = a2.getLineAndCharacterOfPosition(c2.getStart());
+      throw t2.push({
+        message: l2,
+        line: T + 1,
+        // TypeScript uses 0-based lines
+        character: x2 + 1
+        // TypeScript uses 0-based columns
+      }), new Error(l2);
     }
   };
-  function S(o2) {
-    const m2 = L$1[o2.kind];
-    m2 && m2(o2, s2, a2);
-  }
-  function c2(o2) {
-    const m2 = j$2[o2.kind];
-    m2 && m2(o2, s2, a2);
-  }
-  return r.forEachChild((o2) => {
-    var m2;
-    i__namespace.isFunctionDeclaration(o2) && ((m2 = o2.name) == null ? void 0 : m2.text) === "main" && o2.body && o2.body.statements.forEach((l2) => {
-      S(l2);
+  function o2(c2) {
+    const l2 = k[c2.kind];
+    if (l2)
+      l2(c2, r2, m2);
+    else {
+      const { line: T, character: x2 } = a2.getLineAndCharacterOfPosition(c2.getStart());
+      t2.push({
+        message: `Unsupported statement: ${s__namespace.SyntaxKind[c2.kind]}`,
+        line: T + 1,
+        character: x2 + 1
+      });
+    }
+  }
+  function S(c2) {
+    const l2 = W$1[c2.kind];
+    if (l2)
+      l2(c2, r2, m2);
+    else {
+      const { line: T, character: x2 } = a2.getLineAndCharacterOfPosition(c2.getStart());
+      t2.push({
+        message: `Unsupported expression: ${s__namespace.SyntaxKind[c2.kind]}`,
+        line: T + 1,
+        character: x2 + 1
+      });
+    }
+  }
+  return a2.forEachChild((c2) => {
+    var l2;
+    s__namespace.isFunctionDeclaration(c2) && ((l2 = c2.name) == null ? void 0 : l2.text) === "main" && c2.body && c2.body.statements.forEach((T) => {
+      try {
+        o2(T);
+      } catch {
+      }
     });
-  }), s2.emit(n$1.HALT), {
-    success: true,
-    bytecode: s2.getBytecode(),
-    errors: []
+  }), r2.emit(n.HALT), {
+    success: t2.length === 0,
+    bytecode: r2.getBytecode(),
+    errors: t2
   };
 }
-function n(r) {
-  return typeof r == "string";
+function t(r2) {
+  return typeof r2 == "string";
+}
+function i$1(r2) {
+  return typeof r2 == "number";
 }
-function t(r) {
-  return typeof r == "number";
+function e(r2) {
+  return typeof r2 == "boolean";
 }
-function i$1(r) {
-  return typeof r == "boolean";
+function f$1(r2) {
+  return r2 === null;
 }
-function e(r) {
-  return r === null;
+function o(r2) {
+  return r2 !== null && typeof r2 == "object" && "type" in r2 && r2.type === "array";
 }
-function f(r) {
-  return r !== null && typeof r == "object" && "type" in r && r.type === "array";
+function c(r2) {
+  return r2 !== null && typeof r2 == "object" && "type" in r2 && r2.type === "undefined";
 }
-function o(r) {
-  return r !== null && typeof r == "object" && "type" in r && r.type === "undefined";
+function y(r2) {
+  return r2 !== null && typeof r2 == "object" && "type" in r2 && r2.type === "object";
 }
-function c(r) {
-  return r !== null && typeof r == "object" && "type" in r && r.type === "object";
+function u$1(r2) {
+  return r2 !== null && typeof r2 == "object" && "type" in r2 && r2.type === "array-ref";
 }
-function y(r) {
-  return n(r) ? r : t(r) || i$1(r) ? r.toString() : e(r) ? "null" : o(r) ? "undefined" : f(r) ? `[array:${r.elements.length}]` : c(r) ? "[object Object]" : String(r);
+function b(r2) {
+  return r2 !== null && typeof r2 == "object" && "type" in r2 && r2.type === "object-ref";
 }
-function b$1(r) {
-  return i$1(r) ? r : e(r) || o(r) ? false : t(r) ? r !== 0 : n(r) ? r !== "" : f(r) || c(r) ? true : !!r;
+function p$1(r2) {
+  return t(r2) ? r2 : i$1(r2) || e(r2) ? r2.toString() : f$1(r2) ? "null" : c(r2) ? "undefined" : o(r2) ? `[array:${r2.elements.length}]` : y(r2) ? "[object Object]" : String(r2);
 }
-function p(r) {
-  return n(r) ? "string" : t(r) ? "number" : i$1(r) ? "boolean" : e(r) ? "null" : o(r) ? "undefined" : f(r) ? "array" : c(r) ? "object" : "unknown";
+function j$1(r2) {
+  return e(r2) ? r2 : f$1(r2) || c(r2) ? false : i$1(r2) ? r2 !== 0 : t(r2) ? r2 !== "" : o(r2) || y(r2) ? true : !!r2;
 }
-function m(r) {
-  if (t(r)) return r;
-  if (i$1(r)) return r ? 1 : 0;
-  if (e(r)) return 0;
-  if (o(r)) return NaN;
-  if (n(r)) {
-    const u2 = r.trim();
-    return u2 === "" ? 0 : Number(u2);
-  }
-  return f(r) ? NaN : Number(r);
+function d$2(r2) {
+  return t(r2) ? "string" : i$1(r2) ? "number" : e(r2) ? "boolean" : f$1(r2) ? "null" : c(r2) ? "undefined" : o(r2) || u$1(r2) ? "array" : y(r2) || b(r2) ? "object" : "unknown";
 }
-function d(r = []) {
-  return { type: "array", elements: r };
+function m(r2) {
+  if (i$1(r2)) return r2;
+  if (e(r2)) return r2 ? 1 : 0;
+  if (f$1(r2)) return 0;
+  if (c(r2)) return NaN;
+  if (t(r2)) {
+    const n2 = r2.trim();
+    return n2 === "" ? 0 : Number(n2);
+  }
+  return o(r2) ? NaN : Number(r2);
 }
-function s() {
+function s(r2 = [], n2) {
+  return n2 ? { type: "array", elements: r2, properties: n2 } : { type: "array", elements: r2 };
+}
+function C() {
   return { type: "undefined" };
 }
-function j$1(r = {}) {
-  return { type: "object", properties: r };
+function M$1(r2 = {}) {
+  return { type: "object", properties: r2 };
 }
-var l = Object.defineProperty;
-var u$1 = (s2, t2, e2) => t2 in s2 ? l(s2, t2, { enumerable: true, configurable: true, writable: true, value: e2 }) : s2[t2] = e2;
-var a = (s2, t2, e2) => u$1(s2, typeof t2 != "symbol" ? t2 + "" : t2, e2);
-let h$1 = class h {
+var d$1 = Object.defineProperty;
+var h = (s2, t2, n2) => t2 in s2 ? d$1(s2, t2, { enumerable: true, configurable: true, writable: true, value: n2 }) : s2[t2] = n2;
+var a = (s2, t2, n2) => h(s2, typeof t2 != "symbol" ? t2 + "" : t2, n2);
+class p2 {
   constructor(t2) {
     a(this, "connected", false);
     a(this, "programsDir");
     a(this, "executionsDir");
     a(this, "outputsDir");
-    this.dataDir = t2, this.programsDir = c__namespace.join(t2, "programs"), this.executionsDir = c__namespace.join(t2, "executions"), this.outputsDir = c__namespace.join(t2, "outputs");
+    this.dataDir = t2, this.programsDir = r__namespace.join(t2, "programs"), this.executionsDir = r__namespace.join(t2, "executions"), this.outputsDir = r__namespace.join(t2, "outputs");
   }
   get metadataFile() {
-    return c__namespace.join(this.dataDir, "metadata.json");
+    return r__namespace.join(this.dataDir, "metadata.json");
   }
   async connect() {
-    await M$2.promises.mkdir(this.dataDir, { recursive: true }), await M$2.promises.mkdir(this.programsDir, { recursive: true }), await M$2.promises.mkdir(this.executionsDir, { recursive: true }), await M$2.promises.mkdir(this.outputsDir, { recursive: true }), this.connected = true;
+    await b$2.promises.mkdir(this.dataDir, { recursive: true }), await b$2.promises.mkdir(this.programsDir, { recursive: true }), await b$2.promises.mkdir(this.executionsDir, { recursive: true }), await b$2.promises.mkdir(this.outputsDir, { recursive: true }), this.connected = true;
   }
   async disconnect() {
     this.connected = false;
@@ -560,71 +606,71 @@ let h$1 = class h {
   }
   async saveProgram(t2) {
     if (!this.connected) throw new Error("Not connected");
-    const e2 = c__namespace.join(this.programsDir, `${t2.id}.json`), n2 = JSON.stringify(t2, null, 2);
-    await M$2.promises.writeFile(e2, n2, "utf-8");
+    const n2 = r__namespace.join(this.programsDir, `${t2.id}.json`), e2 = JSON.stringify(t2, null, 2);
+    await b$2.promises.writeFile(n2, e2, "utf-8");
   }
   async getProgram(t2) {
     if (!this.connected) throw new Error("Not connected");
-    const e2 = c__namespace.join(this.programsDir, `${t2}.json`);
+    const n2 = r__namespace.join(this.programsDir, `${t2}.json`);
     try {
-      const n2 = await M$2.promises.readFile(e2, "utf-8"), o2 = JSON.parse(n2);
+      const e2 = await b$2.promises.readFile(n2, "utf-8"), o2 = JSON.parse(e2);
       return o2.created = new Date(o2.created), o2.updated && (o2.updated = new Date(o2.updated)), o2;
-    } catch (n2) {
-      if (n2.code === "ENOENT")
+    } catch (e2) {
+      if (e2.code === "ENOENT")
         return null;
-      throw n2;
+      throw e2;
     }
   }
   async saveExecution(t2) {
     if (!this.connected) throw new Error("Not connected");
-    const e2 = c__namespace.join(this.executionsDir, `${t2.id}.json`), n2 = JSON.stringify(t2, null, 2);
-    await M$2.promises.writeFile(e2, n2, "utf-8");
+    const n2 = r__namespace.join(this.executionsDir, `${t2.id}.json`), e2 = JSON.stringify(t2, null, 2);
+    await b$2.promises.writeFile(n2, e2, "utf-8");
   }
   async getExecution(t2) {
     if (!this.connected) throw new Error("Not connected");
-    const e2 = c__namespace.join(this.executionsDir, `${t2}.json`);
+    const n2 = r__namespace.join(this.executionsDir, `${t2}.json`);
     try {
-      const n2 = await M$2.promises.readFile(e2, "utf-8"), o2 = JSON.parse(n2);
+      const e2 = await b$2.promises.readFile(n2, "utf-8"), o2 = JSON.parse(e2);
       return o2.created = new Date(o2.created), o2.updated && (o2.updated = new Date(o2.updated)), o2;
-    } catch (n2) {
-      if (n2.code === "ENOENT")
+    } catch (e2) {
+      if (e2.code === "ENOENT")
         return null;
-      throw n2;
+      throw e2;
     }
   }
-  async appendOutput(t2, e2) {
+  async appendOutput(t2, n2) {
     if (!this.connected) throw new Error("Not connected");
-    const n2 = c__namespace.join(this.outputsDir, `${t2}.output`), o2 = e2.join(`
+    const e2 = r__namespace.join(this.outputsDir, `${t2}.output`), o2 = n2.join(`
 `) + `
 `;
-    await M$2.promises.appendFile(n2, o2, "utf-8");
+    await b$2.promises.appendFile(e2, o2, "utf-8");
   }
   async getOutput(t2) {
     if (!this.connected) throw new Error("Not connected");
-    const e2 = c__namespace.join(this.outputsDir, `${t2}.output`);
+    const n2 = r__namespace.join(this.outputsDir, `${t2}.output`);
     try {
-      return (await M$2.promises.readFile(e2, "utf-8")).split(`
+      return (await b$2.promises.readFile(n2, "utf-8")).split(`
 `).filter((o2) => o2.length > 0);
-    } catch (n2) {
-      if (n2.code === "ENOENT")
+    } catch (e2) {
+      if (e2.code === "ENOENT")
         return [];
-      throw n2;
+      throw e2;
     }
   }
   async listExecutions() {
     if (!this.connected) throw new Error("Not connected");
-    const t2 = await M$2.promises.readdir(this.executionsDir), e2 = [];
-    for (const n2 of t2)
-      if (n2.endsWith(".json")) {
-        const o2 = n2.slice(0, -5), r = await this.getExecution(o2);
-        r && e2.push(r);
+    const t2 = await b$2.promises.readdir(this.executionsDir), n2 = [];
+    for (const e2 of t2)
+      if (e2.endsWith(".json")) {
+        const o2 = e2.slice(0, -5), i2 = await this.getExecution(o2);
+        i2 && n2.push(i2);
       }
-    return e2;
+    return n2;
   }
   async getCurrentExecutionId() {
     if (!this.connected) throw new Error("Not connected");
     try {
-      const t2 = await M$2.promises.readFile(this.metadataFile, "utf-8");
+      const t2 = await b$2.promises.readFile(this.metadataFile, "utf-8");
       return JSON.parse(t2).currentExecutionId || null;
     } catch (t2) {
       if (t2.code === "ENOENT")
@@ -634,27 +680,46 @@ let h$1 = class h {
   }
   async setCurrentExecutionId(t2) {
     if (!this.connected) throw new Error("Not connected");
-    const e2 = { currentExecutionId: t2 };
-    await M$2.promises.writeFile(this.metadataFile, JSON.stringify(e2, null, 2), "utf-8");
+    const n2 = { currentExecutionId: t2 };
+    await b$2.promises.writeFile(this.metadataFile, JSON.stringify(n2, null, 2), "utf-8");
   }
   async deleteExecution(t2) {
     if (!this.connected) throw new Error("Not connected");
-    const e2 = c__namespace.join(this.executionsDir, `${t2}.json`);
+    const n2 = r__namespace.join(this.executionsDir, `${t2}.json`);
     try {
-      await M$2.promises.unlink(e2);
-    } catch (r) {
-      if (r.code !== "ENOENT") throw r;
+      await b$2.promises.unlink(n2);
+    } catch (i2) {
+      if (i2.code !== "ENOENT") throw i2;
     }
-    const n2 = c__namespace.join(this.outputsDir, `${t2}.output`);
+    const e2 = r__namespace.join(this.outputsDir, `${t2}.output`);
     try {
-      await M$2.promises.unlink(n2);
-    } catch (r) {
-      if (r.code !== "ENOENT") throw r;
+      await b$2.promises.unlink(e2);
+    } catch (i2) {
+      if (i2.code !== "ENOENT") throw i2;
     }
     await this.getCurrentExecutionId() === t2 && await this.setCurrentExecutionId(null);
   }
-};
-class w {
+  async listPrograms() {
+    if (!this.connected) throw new Error("Not connected");
+    const t2 = await b$2.promises.readdir(this.programsDir), n2 = [];
+    for (const e2 of t2)
+      if (e2.endsWith(".json")) {
+        const o2 = e2.slice(0, -5), i2 = await this.getProgram(o2);
+        i2 && n2.push(i2);
+      }
+    return n2;
+  }
+  async deleteProgram(t2) {
+    if (!this.connected) throw new Error("Not connected");
+    const n2 = r__namespace.join(this.programsDir, `${t2}.json`);
+    try {
+      await b$2.promises.unlink(n2);
+    } catch (e2) {
+      if (e2.code !== "ENOENT") throw e2;
+    }
+  }
+}
+class f {
   constructor(t2) {
     a(this, "client");
     a(this, "db", null);
@@ -666,8 +731,8 @@ class w {
     await this.client.connect();
     const t2 = ((o2 = this.connectionString.split("/").pop()) == null ? void 0 : o2.split("?")[0]) || "cvm";
     this.db = this.client.db(t2), this.connected = true;
-    const n2 = (await this.db.listCollections().toArray()).map((r) => r.name);
-    n2.includes("programs") || await this.db.createCollection("programs"), n2.includes("executions") || await this.db.createCollection("executions"), n2.includes("outputs") || await this.db.createCollection("outputs"), n2.includes("metadata") || await this.db.createCollection("metadata");
+    const e2 = (await this.db.listCollections().toArray()).map((i2) => i2.name);
+    e2.includes("programs") || await this.db.createCollection("programs"), e2.includes("executions") || await this.db.createCollection("executions"), e2.includes("outputs") || await this.db.createCollection("outputs"), e2.includes("metadata") || await this.db.createCollection("metadata");
   }
   async disconnect() {
     await this.client.close(), this.connected = false, this.db = null;
@@ -677,7 +742,7 @@ class w {
   }
   async getCollections() {
     if (!this.db) throw new Error("Not connected to database");
-    return (await this.db.listCollections().toArray()).map((e2) => e2.name);
+    return (await this.db.listCollections().toArray()).map((n2) => n2.name);
   }
   getCollection(t2) {
     if (!this.db) throw new Error("Not connected to database");
@@ -703,23 +768,23 @@ class w {
   async getExecution(t2) {
     return await this.getCollection("executions").findOne({ id: t2 });
   }
-  async appendOutput(t2, e2) {
-    const n2 = this.getCollection("outputs");
-    await n2.findOne({ executionId: t2 }) ? await n2.updateOne(
+  async appendOutput(t2, n2) {
+    const e2 = this.getCollection("outputs");
+    await e2.findOne({ executionId: t2 }) ? await e2.updateOne(
       { executionId: t2 },
-      { $push: { lines: { $each: e2 } } }
-    ) : await n2.insertOne({ executionId: t2, lines: e2 });
+      { $push: { lines: { $each: n2 } } }
+    ) : await e2.insertOne({ executionId: t2, lines: n2 });
   }
   async getOutput(t2) {
-    const n2 = await this.getCollection("outputs").findOne({ executionId: t2 });
-    return (n2 == null ? void 0 : n2.lines) || [];
+    const e2 = await this.getCollection("outputs").findOne({ executionId: t2 });
+    return (e2 == null ? void 0 : e2.lines) || [];
   }
   async listExecutions() {
     return await this.getCollection("executions").find({}).toArray();
   }
   async getCurrentExecutionId() {
-    const e2 = await this.getCollection("metadata").findOne({ _id: "current" });
-    return (e2 == null ? void 0 : e2.currentExecutionId) || null;
+    const n2 = await this.getCollection("metadata").findOne({ _id: "current" });
+    return (n2 == null ? void 0 : n2.currentExecutionId) || null;
   }
   async setCurrentExecutionId(t2) {
     await this.getCollection("metadata").replaceOne(
@@ -729,136 +794,224 @@ class w {
     );
   }
   async deleteExecution(t2) {
-    await this.getCollection("executions").deleteOne({ id: t2 }), await this.getCollection("outputs").deleteOne({ executionId: t2 }), await this.getCurrentExecutionId() === t2 && await this.setCurrentExecutionId(null);
+    var o2;
+    let n2 = true;
+    const e2 = this.client.startSession();
+    try {
+      await e2.withTransaction(async () => {
+        await this.getCollection("executions").deleteOne({ id: t2 }, { session: e2 }), await this.getCollection("outputs").deleteMany({ executionId: t2 }, { session: e2 }), await this.getCurrentExecutionId() === t2 && await this.db.collection("system").updateOne(
+          { _id: "current" },
+          { $set: { executionId: null } },
+          { session: e2 }
+        );
+      });
+    } catch (i2) {
+      if ((o2 = i2 == null ? void 0 : i2.message) != null && o2.includes("Transaction numbers are only allowed"))
+        n2 = false;
+      else
+        throw i2;
+    } finally {
+      await e2.endSession();
+    }
+    n2 || (await this.getCollection("executions").deleteOne({ id: t2 }), await this.getCollection("outputs").deleteMany({ executionId: t2 }), await this.getCurrentExecutionId() === t2 && await this.setCurrentExecutionId(null));
+  }
+  async listPrograms() {
+    return await this.getCollection("programs").find({}).toArray();
+  }
+  async deleteProgram(t2) {
+    await this.getCollection("programs").deleteOne({ id: t2 });
   }
 }
 class E {
   static create(t2) {
-    const e2 = (t2 == null ? void 0 : t2.type) || process.env.CVM_STORAGE_TYPE || "file";
-    switch (e2) {
+    const n2 = (t2 == null ? void 0 : t2.type) || process.env.CVM_STORAGE_TYPE || "file";
+    switch (n2) {
       case "file": {
-        const n2 = (t2 == null ? void 0 : t2.dataDir) || process.env.CVM_DATA_DIR || ".cvm";
-        return new h$1(n2);
+        const e2 = (t2 == null ? void 0 : t2.dataDir) || process.env.CVM_DATA_DIR || ".cvm";
+        return new p2(e2);
       }
       case "mongodb": {
-        const n2 = (t2 == null ? void 0 : t2.mongoUri) || process.env.MONGODB_URI || "mongodb://localhost:27017/cvm";
-        return new w(n2);
+        const e2 = (t2 == null ? void 0 : t2.mongoUri) || process.env.MONGODB_URI || "mongodb://localhost:27017/cvm";
+        return new f(e2);
       }
       default:
-        throw new Error(`Unsupported storage type: ${e2}`);
+        throw new Error(`Unsupported storage type: ${n2}`);
     }
   }
 }
-var A2 = Object.defineProperty;
-var b = (e2, r, t2) => r in e2 ? A2(e2, r, { enumerable: true, configurable: true, writable: true, value: t2 }) : e2[r] = t2;
-var h2 = (e2, r, t2) => b(e2, typeof r != "symbol" ? r + "" : r, t2);
-const G = {
-  [n$1.ADD]: {
+var H = Object.defineProperty;
+var D = (e2, t2, r2) => t2 in e2 ? H(e2, t2, { enumerable: true, configurable: true, writable: true, value: r2 }) : e2[t2] = r2;
+var _ = (e2, t2, r2) => D(e2, typeof t2 != "symbol" ? t2 + "" : t2, r2);
+function z(e2) {
+  return !!(e2 && typeof e2 == "object" && "type" in e2 && "message" in e2);
+}
+function l(e2, t2) {
+  return e2.stack.length < 1 ? {
+    type: "RuntimeError",
+    message: "Stack underflow",
+    pc: e2.pc,
+    opcode: t2 || n.POP
+  } : e2.stack.pop();
+}
+const d = z, B = {
+  [n.ADD]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e2) => {
-      const r = e2.stack.pop(), t2 = e2.stack.pop(), s2 = m(t2), o2 = m(r);
-      e2.stack.push(s2 + o2);
+    execute: (e2, t$1) => {
+      const r2 = l(e2, t$1.op);
+      if (d(r2)) return r2;
+      const o2 = l(e2, t$1.op);
+      if (d(o2)) return o2;
+      if (t(o2) || t(r2))
+        e2.stack.push(p$1(o2) + p$1(r2));
+      else {
+        const s2 = m(o2), c2 = m(r2);
+        e2.stack.push(s2 + c2);
+      }
     }
   },
-  [n$1.SUB]: {
+  [n.SUB]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e2) => {
-      const r = e2.stack.pop(), t2 = e2.stack.pop(), s2 = m(t2), o2 = m(r);
-      e2.stack.push(s2 - o2);
+    execute: (e2, t2) => {
+      const r2 = l(e2, t2.op);
+      if (d(r2)) return r2;
+      const o2 = l(e2, t2.op);
+      if (d(o2)) return o2;
+      const s2 = m(o2), c2 = m(r2);
+      e2.stack.push(s2 - c2);
     }
   },
-  [n$1.MUL]: {
+  [n.MUL]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e2) => {
-      const r = e2.stack.pop(), t2 = e2.stack.pop(), s2 = m(t2), o2 = m(r);
-      e2.stack.push(s2 * o2);
+    execute: (e2, t2) => {
+      const r2 = l(e2, t2.op);
+      if (d(r2)) return r2;
+      const o2 = l(e2, t2.op);
+      if (d(o2)) return o2;
+      const s2 = m(o2), c2 = m(r2);
+      e2.stack.push(s2 * c2);
     }
   },
-  [n$1.DIV]: {
+  [n.DIV]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e2, r) => {
-      const t2 = e2.stack.pop(), s2 = e2.stack.pop(), o2 = m(s2), n2 = m(t2);
-      if (n2 === 0)
+    execute: (e2, t2) => {
+      const r2 = l(e2, t2.op);
+      if (d(r2)) return r2;
+      const o2 = l(e2, t2.op);
+      if (d(o2)) return o2;
+      const s2 = m(o2), c2 = m(r2);
+      if (c2 === 0)
         return {
           type: "DivisionByZero",
           message: "Division by zero",
           pc: e2.pc,
-          opcode: r.op
+          opcode: t2.op
         };
-      e2.stack.push(o2 / n2);
+      e2.stack.push(s2 / c2);
     }
   },
-  [n$1.MOD]: {
+  [n.MOD]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e2) => {
-      const r = e2.stack.pop(), t2 = e2.stack.pop(), s2 = m(t2), o2 = m(r);
-      e2.stack.push(s2 % o2);
+    execute: (e2, t2) => {
+      const r2 = l(e2, t2.op);
+      if (d(r2)) return r2;
+      const o2 = l(e2, t2.op);
+      if (d(o2)) return o2;
+      const s2 = m(o2), c2 = m(r2);
+      e2.stack.push(s2 % c2);
     }
   },
-  [n$1.UNARY_MINUS]: {
+  [n.UNARY_MINUS]: {
     stackIn: 1,
     stackOut: 1,
-    execute: (e2) => {
-      const r = e2.stack.pop(), t2 = m(r);
-      e2.stack.push(-t2);
+    execute: (e2, t2) => {
+      const r2 = l(e2, t2.op);
+      if (d(r2)) return r2;
+      const o2 = m(r2);
+      e2.stack.push(-o2);
     }
   },
-  [n$1.UNARY_PLUS]: {
+  [n.UNARY_PLUS]: {
     stackIn: 1,
     stackOut: 1,
-    execute: (e2) => {
-      const r = e2.stack.pop(), t2 = m(r);
-      e2.stack.push(t2);
+    execute: (e2, t2) => {
+      const r2 = l(e2, t2.op);
+      if (d(r2)) return r2;
+      const o2 = m(r2);
+      e2.stack.push(o2);
     }
   }
-}, L = {
-  [n$1.PUSH]: {
+}, W = {
+  [n.PUSH]: {
     stackIn: 0,
     stackOut: 1,
-    execute: (e2, r) => {
-      e2.stack.push(r.arg);
+    execute: (e2, t2) => {
+      e2.stack.push(t2.arg);
     }
   },
-  [n$1.PUSH_UNDEFINED]: {
+  [n.PUSH_UNDEFINED]: {
     stackIn: 0,
     stackOut: 1,
     execute: (e2) => {
-      e2.stack.push(s());
+      e2.stack.push(C());
     }
   },
-  [n$1.POP]: {
+  [n.POP]: {
     stackIn: 1,
     stackOut: 0,
     execute: (e2) => {
       e2.stack.pop();
     }
+  },
+  [n.DUP]: {
+    stackIn: 1,
+    stackOut: 2,
+    execute: (e2, t2) => {
+      const r2 = e2.stack.pop();
+      e2.stack.push(r2), e2.stack.push(r2);
+    }
+  },
+  [n.SWAP]: {
+    stackIn: 2,
+    stackOut: 2,
+    execute: (e2, t2) => {
+      const r2 = e2.stack.pop(), o2 = e2.stack.pop();
+      e2.stack.push(r2), e2.stack.push(o2);
+    }
+  },
+  [n.DUP2]: {
+    stackIn: 2,
+    stackOut: 4,
+    execute: (e2, t2) => {
+      const r2 = e2.stack.pop(), o2 = e2.stack.pop();
+      e2.stack.push(o2), e2.stack.push(r2), e2.stack.push(o2), e2.stack.push(r2);
+    }
   }
-}, V = {
-  [n$1.PRINT]: {
+}, X = {
+  [n.PRINT]: {
     stackIn: 1,
     stackOut: 0,
     execute: (e2) => {
-      const r = e2.stack.pop();
-      r !== void 0 && e2.output.push(y(r));
+      const t2 = e2.stack.pop();
+      t2 !== void 0 && e2.output.push(p$1(t2));
     }
   },
-  [n$1.CC]: {
+  [n.CC]: {
     stackIn: 1,
     stackOut: 0,
     controlsPC: true,
     // CC pauses execution
-    execute: (e2, r) => {
-      const t2 = e2.stack.pop();
-      e2.ccPrompt = y(t2), e2.status = "waiting_cc";
+    execute: (e2, t2) => {
+      const r2 = e2.stack.pop();
+      e2.ccPrompt = p$1(r2), e2.status = "waiting_cc";
     }
   }
-}, F = {
-  [n$1.HALT]: {
+}, K = {
+  [n.HALT]: {
     stackIn: 0,
     stackOut: 0,
     controlsPC: true,
@@ -866,102 +1019,102 @@ const G = {
       e2.status = "complete";
     }
   },
-  [n$1.JUMP]: {
+  [n.JUMP]: {
     stackIn: 0,
     stackOut: 0,
     controlsPC: true,
-    execute: (e2, r) => {
-      if (r.arg === void 0)
+    execute: (e2, t2) => {
+      if (t2.arg === void 0)
         return {
           type: "RuntimeError",
           message: "JUMP requires a target address",
           pc: e2.pc,
-          opcode: r.op
+          opcode: t2.op
         };
-      const t2 = r.arg;
-      if (t2 < 0)
+      const r2 = t2.arg;
+      if (r2 < 0)
         return {
           type: "RuntimeError",
-          message: `Invalid jump target: ${t2}`,
+          message: `Invalid jump target: ${r2}`,
           pc: e2.pc,
-          opcode: r.op
+          opcode: t2.op
         };
-      e2.pc = t2;
+      e2.pc = r2;
     }
   },
-  [n$1.JUMP_IF_FALSE]: {
+  [n.JUMP_IF_FALSE]: {
     stackIn: 1,
     stackOut: 0,
     controlsPC: true,
-    execute: (e2, r) => {
-      const t2 = e2.stack.pop();
-      if (r.arg === void 0)
+    execute: (e2, t2) => {
+      const r2 = e2.stack.pop();
+      if (t2.arg === void 0)
         return {
           type: "RuntimeError",
           message: "JUMP_IF_FALSE requires a target address",
           pc: e2.pc,
-          opcode: r.op
+          opcode: t2.op
         };
-      const s2 = r.arg;
-      if (s2 < 0)
+      const o2 = t2.arg;
+      if (o2 < 0)
         return {
           type: "RuntimeError",
-          message: `Invalid jump target: ${s2}`,
+          message: `Invalid jump target: ${o2}`,
           pc: e2.pc,
-          opcode: r.op
+          opcode: t2.op
         };
-      b$1(t2) ? e2.pc++ : e2.pc = s2;
+      j$1(r2) ? e2.pc++ : e2.pc = o2;
     }
   },
-  [n$1.JUMP_IF]: {
+  [n.JUMP_IF]: {
     stackIn: 1,
     stackOut: 0,
     controlsPC: true,
-    execute: (e2, r) => {
-      const t2 = e2.stack.pop();
-      if (r.arg === void 0)
+    execute: (e2, t2) => {
+      const r2 = e2.stack.pop();
+      if (t2.arg === void 0)
         return {
           type: "RuntimeError",
           message: "JUMP_IF requires a target address",
           pc: e2.pc,
-          opcode: r.op
+          opcode: t2.op
         };
-      const s2 = r.arg;
-      if (s2 < 0)
+      const o2 = t2.arg;
+      if (o2 < 0)
         return {
           type: "RuntimeError",
-          message: `Invalid jump target: ${s2}`,
+          message: `Invalid jump target: ${o2}`,
           pc: e2.pc,
-          opcode: r.op
+          opcode: t2.op
         };
-      b$1(t2) ? e2.pc = s2 : e2.pc++;
+      j$1(r2) ? e2.pc = o2 : e2.pc++;
     }
   },
-  [n$1.JUMP_IF_TRUE]: {
+  [n.JUMP_IF_TRUE]: {
     stackIn: 1,
     stackOut: 0,
     controlsPC: true,
-    execute: (e2, r) => {
-      const t2 = e2.stack.pop();
-      if (r.arg === void 0)
+    execute: (e2, t2) => {
+      const r2 = e2.stack.pop();
+      if (t2.arg === void 0)
         return {
           type: "RuntimeError",
           message: "JUMP_IF_TRUE requires a target address",
           pc: e2.pc,
-          opcode: r.op
+          opcode: t2.op
         };
-      const s2 = r.arg;
-      if (s2 < 0)
+      const o2 = t2.arg;
+      if (o2 < 0)
         return {
           type: "RuntimeError",
-          message: `Invalid jump target: ${s2}`,
+          message: `Invalid jump target: ${o2}`,
           pc: e2.pc,
-          opcode: r.op
+          opcode: t2.op
         };
-      b$1(t2) ? e2.pc = s2 : e2.pc++;
+      j$1(r2) ? e2.pc = o2 : e2.pc++;
     }
   },
-  [n$1.CALL]: {
+  [n.CALL]: {
     stackIn: 1,
     stackOut: 0,
     controlsPC: false,
@@ -969,899 +1122,1417 @@ const G = {
       type: "RuntimeError",
       message: "Functions not implemented",
       pc: e2.pc,
-      opcode: n$1.CALL
+      opcode: n.CALL
     })
   }
-}, j = {
-  [n$1.LOAD]: {
+}, Q = {
+  [n.LOAD]: {
     stackIn: 0,
     stackOut: 1,
-    execute: (e2, r) => {
-      const t2 = r.arg;
-      e2.variables.has(t2) ? e2.stack.push(e2.variables.get(t2)) : e2.stack.push(s());
+    execute: (e2, t2) => {
+      const r2 = t2.arg;
+      e2.variables.has(r2) ? e2.stack.push(e2.variables.get(r2)) : e2.stack.push(C());
     }
   },
-  [n$1.STORE]: {
+  [n.STORE]: {
     stackIn: 1,
     stackOut: 0,
-    execute: (e2, r) => {
-      const t2 = e2.stack.pop();
-      e2.variables.set(r.arg, t2);
+    execute: (e2, t2) => {
+      const r2 = e2.stack.pop();
+      e2.variables.set(t2.arg, r2);
     }
   }
-}, D = {
-  [n$1.ITER_START]: {
+}, Z = {
+  [n.ITER_START]: {
     stackIn: 1,
     stackOut: 0,
-    execute: (e2, r) => {
-      const t2 = e2.stack.pop();
-      if (t2 == null)
+    execute: (e2, t2) => {
+      const r2 = e2.stack.pop();
+      if (r2 == null)
         return {
           type: "TypeError",
           message: "TypeError: Cannot iterate over null or undefined",
           pc: e2.pc,
-          opcode: r.op
+          opcode: t2.op
         };
-      if (!f(t2))
+      let o$1;
+      if (u$1(r2)) {
+        const s2 = e2.heap.get(r2.id);
+        if (!s2 || s2.type !== "array")
+          return {
+            type: "RuntimeError",
+            message: "Invalid array reference",
+            pc: e2.pc,
+            opcode: t2.op
+          };
+        o$1 = s2.data;
+      } else if (o(r2))
+        o$1 = r2;
+      else
         return {
           type: "TypeError",
           message: "TypeError: Cannot iterate over non-array value",
           pc: e2.pc,
-          opcode: r.op
+          opcode: t2.op
         };
       if (e2.iterators.length >= 10)
         return {
           type: "RuntimeError",
           message: "RuntimeError: Maximum iterator depth exceeded",
           pc: e2.pc,
-          opcode: r.op
+          opcode: t2.op
         };
       e2.iterators.push({
-        array: t2,
+        array: o$1,
         index: 0,
-        length: t2.elements.length
+        length: o$1.elements.length
       });
     }
   },
-  [n$1.ITER_NEXT]: {
+  [n.ITER_NEXT]: {
     stackIn: 0,
     stackOut: 2,
     // Pushes element and hasMore flag
-    execute: (e2, r) => {
+    execute: (e2, t2) => {
       if (e2.iterators.length === 0)
         return {
           type: "RuntimeError",
           message: "ITER_NEXT: No active iterator",
           pc: e2.pc,
-          opcode: r.op
+          opcode: t2.op
         };
-      const t2 = e2.iterators[e2.iterators.length - 1];
-      t2.index < t2.length ? (t2.index < t2.array.elements.length ? e2.stack.push(t2.array.elements[t2.index]) : e2.stack.push(s()), e2.stack.push(true), t2.index++) : (e2.stack.push(null), e2.stack.push(false));
+      const r2 = e2.iterators[e2.iterators.length - 1];
+      r2.index < r2.length ? (r2.index < r2.array.elements.length ? e2.stack.push(r2.array.elements[r2.index]) : e2.stack.push(C()), e2.stack.push(true), r2.index++) : (e2.stack.push(null), e2.stack.push(false));
     }
   },
-  [n$1.ITER_END]: {
+  [n.ITER_END]: {
     stackIn: 0,
     stackOut: 0,
-    execute: (e2, r) => {
+    execute: (e2, t2) => {
       if (e2.iterators.length === 0)
         return {
           type: "RuntimeError",
           message: "ITER_END: No active iterator",
           pc: e2.pc,
-          opcode: r.op
+          opcode: t2.op
         };
       e2.iterators.pop();
     }
   }
 };
-function g(e2, r, t2) {
-  const s2 = e2.stack.pop(), o2 = e2.stack.pop(), n2 = t2(o2, s2);
-  e2.stack.push(n2);
+function O(e2, t2, r2) {
+  const o2 = l(e2, t2.op);
+  if (d(o2)) return o2;
+  const s2 = l(e2, t2.op);
+  if (d(s2)) return s2;
+  const c2 = r2(s2, o2);
+  e2.stack.push(c2);
 }
-const q = {
-  [n$1.EQ]: {
+const ee = {
+  [n.EQ]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e$1, r) => g(e$1, r, (t2, s2) => {
-      if (e(t2) && o(s2) || o(t2) && e(s2))
+    execute: (e2, t2) => O(e2, t2, (r2, o2) => {
+      if (f$1(r2) && c(o2) || c(r2) && f$1(o2))
         return true;
-      if (o(t2) && o(s2))
+      if (c(r2) && c(o2))
         return true;
+      if (u$1(r2) || b(r2))
+        return u$1(r2) && u$1(o2) || b(r2) && b(o2) ? r2.id === o2.id : false;
       {
-        const o2 = m(t2), n2 = m(s2);
-        return !isNaN(o2) && !isNaN(n2) ? o2 === n2 : y(t2) === y(s2);
+        const s2 = m(r2), c2 = m(o2);
+        return !isNaN(s2) && !isNaN(c2) ? s2 === c2 : p$1(r2) === p$1(o2);
       }
     })
   },
-  [n$1.NEQ]: {
+  [n.NEQ]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e$1, r) => g(e$1, r, (t2, s2) => {
-      if (e(t2) && o(s2) || o(t2) && e(s2))
+    execute: (e2, t2) => O(e2, t2, (r2, o2) => {
+      if (f$1(r2) && c(o2) || c(r2) && f$1(o2))
         return false;
-      if (o(t2) && o(s2))
+      if (c(r2) && c(o2))
         return false;
+      if (u$1(r2) || b(r2))
+        return u$1(r2) && u$1(o2) || b(r2) && b(o2) ? r2.id !== o2.id : true;
       {
-        const o2 = m(t2), n2 = m(s2);
-        return !isNaN(o2) && !isNaN(n2) ? o2 !== n2 : y(t2) !== y(s2);
+        const s2 = m(r2), c2 = m(o2);
+        return !isNaN(s2) && !isNaN(c2) ? s2 !== c2 : p$1(r2) !== p$1(o2);
       }
     })
   },
-  [n$1.LT]: {
+  [n.LT]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e2, r) => g(e2, r, (t2, s2) => {
-      const o2 = m(t2), n2 = m(s2);
-      return o2 < n2;
+    execute: (e2, t2) => O(e2, t2, (r2, o2) => {
+      const s2 = m(r2), c2 = m(o2);
+      return s2 < c2;
     })
   },
-  [n$1.GT]: {
+  [n.GT]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e2, r) => g(e2, r, (t2, s2) => {
-      const o2 = m(t2), n2 = m(s2);
-      return o2 > n2;
+    execute: (e2, t2) => O(e2, t2, (r2, o2) => {
+      const s2 = m(r2), c2 = m(o2);
+      return s2 > c2;
     })
   },
-  [n$1.LTE]: {
+  [n.LTE]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e2, r) => g(e2, r, (t2, s2) => {
-      const o2 = m(t2), n2 = m(s2);
-      return o2 <= n2;
+    execute: (e2, t2) => O(e2, t2, (r2, o2) => {
+      const s2 = m(r2), c2 = m(o2);
+      return s2 <= c2;
     })
   },
-  [n$1.GTE]: {
+  [n.GTE]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e2, r) => g(e2, r, (t2, s2) => {
-      const o2 = m(t2), n2 = m(s2);
-      return o2 >= n2;
+    execute: (e2, t2) => O(e2, t2, (r2, o2) => {
+      const s2 = m(r2), c2 = m(o2);
+      return s2 >= c2;
     })
   },
-  [n$1.EQ_STRICT]: {
+  [n.EQ_STRICT]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e2, r) => g(e2, r, (t2, s2) => t2 === s2)
+    execute: (e2, t2) => O(e2, t2, (r2, o2) => u$1(r2) && u$1(o2) || b(r2) && b(o2) ? r2.id === o2.id : r2 === o2)
   },
-  [n$1.NEQ_STRICT]: {
+  [n.NEQ_STRICT]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e2, r) => g(e2, r, (t2, s2) => t2 !== s2)
+    execute: (e2, t2) => O(e2, t2, (r2, o2) => u$1(r2) && u$1(o2) || b(r2) && b(o2) ? r2.id !== o2.id : r2 !== o2)
   }
-}, H = {
-  [n$1.AND]: {
+}, re = {
+  [n.AND]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e2, r) => {
-      const t2 = e2.stack.pop(), s2 = e2.stack.pop(), o2 = b$1(s2) ? t2 : s2;
-      e2.stack.push(o2);
+    execute: (e2, t2) => {
+      const r2 = l(e2, t2.op);
+      if (d(r2)) return r2;
+      const o2 = l(e2, t2.op);
+      if (d(o2)) return o2;
+      const s2 = j$1(o2) ? r2 : o2;
+      e2.stack.push(s2);
     }
   },
-  [n$1.OR]: {
+  [n.OR]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e2, r) => {
-      const t2 = e2.stack.pop(), s2 = e2.stack.pop(), o2 = b$1(s2) ? s2 : t2;
-      e2.stack.push(o2);
+    execute: (e2, t2) => {
+      const r2 = l(e2, t2.op);
+      if (d(r2)) return r2;
+      const o2 = l(e2, t2.op);
+      if (d(o2)) return o2;
+      const s2 = j$1(o2) ? o2 : r2;
+      e2.stack.push(s2);
     }
   },
-  [n$1.NOT]: {
+  [n.NOT]: {
     stackIn: 1,
     stackOut: 1,
-    execute: (e2, r) => {
-      const t2 = e2.stack.pop(), s2 = !b$1(t2);
-      e2.stack.push(s2);
+    execute: (e2, t2) => {
+      const r2 = l(e2, t2.op);
+      if (d(r2)) return r2;
+      const o2 = !j$1(r2);
+      e2.stack.push(o2);
     }
   }
-}, $ = {
-  [n$1.ARRAY_NEW]: {
+}, te = {
+  /**
+   * ARRAY_NEW: Creates a new empty array on the heap
+   * Stack: [] -> [array-ref]
+   */
+  [n.ARRAY_NEW]: {
     stackIn: 0,
     stackOut: 1,
-    execute: (e2, r) => {
-      e2.stack.push(d());
+    execute: (e2, t2) => {
+      const r2 = s(), o2 = e2.heap.allocate("array", r2);
+      e2.stack.push(o2);
     }
   },
-  [n$1.ARRAY_PUSH]: {
+  /**
+   * ARRAY_PUSH: Pushes a value to the end of an array
+   * Stack: [array-ref, value] -> [array-ref]
+   */
+  [n.ARRAY_PUSH]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e2, r) => {
-      const t2 = e2.stack.pop(), s2 = e2.stack.pop();
-      if (!f(s2))
+    execute: (e2, t2) => {
+      const r2 = e2.stack.pop(), o$1 = e2.stack.pop();
+      let s2;
+      if (u$1(o$1)) {
+        const c2 = e2.heap.get(o$1.id);
+        if (!c2 || c2.type !== "array")
+          return {
+            type: "RuntimeError",
+            message: "Invalid array reference",
+            pc: e2.pc,
+            opcode: t2.op
+          };
+        s2 = c2.data;
+      } else if (o(o$1))
+        s2 = o$1;
+      else
         return {
           type: "RuntimeError",
           message: "ARRAY_PUSH requires an array",
           pc: e2.pc,
-          opcode: r.op
+          opcode: t2.op
         };
-      s2.elements.push(t2), e2.stack.push(s2);
+      s2.elements.push(r2), e2.stack.push(o$1);
     }
   },
-  [n$1.ARRAY_GET]: {
+  [n.ARRAY_GET]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e2, r) => {
-      const t$1 = e2.stack.pop(), s2 = e2.stack.pop();
-      if (f(s2)) {
-        if (!t(t$1))
+    execute: (e2, t$1) => {
+      var u2;
+      const r2 = e2.stack.pop(), o$1 = e2.stack.pop();
+      let s2;
+      if (u$1(o$1)) {
+        const a2 = e2.heap.get(o$1.id);
+        if (!a2 || a2.type !== "array")
           return {
             type: "RuntimeError",
-            message: "ARRAY_GET requires numeric index for arrays",
+            message: "Invalid array reference",
             pc: e2.pc,
-            opcode: r.op
+            opcode: t$1.op
           };
-        const o2 = s2.elements[t$1] ?? null;
-        e2.stack.push(o2);
-        return;
-      }
-      if (c(s2)) {
-        if (!n(t$1))
+        s2 = a2.data;
+      } else if (b(o$1)) {
+        const a2 = e2.heap.get(o$1.id);
+        if (!a2 || a2.type !== "object")
           return {
             type: "RuntimeError",
-            message: "ARRAY_GET requires string key for objects",
+            message: "Invalid object reference",
             pc: e2.pc,
-            opcode: r.op
+            opcode: t$1.op
           };
-        const o2 = s2.properties[t$1] ?? null;
-        e2.stack.push(o2);
+        const i2 = a2.data, E2 = p$1(r2), x2 = i2.properties[E2] ?? C();
+        e2.stack.push(x2);
         return;
-      }
-      return {
-        type: "RuntimeError",
-        message: "ARRAY_GET requires an array or object",
-        pc: e2.pc,
-        opcode: r.op
-      };
+      } else if (o(o$1))
+        s2 = o$1;
+      else if (t(o$1)) {
+        let a2;
+        if (i$1(r2))
+          a2 = r2;
+        else if (t(r2)) {
+          const i2 = parseInt(r2, 10);
+          !isNaN(i2) && i2.toString() === r2 && (a2 = i2);
+        }
+        a2 !== void 0 && a2 >= 0 && a2 < o$1.length ? e2.stack.push(o$1[a2]) : e2.stack.push(C());
+        return;
+      } else
+        return {
+          type: "RuntimeError",
+          message: "ARRAY_GET requires an array, object, or string",
+          pc: e2.pc,
+          opcode: t$1.op
+        };
+      let c2;
+      if (i$1(r2))
+        c2 = r2;
+      else if (t(r2)) {
+        const a2 = parseInt(r2, 10);
+        if (!isNaN(a2) && a2.toString() === r2 && a2 >= 0)
+          c2 = a2;
+        else {
+          const i2 = ((u2 = s2.properties) == null ? void 0 : u2[r2]) ?? C();
+          e2.stack.push(i2);
+          return;
+        }
+      } else
+        return {
+          type: "RuntimeError",
+          message: "ARRAY_GET requires numeric or numeric string index",
+          pc: e2.pc,
+          opcode: t$1.op
+        };
+      const p3 = s2.elements[c2] ?? C();
+      e2.stack.push(p3);
     }
   },
-  [n$1.ARRAY_SET]: {
+  [n.ARRAY_SET]: {
     stackIn: 3,
     stackOut: 1,
-    execute: (e2, r) => {
-      const t$1 = e2.stack.pop(), s2 = e2.stack.pop(), o2 = e2.stack.pop();
-      if (f(o2)) {
-        if (!t(s2))
+    execute: (e2, t$1) => {
+      const r2 = e2.stack.pop(), o$1 = e2.stack.pop(), s2 = e2.stack.pop();
+      let c2;
+      if (u$1(s2)) {
+        const a2 = e2.heap.get(s2.id);
+        if (!a2 || a2.type !== "array")
           return {
             type: "RuntimeError",
-            message: "ARRAY_SET requires numeric index for arrays",
+            message: "Invalid array reference",
             pc: e2.pc,
-            opcode: r.op
+            opcode: t$1.op
           };
-        const n2 = Math.floor(s2);
-        if (n2 < 0)
+        c2 = a2.data;
+      } else if (b(s2)) {
+        const a2 = e2.heap.get(s2.id);
+        if (!a2 || a2.type !== "object")
           return {
             type: "RuntimeError",
-            message: "ARRAY_SET: Negative index not allowed",
+            message: "Invalid object reference",
             pc: e2.pc,
-            opcode: r.op
+            opcode: t$1.op
           };
-        o2.elements[n2] = t$1, e2.stack.push(o2);
+        const i2 = a2.data, E2 = p$1(o$1);
+        i2.properties[E2] = r2, e2.stack.push(s2);
         return;
-      }
-      if (c(o2)) {
-        if (!n(s2))
+      } else if (o(s2))
+        c2 = s2;
+      else
+        return {
+          type: "RuntimeError",
+          message: "ARRAY_SET requires an array",
+          pc: e2.pc,
+          opcode: t$1.op
+        };
+      let p3;
+      if (i$1(o$1))
+        p3 = o$1;
+      else if (t(o$1)) {
+        const a2 = parseInt(o$1, 10);
+        if (!isNaN(a2) && a2.toString() === o$1 && a2 >= 0)
+          p3 = a2;
+        else {
+          c2.properties || (c2.properties = {}), c2.properties[o$1] = r2, e2.stack.push(s2);
+          return;
+        }
+      } else
+        return {
+          type: "RuntimeError",
+          message: "ARRAY_SET requires numeric or numeric string index",
+          pc: e2.pc,
+          opcode: t$1.op
+        };
+      const u2 = Math.floor(p3);
+      if (u2 < 0)
+        return {
+          type: "RuntimeError",
+          message: "ARRAY_SET: Negative index not allowed",
+          pc: e2.pc,
+          opcode: t$1.op
+        };
+      c2.elements[u2] = r2, e2.stack.push(s2);
+    }
+  },
+  [n.ARRAY_LEN]: {
+    stackIn: 1,
+    stackOut: 1,
+    execute: (e2, t2) => {
+      const r2 = e2.stack.pop();
+      let o$1;
+      if (u$1(r2)) {
+        const s2 = e2.heap.get(r2.id);
+        if (!s2 || s2.type !== "array")
           return {
             type: "RuntimeError",
-            message: "ARRAY_SET requires string key for objects",
+            message: "Invalid array reference",
             pc: e2.pc,
-            opcode: r.op
+            opcode: t2.op
           };
-        o2.properties[s2] = t$1, e2.stack.push(o2);
-        return;
-      }
-      return {
-        type: "RuntimeError",
-        message: "ARRAY_SET requires an array or object",
-        pc: e2.pc,
-        opcode: r.op
-      };
+        o$1 = s2.data;
+      } else if (o(r2))
+        o$1 = r2;
+      else
+        return {
+          type: "RuntimeError",
+          message: "ARRAY_LEN requires an array",
+          pc: e2.pc,
+          opcode: t2.op
+        };
+      e2.stack.push(o$1.elements.length);
     }
   },
-  [n$1.ARRAY_LEN]: {
-    stackIn: 1,
+  [n.ARRAY_MAP_PROP]: {
+    stackIn: 2,
     stackOut: 1,
-    execute: (e2, r) => {
-      const t2 = e2.stack.pop();
-      if (!f(t2))
+    execute: (e2, t2) => {
+      const r2 = e2.stack.pop(), o2 = e2.stack.pop();
+      if (!u$1(o2))
         return {
           type: "RuntimeError",
-          message: "ARRAY_LEN requires an array",
+          message: "map() requires an array",
+          pc: e2.pc,
+          opcode: t2.op
+        };
+      const s$12 = e2.heap.get(o2.id);
+      if (!s$12 || s$12.type !== "array")
+        return {
+          type: "RuntimeError",
+          message: "Invalid array reference",
           pc: e2.pc,
-          opcode: r.op
+          opcode: t2.op
         };
-      e2.stack.push(t2.elements.length);
+      const c2 = s$12.data, p3 = s();
+      for (const a2 of c2.elements)
+        if (b(a2)) {
+          const i2 = e2.heap.get(a2.id);
+          if (i2 && i2.type === "object") {
+            const E2 = i2.data, x2 = p$1(r2);
+            p3.elements.push(E2.properties[x2] || null);
+          } else
+            p3.elements.push(null);
+        } else
+          p3.elements.push(null);
+      const u2 = e2.heap.allocate("array", p3);
+      e2.stack.push(u2);
+    }
+  },
+  [n.ARRAY_FILTER_PROP]: {
+    stackIn: 2,
+    stackOut: 1,
+    execute: (e2, t2) => {
+      const r2 = e2.stack.pop(), o2 = e2.stack.pop();
+      if (!u$1(o2))
+        return {
+          type: "RuntimeError",
+          message: "filter() requires an array",
+          pc: e2.pc,
+          opcode: t2.op
+        };
+      const s$12 = e2.heap.get(o2.id);
+      if (!s$12 || s$12.type !== "array")
+        return {
+          type: "RuntimeError",
+          message: "Invalid array reference",
+          pc: e2.pc,
+          opcode: t2.op
+        };
+      const c2 = s$12.data, p3 = s();
+      for (const a2 of c2.elements)
+        if (b(a2)) {
+          const i2 = e2.heap.get(a2.id);
+          if (i2 && i2.type === "object") {
+            const E2 = i2.data, x2 = p$1(r2);
+            x2 in E2.properties && E2.properties[x2] && p3.elements.push(a2);
+          }
+        }
+      const u2 = e2.heap.allocate("array", p3);
+      e2.stack.push(u2);
     }
   }
 };
-function T(e2) {
+function M(e2, t2) {
   if (e2 === null) return null;
   if (e2 !== void 0) {
     if (typeof e2 == "string" || typeof e2 == "number" || typeof e2 == "boolean" || e2 && typeof e2 == "object" && e2.type === "array" && Array.isArray(e2.elements))
       return e2;
     if (Array.isArray(e2)) {
-      const r = d();
-      return r.elements = e2.map(T), r;
+      const r2 = s();
+      return r2.elements = e2.map((o2) => M(o2, t2)), t2.allocate("array", r2);
     }
     if (e2 && typeof e2 == "object" && e2.type === "object" && e2.properties)
       return e2;
     if (typeof e2 == "object") {
-      const r = j$1();
-      for (const [t2, s2] of Object.entries(e2))
-        r.properties[t2] = T(s2);
-      return r;
+      const r2 = M$1();
+      for (const [o2, s2] of Object.entries(e2))
+        r2.properties[o2] = M(s2, t2);
+      return t2.allocate("object", r2);
     }
     return null;
   }
 }
-const J = {
-  [n$1.CONCAT]: {
+const oe = {
+  [n.CONCAT]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e2, r) => {
-      const t2 = e2.stack.pop(), s2 = e2.stack.pop();
-      e2.stack.push(y(s2) + y(t2));
+    execute: (e2, t2) => {
+      const r2 = l(e2, t2.op);
+      if (d(r2)) return r2;
+      const o2 = l(e2, t2.op);
+      if (d(o2)) return o2;
+      e2.stack.push(p$1(o2) + p$1(r2));
     }
   },
-  [n$1.STRING_LEN]: {
+  [n.STRING_LEN]: {
     stackIn: 1,
     stackOut: 1,
-    execute: (e2, r) => {
-      const t2 = e2.stack.pop();
-      if (!n(t2))
+    execute: (e2, t$1) => {
+      const r2 = l(e2, t$1.op);
+      if (d(r2)) return r2;
+      if (!t(r2))
         return {
           type: "RuntimeError",
           message: "STRING_LEN requires a string",
           pc: e2.pc,
-          opcode: r.op
+          opcode: t$1.op
         };
-      e2.stack.push(t2.length);
+      e2.stack.push(r2.length);
     }
   },
-  [n$1.LENGTH]: {
+  [n.LENGTH]: {
     stackIn: 1,
     stackOut: 1,
-    execute: (e2, r) => {
-      const t2 = e2.stack.pop();
-      if (n(t2))
-        e2.stack.push(t2.length);
-      else if (f(t2))
-        e2.stack.push(t2.elements.length);
-      else
+    execute: (e2, t$1) => {
+      const r2 = l(e2, t$1.op);
+      if (d(r2)) return r2;
+      if (t(r2))
+        e2.stack.push(r2.length);
+      else if (o(r2))
+        e2.stack.push(r2.elements.length);
+      else if (u$1(r2)) {
+        const o2 = e2.heap.get(r2.id);
+        if (!o2 || o2.type !== "array")
+          return {
+            type: "RuntimeError",
+            message: "Invalid array reference",
+            pc: e2.pc,
+            opcode: t$1.op
+          };
+        const s2 = o2.data;
+        e2.stack.push(s2.elements.length);
+      } else
         return {
           type: "RuntimeError",
           message: "LENGTH requires a string or array",
           pc: e2.pc,
-          opcode: r.op
+          opcode: t$1.op
         };
     }
   },
-  [n$1.JSON_PARSE]: {
+  [n.JSON_PARSE]: {
     stackIn: 1,
     stackOut: 1,
-    execute: (e2, r) => {
-      const t2 = e2.stack.pop();
-      if (!n(t2))
+    execute: (e2, t$1) => {
+      const r2 = l(e2, t$1.op);
+      if (d(r2)) return r2;
+      if (!t(r2))
         return {
           type: "RuntimeError",
           message: "JSON_PARSE requires a string",
           pc: e2.pc,
-          opcode: r.op
+          opcode: t$1.op
         };
       try {
-        const s2 = JSON.parse(t2);
-        e2.stack.push(T(s2));
+        const o2 = JSON.parse(r2);
+        e2.stack.push(M(o2, e2.heap));
       } catch {
         e2.stack.push(null);
       }
     }
   },
-  [n$1.TYPEOF]: {
+  [n.TYPEOF]: {
     stackIn: 1,
     stackOut: 1,
-    execute: (e2, r) => {
-      const t2 = e2.stack.pop();
-      e2.stack.push(p(t2));
+    execute: (e2, t2) => {
+      const r2 = l(e2, t2.op);
+      if (d(r2)) return r2;
+      e2.stack.push(d$2(r2));
     }
   }
-}, Y = {
-  [n$1.INC]: {
+}, se = {
+  [n.INC]: {
     stackIn: 1,
     stackOut: 1,
-    execute: (e2, r) => {
-      const t2 = e2.stack.pop();
-      if (typeof t2 != "string")
+    execute: (e2, t2) => {
+      const r2 = e2.stack.pop();
+      if (typeof r2 != "string")
         return {
           type: "RuntimeError",
           message: "INC: Invalid variable name",
           pc: e2.pc,
-          opcode: r.op
+          opcode: t2.op
         };
-      const s2 = e2.variables.get(t2) ?? 0, o2 = m(s2) + 1;
-      e2.variables.set(t2, o2);
-      const n2 = r.arg === true;
-      e2.stack.push(n2 ? m(s2) : o2);
+      const o2 = e2.variables.get(r2) ?? 0, s2 = m(o2) + 1;
+      e2.variables.set(r2, s2);
+      const c2 = t2.arg === true;
+      e2.stack.push(c2 ? m(o2) : s2);
     }
   },
-  [n$1.DEC]: {
+  [n.DEC]: {
     stackIn: 1,
     stackOut: 1,
-    execute: (e2, r) => {
-      const t2 = e2.stack.pop();
-      if (typeof t2 != "string")
+    execute: (e2, t2) => {
+      const r2 = e2.stack.pop();
+      if (typeof r2 != "string")
         return {
           type: "RuntimeError",
           message: "DEC: Invalid variable name",
           pc: e2.pc,
-          opcode: r.op
+          opcode: t2.op
         };
-      const s2 = e2.variables.get(t2) ?? 0, o2 = m(s2) - 1;
-      e2.variables.set(t2, o2);
-      const n2 = r.arg === true;
-      e2.stack.push(n2 ? m(s2) : o2);
+      const o2 = e2.variables.get(r2) ?? 0, s2 = m(o2) - 1;
+      e2.variables.set(r2, s2);
+      const c2 = t2.arg === true;
+      e2.stack.push(c2 ? m(o2) : s2);
     }
   }
-}, B = {
-  [n$1.RETURN]: {
+}, ce = {
+  [n.RETURN]: {
     stackIn: 0,
     stackOut: 0,
     controlsPC: true,
-    execute: (e2, r) => {
-      const t2 = e2.stack.pop() ?? null;
-      e2.returnValue = t2, e2.status = "complete";
+    execute: (e2, t2) => {
+      const r2 = e2.stack.pop() ?? null;
+      e2.returnValue = r2, e2.status = "complete";
     }
   },
-  [n$1.BREAK]: {
+  [n.BREAK]: {
     stackIn: 0,
     stackOut: 0,
     controlsPC: true,
-    execute: (e2, r) => {
-      if (r.arg === void 0)
+    execute: (e2, t2) => {
+      if (t2.arg === void 0)
         return {
           type: "RuntimeError",
           message: "BREAK requires a target address",
           pc: e2.pc,
-          opcode: r.op
+          opcode: t2.op
         };
-      const t2 = r.arg;
-      if (t2 < 0)
+      const r2 = t2.arg;
+      if (r2 < 0)
         return {
           type: "RuntimeError",
-          message: `Invalid break target: ${t2}`,
+          message: `Invalid break target: ${r2}`,
           pc: e2.pc,
-          opcode: r.op
+          opcode: t2.op
         };
-      e2.pc = t2;
+      e2.pc = r2;
     }
   },
-  [n$1.CONTINUE]: {
+  [n.CONTINUE]: {
     stackIn: 0,
     stackOut: 0,
     controlsPC: true,
-    execute: (e2, r) => {
-      if (r.arg === void 0)
+    execute: (e2, t2) => {
+      if (t2.arg === void 0)
         return {
           type: "RuntimeError",
           message: "CONTINUE requires a target address",
           pc: e2.pc,
-          opcode: r.op
+          opcode: t2.op
         };
-      const t2 = r.arg;
-      if (t2 < 0)
+      const r2 = t2.arg;
+      if (r2 < 0)
         return {
           type: "RuntimeError",
-          message: `Invalid continue target: ${t2}`,
+          message: `Invalid continue target: ${r2}`,
           pc: e2.pc,
-          opcode: r.op
+          opcode: t2.op
         };
-      e2.pc = t2;
+      e2.pc = r2;
     }
   },
-  [n$1.FS_LIST_FILES]: {
+  [n.FS_LIST_FILES]: {
     stackIn: 1,
     // Minimum 1 argument (path), optionally 2 (path + options)
-    stackOut: 0,
-    controlsPC: true,
-    execute: (e2, r) => {
+    stackOut: 1,
+    execute: (e2, t$1) => {
       if (e2.stack.length < 1)
         return {
           type: "StackUnderflow",
           message: "FS_LIST_FILES: Stack underflow",
           pc: e2.pc,
-          opcode: r.op
+          opcode: t$1.op
         };
-      let t2, s2 = {};
-      const o2 = e2.stack[e2.stack.length - 1];
-      if (e2.stack.length >= 2 && typeof o2 == "object" && o2 !== null && !f(o2) && (s2 = e2.stack.pop()), t2 = e2.stack.pop(), !n(t2))
+      let r2, o$1 = {};
+      const s2 = e2.stack[e2.stack.length - 1];
+      if (e2.stack.length >= 2 && typeof s2 == "object" && s2 !== null && !o(s2) && (o$1 = e2.stack.pop()), r2 = e2.stack.pop(), !t(r2))
         return {
           type: "RuntimeError",
           message: "FS_LIST_FILES requires a string path",
           pc: e2.pc,
-          opcode: r.op
+          opcode: t$1.op
+        };
+      if (!e2.fileSystem)
+        return {
+          type: "RuntimeError",
+          message: "FileSystem not available",
+          pc: e2.pc,
+          opcode: t$1.op
+        };
+      const c2 = e2.fileSystem.listFiles(r2, o$1);
+      if (o(c2)) {
+        const p3 = e2.heap.allocate("array", c2);
+        e2.stack.push(p3);
+      } else
+        e2.stack.push(c2);
+    }
+  },
+  [n.FS_READ_FILE]: {
+    stackIn: 1,
+    // path
+    stackOut: 1,
+    // Returns string or null
+    execute: (e2, t$1) => {
+      const r2 = e2.stack.pop();
+      if (!r2 || !t(r2))
+        return {
+          type: "RuntimeError",
+          message: "FS_READ_FILE requires a string path",
+          pc: e2.pc,
+          opcode: t$1.op
+        };
+      if (!e2.fileSystem)
+        return {
+          type: "RuntimeError",
+          message: "FileSystem not available",
+          pc: e2.pc,
+          opcode: t$1.op
         };
-      e2.fsOperation = {
-        type: "listFiles",
-        path: t2,
-        options: s2
-      }, e2.status = "waiting_fs";
+      const o2 = e2.fileSystem.readFile(r2);
+      e2.stack.push(o2);
+    }
+  },
+  [n.FS_WRITE_FILE]: {
+    stackIn: 2,
+    // path, content
+    stackOut: 1,
+    // Returns boolean
+    execute: (e2, t$1) => {
+      const r2 = e2.stack.pop(), o2 = e2.stack.pop();
+      if (!o2 || !t(o2))
+        return {
+          type: "RuntimeError",
+          message: "FS_WRITE_FILE requires a string path",
+          pc: e2.pc,
+          opcode: t$1.op
+        };
+      if (r2 === void 0)
+        return {
+          type: "RuntimeError",
+          message: "FS_WRITE_FILE requires content argument",
+          pc: e2.pc,
+          opcode: t$1.op
+        };
+      if (!e2.fileSystem)
+        return {
+          type: "RuntimeError",
+          message: "FileSystem not available",
+          pc: e2.pc,
+          opcode: t$1.op
+        };
+      const s2 = p$1(r2), c2 = e2.fileSystem.writeFile(o2, s2);
+      e2.stack.push(c2);
     }
   },
   // String method handlers
-  [n$1.STRING_SUBSTRING]: {
+  [n.STRING_SUBSTRING]: {
     stackIn: 2,
     // Minimum 2 (string, start), optionally 3 (string, start, end)
     stackOut: 1,
-    execute: (e2, r) => {
+    execute: (e2, t$1) => {
       if (e2.stack.length < 2)
         return {
           type: "StackUnderflow",
           message: "STRING_SUBSTRING: Stack underflow",
           pc: e2.pc,
-          opcode: r.op
+          opcode: t$1.op
         };
-      const t2 = e2.stack.length;
-      let s2, o2, n$12;
-      const a2 = e2.stack[t2 - 1], i2 = e2.stack[t2 - 2];
-      if (t2 >= 3 && typeof a2 == "number" && typeof i2 == "number" ? (n$12 = e2.stack.pop(), o2 = e2.stack.pop(), s2 = e2.stack.pop()) : (o2 = e2.stack.pop(), s2 = e2.stack.pop(), n$12 = void 0), !n(s2))
+      const r2 = e2.stack.length;
+      let o2, s2, c2;
+      const p3 = e2.stack[r2 - 1], u2 = e2.stack[r2 - 2];
+      if (r2 >= 3 && typeof p3 == "number" && typeof u2 == "number" ? (c2 = e2.stack.pop(), s2 = e2.stack.pop(), o2 = e2.stack.pop()) : (s2 = e2.stack.pop(), o2 = e2.stack.pop(), c2 = void 0), !t(o2))
         return {
           type: "RuntimeError",
           message: "STRING_SUBSTRING requires a string",
           pc: e2.pc,
-          opcode: r.op
+          opcode: t$1.op
         };
-      if (typeof o2 != "number")
+      if (typeof s2 != "number")
         return {
           type: "RuntimeError",
           message: "STRING_SUBSTRING requires numeric start index",
           pc: e2.pc,
-          opcode: r.op
+          opcode: t$1.op
         };
-      const u2 = s2.length;
-      o2 < 0 && (o2 = Math.max(0, u2 + o2)), n$12 !== void 0 && n$12 < 0 && (n$12 = Math.max(0, u2 + n$12));
-      const O2 = n$12 !== void 0 ? s2.substring(o2, n$12) : s2.substring(o2);
-      e2.stack.push(O2);
+      const a2 = o2.length;
+      s2 < 0 && (s2 = Math.max(0, a2 + s2)), c2 !== void 0 && c2 < 0 && (c2 = Math.max(0, a2 + c2));
+      const i2 = c2 !== void 0 ? o2.substring(s2, c2) : o2.substring(s2);
+      e2.stack.push(i2);
     }
   },
-  [n$1.STRING_INDEXOF]: {
+  [n.STRING_INDEXOF]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e2, r) => {
-      const t2 = e2.stack.pop(), s2 = e2.stack.pop();
-      if (!n(s2) || !n(t2))
+    execute: (e2, t$1) => {
+      const r2 = e2.stack.pop(), o2 = e2.stack.pop();
+      if (!t(o2) || !t(r2))
         return {
           type: "RuntimeError",
           message: "STRING_INDEXOF requires string arguments",
           pc: e2.pc,
-          opcode: r.op
+          opcode: t$1.op
         };
-      e2.stack.push(s2.indexOf(t2));
+      e2.stack.push(o2.indexOf(r2));
     }
   },
-  [n$1.STRING_SPLIT]: {
+  [n.STRING_SPLIT]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e2, r) => {
-      const t2 = e2.stack.pop(), s2 = e2.stack.pop();
-      if (!n(s2) || !n(t2))
+    execute: (e2, t$1) => {
+      const r2 = e2.stack.pop(), o2 = e2.stack.pop();
+      if (!t(o2) || !t(r2))
         return {
           type: "RuntimeError",
           message: "STRING_SPLIT requires string arguments",
           pc: e2.pc,
-          opcode: r.op
+          opcode: t$1.op
         };
-      let o2;
-      t2 === "" ? o2 = s2.split("") : o2 = s2.split(t2), e2.stack.push(d(o2));
+      let s$12;
+      r2 === "" ? s$12 = o2.split("") : s$12 = o2.split(r2);
+      const c2 = s(s$12), p3 = e2.heap.allocate("array", c2);
+      e2.stack.push(p3);
     }
   },
-  [n$1.STRING_SLICE]: {
+  [n.STRING_SLICE]: {
     stackIn: 2,
     // Minimum 2 (string, start), optionally 3 (string, start, end)
     stackOut: 1,
-    execute: (e2, r) => {
+    execute: (e2, t$1) => {
       if (e2.stack.length < 2)
         return {
           type: "StackUnderflow",
           message: "STRING_SLICE: Stack underflow",
           pc: e2.pc,
-          opcode: r.op
+          opcode: t$1.op
         };
-      const t2 = e2.stack.length;
-      let s2, o2, n$12;
-      const a2 = e2.stack.length >= 1 ? e2.stack[t2 - 1] : void 0, i2 = e2.stack.length >= 2 ? e2.stack[t2 - 2] : void 0;
-      if (t2 >= 3 && typeof a2 == "number" && typeof i2 == "number" ? (n$12 = e2.stack.pop(), o2 = e2.stack.pop(), s2 = e2.stack.pop()) : (o2 = e2.stack.pop(), s2 = e2.stack.pop(), n$12 = void 0), !n(s2))
+      const r2 = e2.stack.length;
+      let o2, s2, c2;
+      const p3 = e2.stack.length >= 1 ? e2.stack[r2 - 1] : void 0, u2 = e2.stack.length >= 2 ? e2.stack[r2 - 2] : void 0;
+      if (r2 >= 3 && typeof p3 == "number" && typeof u2 == "number" ? (c2 = e2.stack.pop(), s2 = e2.stack.pop(), o2 = e2.stack.pop()) : (s2 = e2.stack.pop(), o2 = e2.stack.pop(), c2 = void 0), !t(o2))
         return {
           type: "RuntimeError",
           message: "STRING_SLICE requires a string",
           pc: e2.pc,
-          opcode: r.op
+          opcode: t$1.op
         };
-      if (typeof o2 != "number")
+      if (typeof s2 != "number")
         return {
           type: "RuntimeError",
           message: "STRING_SLICE requires numeric start index",
           pc: e2.pc,
-          opcode: r.op
+          opcode: t$1.op
         };
-      const u2 = n$12 !== void 0 ? s2.slice(o2, n$12) : s2.slice(o2);
-      e2.stack.push(u2);
+      const a2 = c2 !== void 0 ? o2.slice(s2, c2) : o2.slice(s2);
+      e2.stack.push(a2);
     }
   },
-  [n$1.STRING_CHARAT]: {
+  [n.STRING_CHARAT]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e2, r) => {
-      const t2 = e2.stack.pop(), s2 = e2.stack.pop();
-      if (!n(s2))
+    execute: (e2, t$1) => {
+      const r2 = e2.stack.pop(), o2 = e2.stack.pop();
+      if (!t(o2))
         return {
           type: "RuntimeError",
           message: "STRING_CHARAT requires a string",
           pc: e2.pc,
-          opcode: r.op
+          opcode: t$1.op
         };
-      if (typeof t2 != "number")
+      if (typeof r2 != "number")
         return {
           type: "RuntimeError",
           message: "STRING_CHARAT requires numeric index",
           pc: e2.pc,
-          opcode: r.op
+          opcode: t$1.op
         };
-      const o2 = s2.charAt(t2);
-      e2.stack.push(o2);
+      const s2 = o2.charAt(r2);
+      e2.stack.push(s2);
     }
   },
-  [n$1.STRING_TOUPPERCASE]: {
+  [n.STRING_TOUPPERCASE]: {
     stackIn: 1,
     stackOut: 1,
-    execute: (e2, r) => {
-      const t2 = e2.stack.pop();
-      if (!n(t2))
+    execute: (e2, t$1) => {
+      const r2 = e2.stack.pop();
+      if (!t(r2))
         return {
           type: "RuntimeError",
           message: "STRING_TOUPPERCASE requires a string",
           pc: e2.pc,
-          opcode: r.op
+          opcode: t$1.op
         };
-      e2.stack.push(t2.toUpperCase());
+      e2.stack.push(r2.toUpperCase());
     }
   },
-  [n$1.STRING_TOLOWERCASE]: {
+  [n.STRING_TOLOWERCASE]: {
     stackIn: 1,
     stackOut: 1,
-    execute: (e2, r) => {
-      const t2 = e2.stack.pop();
-      if (!n(t2))
+    execute: (e2, t$1) => {
+      const r2 = e2.stack.pop();
+      if (!t(r2))
         return {
           type: "RuntimeError",
           message: "STRING_TOLOWERCASE requires a string",
           pc: e2.pc,
-          opcode: r.op
+          opcode: t$1.op
         };
-      e2.stack.push(t2.toLowerCase());
+      e2.stack.push(r2.toLowerCase());
     }
   },
-  [n$1.TO_STRING]: {
+  [n.TO_STRING]: {
     stackIn: 1,
     stackOut: 1,
-    execute: (e2, r) => {
-      const t2 = e2.stack.pop();
-      if (t2 === void 0)
+    execute: (e2, t2) => {
+      const r2 = e2.stack.pop();
+      if (r2 === void 0)
         return {
           type: "StackUnderflow",
           message: "TO_STRING: Stack underflow",
           pc: e2.pc,
-          opcode: r.op
+          opcode: t2.op
         };
-      const s2 = y(t2);
-      e2.stack.push(s2);
+      const o2 = p$1(r2);
+      e2.stack.push(o2);
     }
   }
 };
-function _(e2) {
-  if (f(e2))
-    return e2.elements.map(_);
-  if (c(e2)) {
-    const r = {};
-    for (const [t2, s2] of Object.entries(e2.properties))
-      r[t2] = _(s2);
-    return r;
-  }
-  if (!o(e2))
+function j(e2, t2) {
+  if (u$1(e2)) {
+    const r2 = t2.get(e2.id);
+    return r2 && r2.type === "array" ? r2.data.elements.map((s2) => j(s2, t2)) : null;
+  }
+  if (b(e2)) {
+    const r2 = t2.get(e2.id);
+    if (r2 && r2.type === "object") {
+      const o2 = r2.data, s2 = {};
+      for (const [c2, p3] of Object.entries(o2.properties))
+        s2[c2] = j(p3, t2);
+      return s2;
+    }
+    return null;
+  }
+  if (o(e2))
+    return e2.elements.map((r2) => j(r2, t2));
+  if (y(e2)) {
+    const r2 = {};
+    for (const [o2, s2] of Object.entries(e2.properties))
+      r2[o2] = j(s2, t2);
+    return r2;
+  }
+  if (!c(e2))
     return e2;
 }
-const W = {
-  [n$1.OBJECT_CREATE]: {
+const ne = {
+  [n.OBJECT_CREATE]: {
     stackIn: 0,
     stackOut: 1,
     execute: (e2) => {
-      e2.stack.push(j$1());
+      const t2 = M$1(), r2 = e2.heap.allocate("object", t2);
+      e2.stack.push(r2);
     }
   },
-  [n$1.PROPERTY_SET]: {
+  [n.PROPERTY_SET]: {
     stackIn: 3,
     stackOut: 1,
-    execute: (e2, r) => {
-      const t2 = e2.stack.pop(), s2 = e2.stack.pop(), o2 = e2.stack.pop();
-      if (!c(o2))
+    execute: (e2, t2) => {
+      const r2 = l(e2, t2.op);
+      if (d(r2)) return r2;
+      const o2 = l(e2, t2.op);
+      if (d(o2)) return o2;
+      const s2 = l(e2, t2.op);
+      if (d(s2)) return s2;
+      let c2;
+      if (b(s2)) {
+        const u2 = e2.heap.get(s2.id);
+        if (!u2 || u2.type !== "object")
+          return {
+            type: "RuntimeError",
+            message: "Invalid object reference",
+            pc: e2.pc,
+            opcode: t2.op
+          };
+        c2 = u2.data;
+      } else if (y(s2))
+        c2 = s2;
+      else
         return {
           type: "RuntimeError",
-          message: `Cannot set property '${s2}' on ${p(o2)}`,
+          message: `Cannot set property '${o2}' on ${d$2(s2)}`,
           pc: e2.pc,
-          opcode: r.op
+          opcode: t2.op
         };
-      if (!n(s2))
+      const p3 = p$1(o2);
+      c2.properties[p3] = r2, e2.stack.push(s2);
+    }
+  },
+  [n.PROPERTY_GET]: {
+    stackIn: 2,
+    stackOut: 1,
+    execute: (e2, t2) => {
+      const r2 = l(e2, t2.op);
+      if (d(r2)) return r2;
+      const o2 = l(e2, t2.op);
+      if (d(o2)) return o2;
+      if (f$1(o2) || c(o2))
         return {
           type: "RuntimeError",
-          message: "Property key must be a string",
+          message: `Cannot read property '${r2}' of ${d$2(o2)}`,
           pc: e2.pc,
-          opcode: r.op
+          opcode: t2.op
         };
-      o2.properties[s2] = t2, e2.stack.push(o2);
+      let s2 = null;
+      if (b(o2)) {
+        const p3 = e2.heap.get(o2.id);
+        if (!p3 || p3.type !== "object")
+          return {
+            type: "RuntimeError",
+            message: "Invalid object reference",
+            pc: e2.pc,
+            opcode: t2.op
+          };
+        s2 = p3.data;
+      } else if (y(o2))
+        s2 = o2;
+      else {
+        e2.stack.push(C());
+        return;
+      }
+      const c$1 = s2.properties[p$1(r2)];
+      e2.stack.push(c$1 ?? C());
     }
   },
-  [n$1.PROPERTY_GET]: {
+  [n.JSON_STRINGIFY]: {
+    stackIn: 1,
+    stackOut: 1,
+    execute: (e2, t2) => {
+      const r2 = l(e2, t2.op);
+      if (d(r2)) return r2;
+      const o2 = j(r2, e2.heap);
+      e2.stack.push(JSON.stringify(o2));
+    }
+  }
+}, pe = {
+  [n.GET]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e$1, r) => {
-      const t2 = e$1.stack.pop(), s$1 = e$1.stack.pop();
-      if (e(s$1) || o(s$1))
+    execute: (e2, t$1) => {
+      var s2;
+      const r2 = e2.stack.pop(), o2 = e2.stack.pop();
+      if (u$1(o2)) {
+        const c2 = e2.heap.get(o2.id);
+        if (!c2 || c2.type !== "array")
+          return {
+            type: "RuntimeError",
+            message: "Invalid array reference",
+            pc: e2.pc,
+            opcode: t$1.op
+          };
+        const p3 = c2.data;
+        let u2;
+        if (i$1(r2))
+          u2 = r2;
+        else if (t(r2)) {
+          const i2 = parseInt(r2, 10);
+          if (!isNaN(i2) && i2.toString() === r2 && i2 >= 0)
+            u2 = i2;
+          else {
+            const E2 = ((s2 = p3.properties) == null ? void 0 : s2[r2]) ?? C();
+            e2.stack.push(E2);
+            return;
+          }
+        } else
+          return {
+            type: "RuntimeError",
+            message: "GET requires numeric or numeric string index for arrays",
+            pc: e2.pc,
+            opcode: t$1.op
+          };
+        const a2 = p3.elements[u2] ?? C();
+        e2.stack.push(a2);
+        return;
+      } else if (b(o2)) {
+        const c2 = e2.heap.get(o2.id);
+        if (!c2 || c2.type !== "object")
+          return {
+            type: "RuntimeError",
+            message: "Invalid object reference",
+            pc: e2.pc,
+            opcode: t$1.op
+          };
+        const p3 = c2.data, u2 = p$1(r2), a2 = p3.properties[u2] ?? C();
+        e2.stack.push(a2);
+        return;
+      } else if (t(o2)) {
+        let c2;
+        if (i$1(r2))
+          c2 = r2;
+        else if (t(r2)) {
+          const p3 = parseInt(r2, 10);
+          !isNaN(p3) && p3.toString() === r2 && (c2 = p3);
+        }
+        c2 !== void 0 && c2 >= 0 && c2 < o2.length ? e2.stack.push(o2[c2]) : e2.stack.push(C());
+        return;
+      } else
         return {
           type: "RuntimeError",
-          message: `Cannot read property '${t2}' of ${p(s$1)}`,
-          pc: e$1.pc,
-          opcode: r.op
+          message: "GET requires array, object, or string",
+          pc: e2.pc,
+          opcode: t$1.op
         };
-      if (!c(s$1)) {
-        e$1.stack.push(s());
-        return;
-      }
-      const o$1 = s$1.properties[y(t2)];
-      e$1.stack.push(o$1 ?? s());
     }
   },
-  [n$1.JSON_STRINGIFY]: {
-    stackIn: 1,
+  [n.SET]: {
+    stackIn: 3,
     stackOut: 1,
-    execute: (e2) => {
-      const r = e2.stack.pop(), t2 = _(r);
-      e2.stack.push(JSON.stringify(t2));
-    }
-  }
-}, z = {
-  ...G,
-  ...L,
-  ...V,
-  ...F,
-  ...j,
-  ...D,
-  ...q,
-  ...H,
-  ...$,
-  ...J,
-  ...Y,
+    execute: (e2, t$1) => {
+      const r2 = e2.stack.pop(), o2 = e2.stack.pop(), s2 = e2.stack.pop();
+      if (u$1(s2)) {
+        const c2 = e2.heap.get(s2.id);
+        if (!c2 || c2.type !== "array")
+          return {
+            type: "RuntimeError",
+            message: "Invalid array reference",
+            pc: e2.pc,
+            opcode: t$1.op
+          };
+        const p3 = c2.data;
+        let u2;
+        if (i$1(o2))
+          u2 = o2;
+        else if (t(o2)) {
+          const i2 = parseInt(o2, 10);
+          if (!isNaN(i2) && i2.toString() === o2 && i2 >= 0)
+            u2 = i2;
+          else {
+            p3.properties || (p3.properties = {}), p3.properties[o2] = r2, e2.stack.push(s2);
+            return;
+          }
+        } else
+          return {
+            type: "RuntimeError",
+            message: "SET requires numeric or numeric string index for arrays",
+            pc: e2.pc,
+            opcode: t$1.op
+          };
+        const a2 = Math.floor(u2);
+        if (a2 < 0)
+          return {
+            type: "RuntimeError",
+            message: "SET: Negative index not allowed",
+            pc: e2.pc,
+            opcode: t$1.op
+          };
+        p3.elements[a2] = r2, e2.stack.push(s2);
+        return;
+      } else if (b(s2)) {
+        const c2 = e2.heap.get(s2.id);
+        if (!c2 || c2.type !== "object")
+          return {
+            type: "RuntimeError",
+            message: "Invalid object reference",
+            pc: e2.pc,
+            opcode: t$1.op
+          };
+        const p3 = c2.data, u2 = p$1(o2);
+        p3.properties[u2] = r2, e2.stack.push(s2);
+        return;
+      } else
+        return {
+          type: "RuntimeError",
+          message: "SET requires array or object",
+          pc: e2.pc,
+          opcode: t$1.op
+        };
+    }
+  }
+}, F = {
   ...B,
-  ...W
+  ...W,
+  ...X,
+  ...K,
+  ...Q,
+  ...Z,
+  ...ee,
+  ...re,
+  ...te,
+  ...oe,
+  ...se,
+  ...ce,
+  ...ne,
+  ...pe
 };
-class N {
-  validateStack(r, t2, s2) {
-    if (s2.stack.length < r.stackIn)
+function P() {
+  const e2 = /* @__PURE__ */ new Map();
+  let t2 = 1;
+  return {
+    objects: e2,
+    nextId: t2,
+    allocate(r2, o2) {
+      const s2 = t2++, c2 = { id: s2, type: r2, data: o2 };
+      return e2.set(s2, c2), r2 === "array" ? { type: "array-ref", id: s2 } : { type: "object-ref", id: s2 };
+    },
+    get(r2) {
+      const o2 = e2.get(r2);
+      if (o2)
+        return o2;
+    }
+  };
+}
+class A {
+  createInitialState() {
+    return {
+      pc: 0,
+      stack: [],
+      variables: /* @__PURE__ */ new Map(),
+      status: "running",
+      output: [],
+      iterators: [],
+      heap: P()
+    };
+  }
+  executeInstruction(t2, r2) {
+    const o2 = F[r2.op];
+    if (!o2)
+      throw new Error(`Unknown opcode: ${r2.op}`);
+    const s2 = this.validateStack(o2, r2, t2);
+    if (s2) {
+      t2.status = "error", t2.error = s2.message;
+      return;
+    }
+    o2.execute(t2, r2), t2.pc++;
+  }
+  validateStack(t2, r2, o2) {
+    if (o2.stack.length < t2.stackIn)
       return {
         type: "StackUnderflow",
-        message: `${n$1[t2.op]}: Stack underflow`,
-        pc: s2.pc,
-        opcode: t2.op
+        message: `${n[r2.op]}: Stack underflow`,
+        pc: o2.pc,
+        opcode: r2.op
       };
   }
-  execute(r, t2) {
+  execute(t2, r2, o2) {
     const s2 = {
-      pc: (t2 == null ? void 0 : t2.pc) ?? 0,
-      stack: (t2 == null ? void 0 : t2.stack) ?? [],
-      variables: (t2 == null ? void 0 : t2.variables) ?? /* @__PURE__ */ new Map(),
+      pc: (r2 == null ? void 0 : r2.pc) ?? 0,
+      stack: (r2 == null ? void 0 : r2.stack) ?? [],
+      variables: (r2 == null ? void 0 : r2.variables) ?? /* @__PURE__ */ new Map(),
       status: "running",
-      output: (t2 == null ? void 0 : t2.output) ?? [],
-      iterators: (t2 == null ? void 0 : t2.iterators) ?? [],
-      ...t2
+      output: (r2 == null ? void 0 : r2.output) ?? [],
+      iterators: (r2 == null ? void 0 : r2.iterators) ?? [],
+      fileSystem: o2,
+      heap: (r2 == null ? void 0 : r2.heap) ?? P(),
+      ...r2
     };
-    for (; s2.status === "running" && s2.pc < r.length; ) {
-      const o2 = r[s2.pc], n2 = z[o2.op];
-      if (n2) {
-        const a2 = this.validateStack(n2, o2, s2);
-        if (a2) {
-          s2.status = "error", s2.error = a2.message;
+    for (; s2.status === "running" && s2.pc < t2.length; ) {
+      const c2 = t2[s2.pc], p3 = F[c2.op];
+      if (p3) {
+        const u2 = this.validateStack(p3, c2, s2);
+        if (u2) {
+          s2.status = "error", s2.error = u2.message;
           break;
         }
-        if ((o2.op === n$1.JUMP || o2.op === n$1.JUMP_IF_FALSE || o2.op === n$1.JUMP_IF || o2.op === n$1.JUMP_IF_TRUE || o2.op === n$1.BREAK || o2.op === n$1.CONTINUE) && o2.arg !== void 0 && o2.arg >= r.length) {
+        if ((c2.op === n.JUMP || c2.op === n.JUMP_IF_FALSE || c2.op === n.JUMP_IF || c2.op === n.JUMP_IF_TRUE || c2.op === n.BREAK || c2.op === n.CONTINUE) && c2.arg !== void 0 && c2.arg >= t2.length) {
           s2.status = "error";
-          const u2 = o2.op === n$1.JUMP || o2.op === n$1.JUMP_IF_FALSE || o2.op === n$1.JUMP_IF || o2.op === n$1.JUMP_IF_TRUE ? "jump" : o2.op === n$1.BREAK ? "break" : "continue";
-          s2.error = `Invalid ${u2} target: ${o2.arg}`;
+          const i2 = c2.op === n.JUMP || c2.op === n.JUMP_IF_FALSE || c2.op === n.JUMP_IF || c2.op === n.JUMP_IF_TRUE ? "jump" : c2.op === n.BREAK ? "break" : "continue";
+          s2.error = `Invalid ${i2} target: ${c2.arg}`;
           break;
         }
-        const i2 = n2.execute(s2, o2);
-        if (i2) {
-          s2.status = "error", s2.error = i2.message;
+        const a2 = p3.execute(s2, c2);
+        if (a2) {
+          const i2 = s2.pc + 1;
+          if (i2 < t2.length && t2[i2].op === n.CC) {
+            s2.ccPrompt = `ERROR: ${a2.message}. How should I proceed?`, s2.status = "waiting_cc", s2.pc = i2;
+            break;
+          }
+          s2.status = "error", s2.error = a2.message;
           break;
         }
-        n2.controlsPC || s2.pc++;
+        p3.controlsPC || s2.pc++;
         continue;
       }
-      s2.status = "error", s2.error = `Unknown opcode: ${n$1[o2.op]}`;
+      s2.status = "error", s2.error = `Unknown opcode: ${n[c2.op]}`;
       break;
     }
     return s2;
   }
-  resume(r, t2, s2) {
-    if (r.status !== "waiting_cc")
+  resume(t2, r2, o2, s2) {
+    if (t2.status !== "waiting_cc")
       throw new Error("Cannot resume: VM not waiting for CC");
-    const o2 = {
-      ...r,
-      stack: [...r.stack, t2],
+    const c2 = {
+      ...t2,
+      stack: [...t2.stack, r2],
       status: "running",
       ccPrompt: void 0,
-      pc: r.pc + 1
+      pc: t2.pc + 1
     };
-    return this.execute(s2, o2);
-  }
-  resumeWithFsResult(r, t2, s2) {
-    if (r.status !== "waiting_fs")
-      throw new Error("Cannot resume: VM not waiting for FS operation");
-    const o2 = {
-      ...r,
-      stack: [...r.stack, t2],
-      status: "running",
-      fsOperation: void 0,
-      pc: r.pc + 1
-    };
-    return this.execute(s2, o2);
+    return this.execute(o2, c2, s2 || t2.fileSystem);
   }
 }
-class P {
+class G {
   constructor() {
-    h2(this, "sandboxPaths", []);
-    const r = process.env.CVM_SANDBOX_PATHS, t2 = process.env.CVM_SANDBOX_ROOT;
-    r ? this.sandboxPaths = r.split(",").map((s2) => c__namespace.resolve(s2.trim())) : t2 && (this.sandboxPaths = [c__namespace.resolve(t2)]);
-  }
-  isPathAllowed(r) {
-    const t2 = c__namespace.resolve(r);
-    return t2.includes("..") || this.sandboxPaths.length === 0 ? false : this.sandboxPaths.some(
-      (s2) => t2.startsWith(s2)
+    _(this, "sandboxPaths", []);
+    const t2 = process.env.CVM_SANDBOX_PATHS, r2 = process.env.CVM_SANDBOX_ROOT;
+    t2 ? this.sandboxPaths = t2.split(",").map((o2) => r__namespace.resolve(o2.trim())) : r2 && (this.sandboxPaths = [r__namespace.resolve(r2)]);
+  }
+  isPathAllowed(t2) {
+    const r2 = r__namespace.resolve(t2);
+    return r2.includes("..") || this.sandboxPaths.length === 0 ? false : this.sandboxPaths.some(
+      (o2) => r2.startsWith(o2)
     );
   }
-  listFiles(r, t2 = {}) {
-    const s2 = d();
-    if (!this.isPathAllowed(r))
-      return s2;
+  listFiles(t2, r2 = {}) {
+    const o2 = s();
+    if (!this.isPathAllowed(t2))
+      return o2;
     try {
-      const o2 = c__namespace.resolve(r);
-      this.listFilesRecursive(o2, o2, s2.elements, t2);
+      const s2 = r__namespace.resolve(t2);
+      this.listFilesRecursive(s2, s2, o2.elements, r2);
     } catch {
     }
-    return s2;
+    return o2;
   }
-  matchesPattern(r, t2) {
-    let s2 = t2.replace(/\./g, "\\.").replace(/\*\*/g, "__DOUBLESTAR__").replace(/\*/g, "[^/]*").replace(/__DOUBLESTAR__/g, ".*").replace(/\?/g, ".");
-    s2 = "^" + s2 + "$";
+  matchesPattern(t2, r2) {
+    let o2 = r2.replace(/\./g, "\\.").replace(/\*\*/g, "__DOUBLESTAR__").replace(/\*/g, "[^/]*").replace(/__DOUBLESTAR__/g, ".*").replace(/\?/g, ".");
+    o2 = "^" + o2 + "$";
     try {
-      return new RegExp(s2).test(r);
+      return new RegExp(o2).test(t2);
     } catch {
       return true;
     }
   }
-  listFilesRecursive(r, t2, s2, o2, n2 = 0) {
+  listFilesRecursive(t2, r2, o2, s2, c2 = 0) {
     try {
-      const a2 = M__namespace.readdirSync(t2, { withFileTypes: true });
-      for (const i2 of a2) {
-        const u2 = c__namespace.join(t2, i2.name), O2 = c__namespace.relative(r, u2);
-        i2.isSymbolicLink() || o2.filter && !this.matchesPattern(O2, o2.filter) || (s2.push(u2), i2.isDirectory() && o2.recursive && this.listFilesRecursive(r, u2, s2, o2, n2 + 1));
+      const p3 = b__namespace.readdirSync(r2, { withFileTypes: true });
+      for (const u2 of p3) {
+        const a2 = r__namespace.join(r2, u2.name), i2 = r__namespace.relative(t2, a2);
+        u2.isSymbolicLink() || s2.filter && !this.matchesPattern(i2, s2.filter) || (o2.push(a2), u2.isDirectory() && s2.recursive && this.listFilesRecursive(t2, a2, o2, s2, c2 + 1));
       }
     } catch {
     }
   }
+  readFile(t2) {
+    if (!this.isPathAllowed(t2))
+      return null;
+    try {
+      const r2 = r__namespace.resolve(t2), o2 = b__namespace.lstatSync(r2);
+      return o2.isSymbolicLink() || !o2.isFile() ? null : b__namespace.readFileSync(r2, "utf-8");
+    } catch {
+      return null;
+    }
+  }
+  writeFile(t2, r2) {
+    if (!this.isPathAllowed(t2))
+      return false;
+    try {
+      const o2 = r__namespace.resolve(t2), s2 = r__namespace.dirname(o2);
+      if (!this.isPathAllowed(s2))
+        return false;
+      try {
+        if (b__namespace.lstatSync(o2).isSymbolicLink())
+          return false;
+      } catch (c2) {
+        if (c2.code !== "ENOENT")
+          return false;
+      }
+      return b__namespace.mkdirSync(s2, { recursive: true }), b__namespace.writeFileSync(o2, r2, "utf-8"), true;
+    } catch {
+      return false;
+    }
+  }
 }
-new P();
-class te {
-  constructor(r, t2) {
-    h2(this, "vms", /* @__PURE__ */ new Map());
-    h2(this, "storage");
-    h2(this, "fileSystem");
-    r ? this.storage = r : this.storage = E.create(), this.fileSystem = t2 || new P();
+new G();
+class fe {
+  constructor(t2, r2) {
+    _(this, "vms", /* @__PURE__ */ new Map());
+    _(this, "storage");
+    _(this, "fileSystem");
+    t2 ? this.storage = t2 : this.storage = E.create(), this.fileSystem = r2 || new G();
   }
   /**
    * Initialize the VMManager (connect to database)
@@ -1878,152 +2549,138 @@ class te {
   /**
    * Load and compile a program from source code
    */
-  async loadProgram(r, t2) {
-    const s2 = W$1(t2);
-    if (!s2.success)
-      throw new Error(`Compilation failed: ${s2.errors.join(", ")}`);
-    const o2 = {
-      id: r,
-      name: r,
-      source: t2,
-      bytecode: s2.bytecode,
+  async loadProgram(t2, r2) {
+    const o2 = j$2(r2);
+    if (!o2.success)
+      throw new Error(`Compilation failed: ${o2.errors.join(", ")}`);
+    const s2 = {
+      id: t2,
+      name: t2,
+      source: r2,
+      bytecode: o2.bytecode,
       // VM decides internal format
       created: /* @__PURE__ */ new Date()
     };
-    await this.storage.saveProgram(o2);
+    await this.storage.saveProgram(s2);
   }
   /**
    * Start execution of a loaded program
    */
-  async startExecution(r, t2) {
-    if (!await this.storage.getProgram(r))
-      throw new Error(`Program not found: ${r}`);
-    const o2 = {
-      id: t2,
-      programId: r,
+  async startExecution(t2, r2) {
+    if (!await this.storage.getProgram(t2))
+      throw new Error(`Program not found: ${t2}`);
+    const s2 = {
+      id: r2,
+      programId: t2,
       state: "READY",
       pc: 0,
       stack: [],
       variables: {},
       created: /* @__PURE__ */ new Date()
     };
-    await this.storage.saveExecution(o2);
-    const n2 = new N();
-    this.vms.set(t2, n2);
+    await this.storage.saveExecution(s2);
+    const c2 = new A();
+    this.vms.set(r2, c2);
   }
   /**
    * Get next action from execution (Claude polls this)
    * This is READ-ONLY - just returns current state
    */
-  async getNext(r) {
-    const t2 = await this.storage.getExecution(r);
-    if (!t2)
-      throw new Error(`Execution not found: ${r}`);
-    if (t2.state === "READY") {
-      const s2 = await this.storage.getProgram(t2.programId);
-      if (!s2)
-        throw new Error(`Program not found: ${t2.programId}`);
-      let o2 = this.vms.get(r);
-      o2 || (o2 = new N(), this.vms.set(r, o2));
-      const n2 = {
+  async getNext(t2) {
+    const r2 = await this.storage.getExecution(t2);
+    if (!r2)
+      throw new Error(`Execution not found: ${t2}`);
+    if (r2.state === "READY" || r2.state === "RUNNING") {
+      const o2 = await this.storage.getProgram(r2.programId);
+      if (!o2)
+        throw new Error(`Program not found: ${r2.programId}`);
+      let s2 = this.vms.get(t2);
+      s2 || (s2 = new A(), this.vms.set(t2, s2));
+      const c2 = r2.state === "READY" ? {
         pc: 0,
         stack: [],
         variables: /* @__PURE__ */ new Map(),
         output: []
-      }, a2 = o2.execute(s2.bytecode, n2);
-      if (a2.output.length > 0 && await this.storage.appendOutput(r, a2.output), t2.pc = a2.pc, t2.stack = a2.stack, t2.variables = Object.fromEntries(a2.variables), t2.iterators = a2.iterators, a2.status === "complete")
-        return t2.state = "COMPLETED", a2.returnValue !== void 0 && (t2.returnValue = a2.returnValue), await this.storage.saveExecution(t2), this.vms.delete(r), {
+      } : this.deserializeVMState(r2), p3 = s2.execute(o2.bytecode, c2, this.fileSystem);
+      p3.output.length > 0 && await this.storage.appendOutput(t2, p3.output);
+      const u2 = this.serializeVMState(p3);
+      if (Object.assign(r2, u2), p3.status === "complete")
+        return r2.state = "COMPLETED", p3.returnValue !== void 0 && (r2.returnValue = p3.returnValue), await this.storage.saveExecution(r2), this.vms.delete(t2), {
           type: "completed",
           message: "Execution completed",
-          result: a2.returnValue
+          result: p3.returnValue
         };
-      if (a2.status === "waiting_cc")
-        return t2.state = "AWAITING_COGNITIVE_RESULT", t2.ccPrompt = a2.ccPrompt, await this.storage.saveExecution(t2), {
+      if (p3.status === "waiting_cc")
+        return r2.state = "AWAITING_COGNITIVE_RESULT", r2.ccPrompt = p3.ccPrompt, await this.storage.saveExecution(r2), {
           type: "waiting",
-          message: a2.ccPrompt || "Waiting for input"
+          message: p3.ccPrompt || "Waiting for input"
         };
-      if (a2.status === "waiting_fs") {
-        if (a2.fsOperation) {
-          const i2 = this.fileSystem.listFiles(a2.fsOperation.path, a2.fsOperation.options), u2 = o2.resumeWithFsResult(a2, i2, s2.bytecode);
-          return u2.output.length > 0 && await this.storage.appendOutput(r, u2.output), t2.pc = u2.pc, t2.stack = u2.stack, t2.variables = Object.fromEntries(u2.variables), t2.iterators = u2.iterators, u2.status === "complete" ? (t2.state = "COMPLETED", u2.returnValue !== void 0 && (t2.returnValue = u2.returnValue), await this.storage.saveExecution(t2), this.vms.delete(r), {
-            type: "completed",
-            message: "Execution completed",
-            result: u2.returnValue
-          }) : u2.status === "error" ? (t2.state = "ERROR", t2.error = u2.error, await this.storage.saveExecution(t2), this.vms.delete(r), {
-            type: "error",
-            error: u2.error
-          }) : u2.status === "waiting_cc" ? (t2.state = "AWAITING_COGNITIVE_RESULT", t2.ccPrompt = u2.ccPrompt, await this.storage.saveExecution(t2), {
-            type: "waiting",
-            message: u2.ccPrompt || "Waiting for input"
-          }) : (t2.state = "RUNNING", await this.storage.saveExecution(t2), this.getNext(r));
-        }
-      } else if (a2.status === "error")
-        return t2.state = "ERROR", t2.error = a2.error, await this.storage.saveExecution(t2), this.vms.delete(r), {
+      if (p3.status === "error")
+        return r2.state = "ERROR", r2.error = p3.error, await this.storage.saveExecution(r2), this.vms.delete(t2), {
           type: "error",
-          error: a2.error
+          error: p3.error
         };
     }
-    if (t2.state === "COMPLETED")
+    if (r2.state === "COMPLETED")
       return {
         type: "completed",
         message: "Execution completed"
       };
-    if (t2.state === "ERROR")
+    if (r2.state === "ERROR")
       return {
         type: "error",
-        error: t2.error || "Unknown error"
+        error: r2.error || "Unknown error"
       };
-    if (t2.state === "AWAITING_COGNITIVE_RESULT")
+    if (r2.state === "AWAITING_COGNITIVE_RESULT")
       return {
         type: "waiting",
-        message: t2.ccPrompt || "Waiting for input"
+        message: r2.ccPrompt || "Waiting for input"
       };
-    throw new Error(`Unexpected execution state: ${t2.state}`);
+    throw new Error(`Unexpected execution state: ${r2.state}`);
   }
   /**
    * Report result from cognitive operation and continue execution
    */
-  async reportCCResult(r, t2) {
-    const s2 = await this.storage.getExecution(r);
-    if (!s2)
-      throw new Error(`Execution not found: ${r}`);
-    const o2 = await this.storage.getProgram(s2.programId);
+  async reportCCResult(t2, r2) {
+    const o2 = await this.storage.getExecution(t2);
     if (!o2)
-      throw new Error(`Program not found: ${s2.programId}`);
-    let n2 = this.vms.get(r);
-    n2 || (n2 = new N(), this.vms.set(r, n2));
-    const a2 = {
-      pc: s2.pc,
-      stack: s2.stack,
-      variables: new Map(Object.entries(s2.variables)),
+      throw new Error(`Execution not found: ${t2}`);
+    const s2 = await this.storage.getProgram(o2.programId);
+    if (!s2)
+      throw new Error(`Program not found: ${o2.programId}`);
+    let c2 = this.vms.get(t2);
+    c2 || (c2 = new A(), this.vms.set(t2, c2));
+    const p3 = {
+      ...this.deserializeVMState(o2),
       status: "waiting_cc",
       output: [],
       // Start with empty output for resumed execution
-      ccPrompt: void 0,
-      iterators: s2.iterators || []
-    }, i2 = n2.resume(a2, t2, o2.bytecode);
-    i2.output.length > 0 && await this.storage.appendOutput(r, i2.output), s2.pc = i2.pc, s2.stack = i2.stack, s2.variables = Object.fromEntries(i2.variables), s2.iterators = i2.iterators, i2.status === "complete" ? (s2.state = "COMPLETED", i2.returnValue !== void 0 && (s2.returnValue = i2.returnValue), this.vms.delete(r)) : i2.status === "error" ? (s2.state = "ERROR", s2.error = i2.error, this.vms.delete(r)) : i2.status === "waiting_cc" ? (s2.state = "AWAITING_COGNITIVE_RESULT", s2.ccPrompt = i2.ccPrompt) : s2.state = "RUNNING", await this.storage.saveExecution(s2);
+      ccPrompt: void 0
+    }, u2 = c2.resume(p3, r2, s2.bytecode, this.fileSystem);
+    u2.output.length > 0 && await this.storage.appendOutput(t2, u2.output);
+    const a2 = this.serializeVMState(u2);
+    Object.assign(o2, a2), u2.status === "complete" ? (o2.state = "COMPLETED", u2.returnValue !== void 0 && (o2.returnValue = u2.returnValue), this.vms.delete(t2)) : u2.status === "error" ? (o2.state = "ERROR", o2.error = u2.error, this.vms.delete(t2)) : u2.status === "waiting_cc" ? (o2.state = "AWAITING_COGNITIVE_RESULT", o2.ccPrompt = u2.ccPrompt) : o2.state = "RUNNING", await this.storage.saveExecution(o2);
   }
   /**
    * Get current execution status
    */
-  async getExecutionStatus(r) {
-    const t2 = await this.storage.getExecution(r);
-    if (!t2)
-      throw new Error(`Execution not found: ${r}`);
+  async getExecutionStatus(t2) {
+    const r2 = await this.storage.getExecution(t2);
+    if (!r2)
+      throw new Error(`Execution not found: ${t2}`);
     return {
-      id: t2.id,
-      state: t2.state,
-      pc: t2.pc,
-      stack: t2.stack,
-      variables: t2.variables
+      id: r2.id,
+      state: r2.state,
+      pc: r2.pc,
+      stack: r2.stack,
+      variables: r2.variables
     };
   }
   /**
    * Get output for an execution
    */
-  async getExecutionOutput(r) {
-    return await this.storage.getOutput(r);
+  async getExecutionOutput(t2) {
+    return await this.storage.getOutput(t2);
   }
   /**
    * List all executions
@@ -2040,35 +2697,138 @@ class te {
   /**
    * Set current execution ID
    */
-  async setCurrentExecutionId(r) {
-    return await this.storage.setCurrentExecutionId(r);
+  async setCurrentExecutionId(t2) {
+    return await this.storage.setCurrentExecutionId(t2);
   }
   /**
    * Delete an execution
    */
-  async deleteExecution(r) {
-    return await this.storage.deleteExecution(r);
+  async deleteExecution(t2) {
+    return this.vms.delete(t2), await this.storage.deleteExecution(t2);
   }
   /**
    * Get execution with attempt tracking
    */
-  async getExecutionWithAttempts(r) {
-    const t2 = await this.storage.getExecution(r);
-    if (!t2)
-      throw new Error(`Execution not found: ${r}`);
+  async getExecutionWithAttempts(t2) {
+    const r2 = await this.storage.getExecution(t2);
+    if (!r2)
+      throw new Error(`Execution not found: ${t2}`);
+    return r2;
+  }
+  /**
+   * List all programs
+   */
+  async listPrograms() {
+    return await this.storage.listPrograms();
+  }
+  /**
+   * Delete a program
+   */
+  async deleteProgram(t2) {
+    return await this.storage.deleteProgram(t2);
+  }
+  /**
+   * Restart a program (create new execution and set as current)
+   */
+  async restartExecution(t2, r2) {
+    const o2 = r2 || `${t2}-${Date.now()}`;
+    return await this.startExecution(t2, o2), await this.setCurrentExecutionId(o2), o2;
+  }
+  /**
+   * Serialize heap to storage format
+   */
+  serializeHeap(t2) {
+    const r2 = (s2, c2) => u$1(c2) || b(c2) ? { $ref: c2.id } : c2, o2 = {};
+    return t2.objects.forEach((s2, c2) => {
+      o2[c2] = {
+        type: s2.type,
+        // Serialize each object's data individually with replacer
+        data: JSON.parse(JSON.stringify(s2.data, r2))
+      };
+    }), {
+      objects: o2,
+      nextId: t2.nextId
+    };
+  }
+  /**
+   * Deserialize heap from storage format
+   */
+  deserializeHeap(t2) {
+    const r2 = P();
+    r2.nextId = t2.nextId;
+    for (const o2 in t2.objects) {
+      const s2 = parseInt(o2, 10), c2 = t2.objects[s2];
+      r2.objects.set(s2, {
+        id: s2,
+        type: c2.type,
+        data: c2.data
+        // Still contains $ref stubs
+      });
+    }
+    return r2.objects.forEach((o2) => {
+      o2.data = this.restoreReferences(o2.data, r2);
+    }), r2;
+  }
+  /**
+   * Serialize VM state for storage
+   */
+  serializeVMState(t2) {
+    return {
+      pc: t2.pc,
+      stack: t2.stack,
+      variables: Object.fromEntries(t2.variables),
+      heap: t2.heap ? this.serializeHeap(t2.heap) : void 0,
+      iterators: t2.iterators,
+      status: t2.status,
+      error: t2.error,
+      ccPrompt: t2.ccPrompt,
+      output: t2.output,
+      returnValue: t2.returnValue
+    };
+  }
+  /**
+   * Deserialize VM state from storage
+   */
+  deserializeVMState(t2) {
+    return {
+      pc: t2.pc || 0,
+      stack: t2.stack || [],
+      variables: new Map(Object.entries(t2.variables || {})),
+      heap: t2.heap ? this.deserializeHeap(t2.heap) : P(),
+      iterators: t2.iterators || [],
+      status: t2.status || "running",
+      error: t2.error || null,
+      ccPrompt: t2.ccPrompt || null,
+      output: t2.output || [],
+      returnValue: t2.returnValue
+    };
+  }
+  restoreReferences(t2, r2) {
+    if (t2 && typeof t2 == "object" && t2.$ref !== void 0) {
+      const o2 = r2.objects.get(t2.$ref);
+      return (o2 == null ? void 0 : o2.type) === "array" ? { type: "array-ref", id: t2.$ref } : (o2 == null ? void 0 : o2.type) === "object" ? { type: "object-ref", id: t2.$ref } : t2;
+    }
+    if (Array.isArray(t2))
+      return t2.map((o2) => this.restoreReferences(o2, r2));
+    if (t2 && typeof t2 == "object") {
+      const o2 = {};
+      for (const s2 in t2)
+        o2[s2] = this.restoreReferences(t2[s2], r2);
+      return o2;
+    }
     return t2;
   }
 }
 var u = Object.defineProperty;
-var x = (s2, r, e2) => r in s2 ? u(s2, r, { enumerable: true, configurable: true, writable: true, value: e2 }) : s2[r] = e2;
-var i = (s2, r, e2) => x(s2, typeof r != "symbol" ? r + "" : r, e2);
-class M {
-  constructor(r = "0.0.1") {
+var x = (s2, e2, r2) => e2 in s2 ? u(s2, e2, { enumerable: true, configurable: true, writable: true, value: r2 }) : s2[e2] = r2;
+var i = (s2, e2, r2) => x(s2, typeof e2 != "symbol" ? e2 + "" : e2, r2);
+class $ {
+  constructor(e2 = "0.0.1") {
     i(this, "server");
     i(this, "transport", null);
     i(this, "vmManager");
     i(this, "version");
-    this.version = r, this.vmManager = new te(), this.server = new mcp_js.McpServer({
+    this.version = e2, this.vmManager = new fe(), this.server = new mcp_js.McpServer({
       name: "cvm-server",
       version: this.version
     }), this.setupTools();
@@ -2086,10 +2846,10 @@ class M {
         programId: zod.z.string(),
         source: zod.z.string()
       },
-      async ({ programId: r, source: e2 }) => {
+      async ({ programId: e2, source: r2 }) => {
         try {
-          return await this.vmManager.loadProgram(r, e2), {
-            content: [{ type: "text", text: `Program loaded successfully: ${r}` }]
+          return await this.vmManager.loadProgram(e2, r2), {
+            content: [{ type: "text", text: `Program loaded successfully: ${e2}` }]
           };
         } catch (t2) {
           return {
@@ -2104,23 +2864,23 @@ class M {
         programId: zod.z.string(),
         filePath: zod.z.string()
       },
-      async ({ programId: r, filePath: e2 }) => {
+      async ({ programId: e2, filePath: r$1 }) => {
         try {
-          const t2 = c$1.resolve(e2), n2 = await promises.readFile(t2, "utf-8");
-          return await this.vmManager.loadProgram(r, n2), {
-            content: [{ type: "text", text: `Program loaded successfully from ${e2}: ${r}` }]
+          const t2 = r.resolve(r$1), n2 = await promises.readFile(t2, "utf-8");
+          return await this.vmManager.loadProgram(e2, n2), {
+            content: [{ type: "text", text: `Program loaded successfully from ${r$1}: ${e2}` }]
           };
         } catch (t2) {
           if (t2 instanceof Error) {
             const n2 = t2;
             if (n2.code === "ENOENT")
               return {
-                content: [{ type: "text", text: `Error: File not found: ${e2}` }],
+                content: [{ type: "text", text: `Error: File not found: ${r$1}` }],
                 isError: true
               };
             if (n2.code === "EACCES")
               return {
-                content: [{ type: "text", text: `Error: Permission denied: ${e2}` }],
+                content: [{ type: "text", text: `Error: Permission denied: ${r$1}` }],
                 isError: true
               };
           }
@@ -2137,10 +2897,10 @@ class M {
         executionId: zod.z.string(),
         setCurrent: zod.z.boolean().optional()
       },
-      async ({ programId: r, executionId: e2, setCurrent: t2 = true }) => {
+      async ({ programId: e2, executionId: r2, setCurrent: t2 = true }) => {
         try {
-          return await this.vmManager.startExecution(r, e2), t2 && await this.vmManager.setCurrentExecutionId(e2), {
-            content: [{ type: "text", text: `Execution started: ${e2}${t2 ? " (set as current)" : ""}` }]
+          return await this.vmManager.startExecution(e2, r2), t2 && await this.vmManager.setCurrentExecutionId(r2), {
+            content: [{ type: "text", text: `Execution started: ${r2}${t2 ? " (set as current)" : ""}` }]
           };
         } catch (n2) {
           return {
@@ -2154,18 +2914,18 @@ class M {
       {
         executionId: zod.z.string().optional()
       },
-      async ({ executionId: r }) => {
+      async ({ executionId: e2 }) => {
         try {
-          let e2 = r;
-          if (!e2) {
+          let r2 = e2;
+          if (!r2) {
             const n2 = await this.vmManager.getCurrentExecutionId();
             if (!n2)
               return {
                 content: [{ type: "text", text: "No current execution set. Use list_executions to see available executions." }]
               };
-            e2 = n2;
+            r2 = n2;
           }
-          const t2 = await this.vmManager.getNext(e2);
+          const t2 = await this.vmManager.getNext(r2);
           return t2.type === "completed" ? {
             content: [{ type: "text", text: t2.result !== void 0 ? `Execution completed with result: ${JSON.stringify(t2.result)}` : "Execution completed" }]
           } : t2.type === "waiting" ? {
@@ -2177,9 +2937,9 @@ class M {
             content: [{ type: "text", text: "Unexpected state" }],
             isError: true
           };
-        } catch (e2) {
+        } catch (r2) {
           return {
-            content: [{ type: "text", text: `Error: ${e2 instanceof Error ? e2.message : "Unknown error"}` }],
+            content: [{ type: "text", text: `Error: ${r2 instanceof Error ? r2.message : "Unknown error"}` }],
             isError: true
           };
         }
@@ -2190,9 +2950,9 @@ class M {
         executionId: zod.z.string().optional(),
         result: zod.z.string()
       },
-      async ({ executionId: r, result: e2 }) => {
+      async ({ executionId: e2, result: r2 }) => {
         try {
-          let t2 = r;
+          let t2 = e2;
           if (!t2) {
             const n2 = await this.vmManager.getCurrentExecutionId();
             if (!n2)
@@ -2202,7 +2962,7 @@ class M {
               };
             t2 = n2;
           }
-          return await this.vmManager.reportCCResult(t2, e2), {
+          return await this.vmManager.reportCCResult(t2, r2), {
             content: [{ type: "text", text: "Execution resumed" }]
           };
         } catch (t2) {
@@ -2217,25 +2977,25 @@ class M {
       {
         executionId: zod.z.string().optional()
       },
-      async ({ executionId: r }) => {
+      async ({ executionId: e2 }) => {
         try {
-          let e2 = r;
-          if (!e2) {
+          let r2 = e2;
+          if (!r2) {
             const n2 = await this.vmManager.getCurrentExecutionId();
             if (!n2)
               return {
                 content: [{ type: "text", text: "Error: No current execution set" }],
                 isError: true
               };
-            e2 = n2;
+            r2 = n2;
           }
-          const t2 = await this.vmManager.getExecutionStatus(e2);
+          const t2 = await this.vmManager.getExecutionStatus(r2);
           return {
             content: [{ type: "text", text: JSON.stringify(t2, null, 2) }]
           };
-        } catch (e2) {
+        } catch (r2) {
           return {
-            content: [{ type: "text", text: `Error: ${e2 instanceof Error ? e2.message : "Unknown error"}` }],
+            content: [{ type: "text", text: `Error: ${r2 instanceof Error ? r2.message : "Unknown error"}` }],
             isError: true
           };
         }
@@ -2245,12 +3005,12 @@ class M {
       {},
       async () => {
         try {
-          const r = await this.vmManager.listExecutions(), e2 = await this.vmManager.getCurrentExecutionId(), t2 = r.map((n2) => ({
+          const e2 = await this.vmManager.listExecutions(), r2 = await this.vmManager.getCurrentExecutionId(), t2 = e2.map((n2) => ({
             executionId: n2.id,
             programId: n2.programId,
             state: n2.state,
             created: n2.created,
-            isCurrent: n2.id === e2,
+            isCurrent: n2.id === r2,
             summary: {
               currentPrompt: n2.state === "AWAITING_COGNITIVE_RESULT" ? n2.ccPrompt : void 0,
               tasksCompleted: 0
@@ -2260,9 +3020,9 @@ class M {
           return {
             content: [{ type: "text", text: JSON.stringify(t2, null, 2) }]
           };
-        } catch (r) {
+        } catch (e2) {
           return {
-            content: [{ type: "text", text: `Error: ${r instanceof Error ? r.message : "Unknown error"}` }],
+            content: [{ type: "text", text: `Error: ${e2 instanceof Error ? e2.message : "Unknown error"}` }],
             isError: true
           };
         }
@@ -2272,19 +3032,19 @@ class M {
       {
         executionId: zod.z.string().optional()
       },
-      async ({ executionId: r }) => {
+      async ({ executionId: e2 }) => {
         try {
-          let e2 = r;
-          if (!e2) {
+          let r2 = e2;
+          if (!r2) {
             const a2 = await this.vmManager.getCurrentExecutionId();
             if (!a2)
               return {
                 content: [{ type: "text", text: "Error: No current execution set" }],
                 isError: true
               };
-            e2 = a2;
+            r2 = a2;
           }
-          const t2 = await this.vmManager.getExecutionWithAttempts(e2), n2 = await this.vmManager.getCurrentExecutionId(), c2 = {
+          const t2 = await this.vmManager.getExecutionWithAttempts(r2), n2 = await this.vmManager.getCurrentExecutionId(), c2 = {
             executionId: t2.id,
             programId: t2.programId,
             state: t2.state,
@@ -2305,9 +3065,9 @@ class M {
           return {
             content: [{ type: "text", text: JSON.stringify(c2, null, 2) }]
           };
-        } catch (e2) {
+        } catch (r2) {
           return {
-            content: [{ type: "text", text: `Error: ${e2 instanceof Error ? e2.message : "Unknown error"}` }],
+            content: [{ type: "text", text: `Error: ${r2 instanceof Error ? r2.message : "Unknown error"}` }],
             isError: true
           };
         }
@@ -2317,14 +3077,14 @@ class M {
       {
         executionId: zod.z.string()
       },
-      async ({ executionId: r }) => {
+      async ({ executionId: e2 }) => {
         try {
-          return await this.vmManager.setCurrentExecutionId(r), {
-            content: [{ type: "text", text: `Current execution set to: ${r}` }]
+          return await this.vmManager.setCurrentExecutionId(e2), {
+            content: [{ type: "text", text: `Current execution set to: ${e2}` }]
           };
-        } catch (e2) {
+        } catch (r2) {
           return {
-            content: [{ type: "text", text: `Error: ${e2 instanceof Error ? e2.message : "Unknown error"}` }],
+            content: [{ type: "text", text: `Error: ${r2 instanceof Error ? r2.message : "Unknown error"}` }],
             isError: true
           };
         }
@@ -2335,11 +3095,11 @@ class M {
         executionId: zod.z.string(),
         confirmToken: zod.z.string().optional()
       },
-      async ({ executionId: r, confirmToken: e2 }) => {
+      async ({ executionId: e2, confirmToken: r2 }) => {
         try {
-          const t2 = `delete-${r}-${Date.now()}`;
-          return e2 ? e2 && e2.startsWith(`delete-${r}-`) ? (await this.vmManager.deleteExecution(r), {
-            content: [{ type: "text", text: `Execution deleted: ${r}` }]
+          const t2 = `delete-${e2}-${Date.now()}`;
+          return r2 ? r2 && r2.startsWith(`delete-${e2}-`) ? (await this.vmManager.deleteExecution(e2), {
+            content: [{ type: "text", text: `Execution deleted: ${e2}` }]
           }) : {
             content: [{ type: "text", text: "Invalid confirmation token" }],
             isError: true
@@ -2348,7 +3108,7 @@ class M {
               type: "text",
               text: JSON.stringify({
                 confirmationRequired: true,
-                message: `To delete execution '${r}', call this tool again with the confirmation token`,
+                message: `To delete execution '${e2}', call this tool again with the confirmation token`,
                 token: t2
               }, null, 2)
             }]
@@ -2360,10 +3120,84 @@ class M {
           };
         }
       }
+    ), this.server.tool(
+      "list_programs",
+      {},
+      async () => {
+        try {
+          const e2 = await this.vmManager.listPrograms();
+          if (e2.length === 0)
+            return {
+              content: [{ type: "text", text: "No programs loaded" }]
+            };
+          const r2 = e2.map((t2) => ({
+            programId: t2.id,
+            name: t2.name,
+            created: t2.created
+          }));
+          return {
+            content: [{ type: "text", text: JSON.stringify(r2, null, 2) }]
+          };
+        } catch (e2) {
+          return {
+            content: [{ type: "text", text: `Error: ${e2 instanceof Error ? e2.message : "Unknown error"}` }],
+            isError: true
+          };
+        }
+      }
+    ), this.server.tool(
+      "delete_program",
+      {
+        programId: zod.z.string(),
+        confirmToken: zod.z.string().optional()
+      },
+      async ({ programId: e2, confirmToken: r2 }) => {
+        try {
+          const t2 = `delete-${e2}-${Date.now()}`;
+          return r2 ? r2 && r2.startsWith(`delete-${e2}-`) ? (await this.vmManager.deleteProgram(e2), {
+            content: [{ type: "text", text: `Program deleted: ${e2}` }]
+          }) : {
+            content: [{ type: "text", text: "Invalid confirmation token" }],
+            isError: true
+          } : {
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                confirmationRequired: true,
+                message: `To delete program '${e2}', call this tool again with the confirmation token`,
+                token: t2
+              }, null, 2)
+            }]
+          };
+        } catch (t2) {
+          return {
+            content: [{ type: "text", text: `Error: ${t2 instanceof Error ? t2.message : "Unknown error"}` }],
+            isError: true
+          };
+        }
+      }
+    ), this.server.tool(
+      "restart",
+      {
+        programId: zod.z.string(),
+        executionId: zod.z.string().optional()
+      },
+      async ({ programId: e2, executionId: r2 }) => {
+        try {
+          return {
+            content: [{ type: "text", text: `Execution started: ${await this.vmManager.restartExecution(e2, r2)} (set as current)` }]
+          };
+        } catch (t2) {
+          return {
+            content: [{ type: "text", text: `Error: ${t2 instanceof Error ? t2.message : "Unknown error"}` }],
+            isError: true
+          };
+        }
+      }
     );
   }
-  async start(r) {
-    await this.vmManager.initialize(), this.transport = r || new stdio_js.StdioServerTransport(), await this.server.connect(this.transport);
+  async start(e2) {
+    await this.vmManager.initialize(), this.transport = e2 || new stdio_js.StdioServerTransport(), await this.server.connect(this.transport);
   }
   async stop() {
     this.transport && (await this.transport.close(), this.transport = null), await this.vmManager.dispose();
@@ -2373,7 +3207,7 @@ class M {
     return this.vmManager;
   }
 }
-dotenv__namespace.config({ path: c$1.resolve(__dirname, "../../../.env") });
+dotenv__namespace.config({ path: r.resolve(__dirname, "../../../.env") });
 function loadConfig() {
   const env = process.env.NODE_ENV || "development";
   const storageType = process.env.CVM_STORAGE_TYPE || "file";
@@ -2454,7 +3288,7 @@ function getLogger() {
   return logger;
 }
 const __filename$1 = url.fileURLToPath(typeof document === "undefined" ? require("url").pathToFileURL(__filename).href : _documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === "SCRIPT" && _documentCurrentScript.src || new URL("main.cjs", document.baseURI).href);
-const __dirname$1 = c$1.dirname(__filename$1);
+const __dirname$1 = r.dirname(__filename$1);
 async function main() {
   let cvmServer;
   try {
@@ -2463,16 +3297,16 @@ async function main() {
     const logger2 = getLogger();
     let version = "0.4.3";
     const possiblePaths = [
-      c$1.join(__dirname$1, "..", "package.json"),
+      r.join(__dirname$1, "..", "package.json"),
       // Development
-      c$1.join(__dirname$1, "package.json"),
+      r.join(__dirname$1, "package.json"),
       // Bundled dist
-      c$1.join(process.cwd(), "package.json")
+      r.join(process.cwd(), "package.json")
       // Current directory
     ];
     for (const packageJsonPath of possiblePaths) {
       try {
-        const packageJson = JSON.parse(M$2.readFileSync(packageJsonPath, "utf-8"));
+        const packageJson = JSON.parse(b$2.readFileSync(packageJsonPath, "utf-8"));
         if (packageJson.name === "cvm-server" && packageJson.version) {
           version = packageJson.version;
           break;
@@ -2487,13 +3321,13 @@ async function main() {
     });
     if (config.storage.type === "file") {
       const dataDir = config.storage.dataDir || ".cvm";
-      const fullPath = c$1.resolve(process.cwd(), dataDir);
+      const fullPath = r.resolve(process.cwd(), dataDir);
       logger2.info(`[CVM] Initializing file storage in: ${fullPath}`);
       logger2.warn(`[CVM] ⚠️  Remember to add '${dataDir}/' to your .gitignore file!`);
     } else {
       logger2.info("[CVM] Using MongoDB storage");
     }
-    cvmServer = new M(version);
+    cvmServer = new $(version);
     await cvmServer.start();
     logger2.info("CVM Server is running and ready to accept MCP connections");
     process.on("SIGINT", async () => {