cvm-server 0.9.1 → 0.10.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 n$1 = require("typescript");
-const G$1 = require("fs");
-const c$2 = require("path");
+const i$2 = require("typescript");
+const M$2 = require("fs");
+const c$1 = require("path");
 const mongodb = require("mongodb");
 const promises = require("fs/promises");
 const dotenv = require("dotenv");
@@ -26,51 +26,47 @@ function _interopNamespaceDefault(e2) {
   n2.default = e2;
   return Object.freeze(n2);
 }
-const n__namespace = /* @__PURE__ */ _interopNamespaceDefault(n$1);
-const G__namespace = /* @__PURE__ */ _interopNamespaceDefault(G$1);
-const c__namespace = /* @__PURE__ */ _interopNamespaceDefault(c$2);
+const i__namespace = /* @__PURE__ */ _interopNamespaceDefault(i$2);
+const M__namespace = /* @__PURE__ */ _interopNamespaceDefault(M$2);
+const c__namespace = /* @__PURE__ */ _interopNamespaceDefault(c$1);
 const dotenv__namespace = /* @__PURE__ */ _interopNamespaceDefault(dotenv);
-var p$2 = Object.defineProperty;
-var f$1 = (e2, t2, s2) => t2 in e2 ? p$2(e2, t2, { enumerable: true, configurable: true, writable: true, value: s2 }) : e2[t2] = s2;
-var x$1 = (e2, t2, s2) => f$1(e2, typeof t2 != "symbol" ? t2 + "" : t2, s2);
-var i$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.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))(i$1 || {});
+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 || {});
 function R(e2) {
   const t2 = [], s2 = [];
-  let r2 = false, a2 = false;
-  const m2 = n__namespace.createSourceFile(
+  let r = false;
+  const a2 = i__namespace.createSourceFile(
     "program.ts",
     e2,
-    n__namespace.ScriptTarget.Latest,
+    i__namespace.ScriptTarget.Latest,
     true
   );
-  function l2(o2) {
-    if (n__namespace.isFunctionDeclaration(o2) && o2.name && o2.name.text === "main" && (r2 = true, o2.parameters.length > 0 && t2.push("main() must not have parameters")), n__namespace.isExpressionStatement(o2) && o2.parent === m2) {
-      const c2 = o2.expression;
-      n__namespace.isCallExpression(c2) && n__namespace.isIdentifier(c2.expression) && c2.expression.text === "main" && (a2 = 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}`);
     }
-    if (n__namespace.isCallExpression(o2) && n__namespace.isIdentifier(o2.expression)) {
-      const c2 = o2.expression.text;
-      ["setTimeout", "fetch", "require", "import"].includes(c2) && t2.push(`Unsupported function: ${c2}`);
-    }
-    n__namespace.forEachChild(o2, l2);
+    i__namespace.forEachChild(c2, S);
   }
-  return l2(m2), r2 || t2.push("Program must have a main() function"), r2 && !a2 && t2.push("main() must be called at the top level"), t2.length === 0 && s2.push({ op: i$1.HALT }), {
+  return S(a2), r || t2.push("Program must have a main() function"), t2.length === 0 && s2.push({ op: n$1.HALT }), {
     bytecode: s2,
     errors: t2,
-    hasMain: r2
+    hasMain: r
   };
 }
 let A$1 = class A {
   constructor() {
-    x$1(this, "bytecode", []);
-    x$1(this, "contextStack", []);
+    T$1(this, "bytecode", []);
+    T$1(this, "contextStack", []);
   }
   /**
    * Emit an instruction and return its index
    */
   emit(t2, s2) {
-    const r2 = this.bytecode.length;
-    return this.bytecode.push({ op: t2, arg: s2 }), r2;
+    const r = this.bytecode.length;
+    return this.bytecode.push({ op: t2, arg: s2 }), r;
   }
   /**
    * Get the current address (next instruction index)
@@ -88,7 +84,7 @@ let A$1 = class A {
    * Patch multiple jump instructions with the same target
    */
   patchJumps(t2, s2) {
-    t2.forEach((r2) => this.patchJump(r2, s2));
+    t2.forEach((r) => this.patchJump(r, s2));
   }
   /**
    * Push a new jump context onto the stack
@@ -138,320 +134,322 @@ let A$1 = class A {
     return [...this.contextStack];
   }
 };
-const P$1 = (e2, t2, { compileExpression: s2, compileStatement: r2 }) => {
+const P$1 = (e2, t2, { compileExpression: s2, compileStatement: r }) => {
   s2(e2.expression);
-  const a2 = t2.emit(i$1.JUMP_IF_FALSE, -1), m2 = {
+  const a2 = t2.emit(n$1.JUMP_IF_FALSE, -1), S = {
     type: "if",
     endTargets: []
   };
-  if (e2.elseStatement ? m2.elseTarget = a2 : m2.endTargets.push(a2), t2.pushContext(m2), r2(e2.thenStatement), e2.elseStatement) {
-    const o2 = t2.emit(i$1.JUMP, -1);
-    m2.endTargets.push(o2);
-    const c2 = t2.currentAddress();
-    t2.patchJump(a2, c2), r2(e2.elseStatement);
-  }
-  const l2 = t2.popContext();
-  if (l2) {
+  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(l2.endTargets, o2);
+    t2.patchJumps(c2.endTargets, o2);
   }
-}, I = (e2, t2, { compileExpression: s2, compileStatement: r2 }) => {
+}, I = (e2, t2, { compileExpression: s2, compileStatement: r }) => {
   const a2 = t2.currentAddress();
   s2(e2.expression);
-  const l2 = {
+  const c2 = {
     type: "loop",
-    breakTargets: [t2.emit(i$1.JUMP_IF_FALSE, -1)],
+    breakTargets: [t2.emit(n$1.JUMP_IF_FALSE, -1)],
     continueTargets: [],
     endTargets: [],
     startAddress: a2
   };
-  t2.pushContext(l2), r2(e2.statement), t2.emit(i$1.JUMP, a2);
+  t2.pushContext(c2), r(e2.statement), t2.emit(n$1.JUMP, a2);
   const o2 = t2.popContext();
   if (o2) {
-    const c2 = t2.currentAddress();
-    t2.patchJumps(o2.breakTargets || [], c2);
-  }
-}, h$2 = (e2, t2, { compileExpression: s2, compileStatement: r2 }) => {
-  const a2 = e2.initializer, m2 = e2.expression;
-  let l2;
-  if (n__namespace.isVariableDeclarationList(a2))
-    l2 = a2.declarations[0].name.getText();
-  else if (n__namespace.isIdentifier(a2))
-    l2 = a2.text;
+    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;
   else
     throw new Error("Unsupported for-of variable declaration");
-  s2(m2), t2.emit(i$1.ITER_START);
+  s2(S), t2.emit(n$1.ITER_START);
   const o2 = t2.currentAddress();
-  t2.emit(i$1.ITER_NEXT);
-  const c2 = t2.emit(i$1.JUMP_IF_FALSE, -1);
-  t2.emit(i$1.STORE, l2);
-  const S = {
+  t2.emit(n$1.ITER_NEXT);
+  const m2 = t2.emit(n$1.JUMP_IF_FALSE, -1);
+  t2.emit(n$1.STORE, c2);
+  const l2 = {
     type: "foreach",
-    breakTargets: [c2],
+    breakTargets: [m2],
     continueTargets: [],
     endTargets: [],
     startAddress: o2,
-    iterVariable: l2
+    iterVariable: c2
   };
-  t2.pushContext(S), r2(e2.statement), t2.emit(i$1.JUMP, o2);
+  t2.pushContext(l2), r(e2.statement), t2.emit(n$1.JUMP, o2);
   const u2 = t2.popContext();
   if (u2) {
-    const E = t2.currentAddress();
-    t2.patchJumps(u2.breakTargets || [], E), t2.emit(i$1.ITER_END);
+    const E2 = t2.currentAddress();
+    t2.patchJumps(u2.breakTargets || [], E2), t2.emit(n$1.ITER_END);
   }
 }, y$1 = (e2, t2, { compileStatement: s2 }) => {
-  e2.statements.forEach((r2) => {
-    s2(r2);
+  e2.statements.forEach((r) => {
+    s2(r);
   });
 }, N$1 = (e2, t2, { compileExpression: s2 }) => {
-  const r2 = e2.declarationList.declarations[0];
-  r2.initializer && (s2(r2.initializer), t2.emit(i$1.STORE, r2.name.getText()));
-}, g$2 = (e2, t2, { compileExpression: s2 }) => {
-  const r2 = e2.expression;
-  if (n__namespace.isBinaryExpression(r2)) {
-    const a2 = r2.operatorToken.kind;
-    if (a2 === n__namespace.SyntaxKind.PlusEqualsToken || a2 === n__namespace.SyntaxKind.MinusEqualsToken || a2 === n__namespace.SyntaxKind.AsteriskEqualsToken || a2 === n__namespace.SyntaxKind.SlashEqualsToken || a2 === n__namespace.SyntaxKind.PercentEqualsToken) {
-      if (n__namespace.isIdentifier(r2.left)) {
-        switch (t2.emit(i$1.LOAD, r2.left.text), s2(r2.right), a2) {
-          case n__namespace.SyntaxKind.PlusEqualsToken:
-            n__namespace.isStringLiteral(r2.right) ? t2.emit(i$1.CONCAT) : t2.emit(i$1.ADD);
+  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);
             break;
-          case n__namespace.SyntaxKind.MinusEqualsToken:
-            t2.emit(i$1.SUB);
+          case i__namespace.SyntaxKind.MinusEqualsToken:
+            t2.emit(n$1.SUB);
             break;
-          case n__namespace.SyntaxKind.AsteriskEqualsToken:
-            t2.emit(i$1.MUL);
+          case i__namespace.SyntaxKind.AsteriskEqualsToken:
+            t2.emit(n$1.MUL);
             break;
-          case n__namespace.SyntaxKind.SlashEqualsToken:
-            t2.emit(i$1.DIV);
+          case i__namespace.SyntaxKind.SlashEqualsToken:
+            t2.emit(n$1.DIV);
             break;
-          case n__namespace.SyntaxKind.PercentEqualsToken:
-            t2.emit(i$1.MOD);
+          case i__namespace.SyntaxKind.PercentEqualsToken:
+            t2.emit(n$1.MOD);
             break;
         }
-        t2.emit(i$1.STORE, r2.left.text);
-      } else if (n__namespace.isElementAccessExpression(r2.left))
+        t2.emit(n$1.STORE, r.left.text);
+      } else if (i__namespace.isElementAccessExpression(r.left))
         throw new Error("Compound assignment to array elements not yet supported");
       return;
-    } else if (a2 === n__namespace.SyntaxKind.EqualsToken) {
-      if (s2(r2.right), n__namespace.isIdentifier(r2.left))
-        t2.emit(i$1.STORE, r2.left.text);
-      else if (n__namespace.isElementAccessExpression(r2.left)) {
-        const m2 = `__temp_${t2.getBytecode().length}`;
-        t2.emit(i$1.STORE, m2), s2(r2.left.expression), s2(r2.left.argumentExpression), t2.emit(i$1.LOAD, m2), t2.emit(i$1.ARRAY_SET), t2.emit(i$1.POP);
-      } else if (n__namespace.isPropertyAccessExpression(r2.left)) {
-        const m2 = `__temp_${t2.getBytecode().length}`;
-        t2.emit(i$1.STORE, m2), s2(r2.left.expression), t2.emit(i$1.PUSH, r2.left.name.text), t2.emit(i$1.LOAD, m2), t2.emit(i$1.PROPERTY_SET), t2.emit(i$1.POP);
+    } 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);
       }
       return;
     }
   }
-  n__namespace.isCallExpression(r2) && n__namespace.isPropertyAccessExpression(r2.expression) && r2.expression.expression.getText() === "console" && r2.expression.name.getText() === "log" ? (r2.arguments.forEach((a2) => {
+  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(i$1.PRINT)) : n__namespace.isCallExpression(r2) && n__namespace.isIdentifier(r2.expression) && r2.expression.text === "CC" ? (r2.arguments.length > 0 && s2(r2.arguments[0]), t2.emit(i$1.CC), t2.emit(i$1.POP)) : n__namespace.isCallExpression(r2) && n__namespace.isPropertyAccessExpression(r2.expression) && r2.expression.name.getText() === "push" ? (s2(r2.expression.expression), r2.arguments.length > 0 && s2(r2.arguments[0]), t2.emit(i$1.ARRAY_PUSH)) : (n__namespace.isPostfixUnaryExpression(r2) || n__namespace.isPrefixUnaryExpression(r2)) && (s2(r2), t2.emit(i$1.POP));
-}, _$1 = (e2, t2, { compileExpression: s2 }) => {
-  e2.expression ? s2(e2.expression) : t2.emit(i$1.PUSH, null), t2.emit(i$1.RETURN);
+  }), 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 r2 = t2.findLoopContext();
-  if (r2) {
-    r2.type === "foreach" && t2.emit(i$1.ITER_END);
-    const a2 = t2.emit(i$1.BREAK, -1);
-    r2.breakTargets = r2.breakTargets || [], r2.breakTargets.push(a2);
+  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);
   } else
     throw new Error("break statement not in loop");
 }, U = (e2, t2, s2) => {
-  const r2 = t2.findLoopContext();
-  if (r2 && r2.startAddress !== void 0) {
-    const a2 = t2.emit(i$1.CONTINUE, r2.startAddress);
-    r2.continueTargets = r2.continueTargets || [], r2.continueTargets.push(a2);
+  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);
   } else
     throw new Error("continue statement not in loop");
 }, L$1 = {
-  [n__namespace.SyntaxKind.IfStatement]: P$1,
-  [n__namespace.SyntaxKind.WhileStatement]: I,
-  [n__namespace.SyntaxKind.ForOfStatement]: h$2,
-  [n__namespace.SyntaxKind.Block]: y$1,
-  [n__namespace.SyntaxKind.VariableStatement]: N$1,
-  [n__namespace.SyntaxKind.ExpressionStatement]: g$2,
-  [n__namespace.SyntaxKind.ReturnStatement]: _$1,
-  [n__namespace.SyntaxKind.BreakStatement]: k,
-  [n__namespace.SyntaxKind.ContinueStatement]: U
-}, d$1 = (e2, t2, s2) => {
-  t2.emit(i$1.PUSH, e2.text);
+  [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(i$1.PUSH, Number(e2.text));
+  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(i$1.PUSH, true);
+  t2.emit(n$1.PUSH, true);
 }, F$1 = (e2, t2, s2) => {
-  t2.emit(i$1.PUSH, false);
+  t2.emit(n$1.PUSH, false);
+}, G$1 = (e2, t2, s2) => {
+  t2.emit(n$1.PUSH, null);
 }, D$1 = (e2, t2, s2) => {
-  t2.emit(i$1.PUSH, null);
-}, G = (e2, t2, s2) => {
-  e2.text === "undefined" ? t2.emit(i$1.PUSH_UNDEFINED) : t2.emit(i$1.LOAD, e2.text);
+  e2.text === "undefined" ? t2.emit(n$1.PUSH_UNDEFINED) : t2.emit(n$1.LOAD, e2.text);
 }, H$1 = (e2, t2, { compileExpression: s2 }) => {
-  t2.emit(i$1.ARRAY_NEW), e2.elements.forEach((r2) => {
-    s2(r2), t2.emit(i$1.ARRAY_PUSH);
+  t2.emit(n$1.ARRAY_NEW), e2.elements.forEach((r) => {
+    s2(r), t2.emit(n$1.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(i$1.LENGTH)) : (s2(e2.expression), t2.emit(i$1.PUSH, e2.name.text), t2.emit(i$1.PROPERTY_GET));
-}, C = (e2, t2, { compileExpression: s2, reportError: r2 }) => {
-  s2(e2.expression), e2.argumentExpression ? s2(e2.argumentExpression) : r2(e2, "Element access requires an index expression"), t2.emit(i$1.ARRAY_GET);
-}, Y$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 }) => {
   switch (e2.operator) {
-    case n__namespace.SyntaxKind.ExclamationToken:
-      s2(e2.operand), t2.emit(i$1.NOT);
+    case i__namespace.SyntaxKind.ExclamationToken:
+      s2(e2.operand), t2.emit(n$1.NOT);
       break;
-    case n__namespace.SyntaxKind.MinusToken:
-      s2(e2.operand), t2.emit(i$1.UNARY_MINUS);
+    case i__namespace.SyntaxKind.MinusToken:
+      s2(e2.operand), t2.emit(n$1.UNARY_MINUS);
       break;
-    case n__namespace.SyntaxKind.PlusToken:
-      s2(e2.operand), t2.emit(i$1.UNARY_PLUS);
+    case i__namespace.SyntaxKind.PlusToken:
+      s2(e2.operand), t2.emit(n$1.UNARY_PLUS);
       break;
-    case n__namespace.SyntaxKind.PlusPlusToken:
-      n__namespace.isIdentifier(e2.operand) && (t2.emit(i$1.PUSH, e2.operand.text), t2.emit(i$1.INC, false));
+    case i__namespace.SyntaxKind.PlusPlusToken:
+      i__namespace.isIdentifier(e2.operand) && (t2.emit(n$1.PUSH, e2.operand.text), t2.emit(n$1.INC, false));
       break;
-    case n__namespace.SyntaxKind.MinusMinusToken:
-      n__namespace.isIdentifier(e2.operand) && (t2.emit(i$1.PUSH, e2.operand.text), t2.emit(i$1.DEC, false));
+    case i__namespace.SyntaxKind.MinusMinusToken:
+      i__namespace.isIdentifier(e2.operand) && (t2.emit(n$1.PUSH, e2.operand.text), t2.emit(n$1.DEC, false));
       break;
   }
 }, w$1 = (e2, t2, { compileExpression: s2 }) => {
   switch (e2.operator) {
-    case n__namespace.SyntaxKind.PlusPlusToken:
-      n__namespace.isIdentifier(e2.operand) && (t2.emit(i$1.PUSH, e2.operand.text), t2.emit(i$1.INC, true));
+    case i__namespace.SyntaxKind.PlusPlusToken:
+      i__namespace.isIdentifier(e2.operand) && (t2.emit(n$1.PUSH, e2.operand.text), t2.emit(n$1.INC, true));
       break;
-    case n__namespace.SyntaxKind.MinusMinusToken:
-      n__namespace.isIdentifier(e2.operand) && (t2.emit(i$1.PUSH, e2.operand.text), t2.emit(i$1.DEC, true));
+    case i__namespace.SyntaxKind.MinusMinusToken:
+      i__namespace.isIdentifier(e2.operand) && (t2.emit(n$1.PUSH, e2.operand.text), t2.emit(n$1.DEC, true));
       break;
   }
 };
-function T(e2, t2) {
-  return !!(n__namespace.isStringLiteral(e2) || n__namespace.isStringLiteral(t2) || n__namespace.isBinaryExpression(e2) && e2.operatorToken.kind === n__namespace.SyntaxKind.PlusToken && T(e2.left, e2.right) || n__namespace.isBinaryExpression(t2) && t2.operatorToken.kind === n__namespace.SyntaxKind.PlusToken && T(t2.left, t2.right));
+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 r2 = e2.operatorToken.kind;
-  switch (s2(e2.left), s2(e2.right), r2) {
-    case n__namespace.SyntaxKind.PlusToken:
-      T(e2.left, e2.right) ? t2.emit(i$1.CONCAT) : t2.emit(i$1.ADD);
+  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);
       break;
-    case n__namespace.SyntaxKind.MinusToken:
-      t2.emit(i$1.SUB);
+    case i__namespace.SyntaxKind.MinusToken:
+      t2.emit(n$1.SUB);
       break;
-    case n__namespace.SyntaxKind.AsteriskToken:
-      t2.emit(i$1.MUL);
+    case i__namespace.SyntaxKind.AsteriskToken:
+      t2.emit(n$1.MUL);
       break;
-    case n__namespace.SyntaxKind.SlashToken:
-      t2.emit(i$1.DIV);
+    case i__namespace.SyntaxKind.SlashToken:
+      t2.emit(n$1.DIV);
       break;
-    case n__namespace.SyntaxKind.PercentToken:
-      t2.emit(i$1.MOD);
+    case i__namespace.SyntaxKind.PercentToken:
+      t2.emit(n$1.MOD);
       break;
-    case n__namespace.SyntaxKind.EqualsEqualsToken:
-      t2.emit(i$1.EQ);
+    case i__namespace.SyntaxKind.EqualsEqualsToken:
+      t2.emit(n$1.EQ);
       break;
-    case n__namespace.SyntaxKind.ExclamationEqualsToken:
-      t2.emit(i$1.NEQ);
+    case i__namespace.SyntaxKind.ExclamationEqualsToken:
+      t2.emit(n$1.NEQ);
       break;
-    case n__namespace.SyntaxKind.LessThanToken:
-      t2.emit(i$1.LT);
+    case i__namespace.SyntaxKind.LessThanToken:
+      t2.emit(n$1.LT);
       break;
-    case n__namespace.SyntaxKind.GreaterThanToken:
-      t2.emit(i$1.GT);
+    case i__namespace.SyntaxKind.GreaterThanToken:
+      t2.emit(n$1.GT);
       break;
-    case n__namespace.SyntaxKind.LessThanEqualsToken:
-      t2.emit(i$1.LTE);
+    case i__namespace.SyntaxKind.LessThanEqualsToken:
+      t2.emit(n$1.LTE);
       break;
-    case n__namespace.SyntaxKind.GreaterThanEqualsToken:
-      t2.emit(i$1.GTE);
+    case i__namespace.SyntaxKind.GreaterThanEqualsToken:
+      t2.emit(n$1.GTE);
       break;
-    case n__namespace.SyntaxKind.EqualsEqualsEqualsToken:
-      t2.emit(i$1.EQ_STRICT);
+    case i__namespace.SyntaxKind.EqualsEqualsEqualsToken:
+      t2.emit(n$1.EQ_STRICT);
       break;
-    case n__namespace.SyntaxKind.ExclamationEqualsEqualsToken:
-      t2.emit(i$1.NEQ_STRICT);
+    case i__namespace.SyntaxKind.ExclamationEqualsEqualsToken:
+      t2.emit(n$1.NEQ_STRICT);
       break;
-    case n__namespace.SyntaxKind.AmpersandAmpersandToken:
-      t2.emit(i$1.AND);
+    case i__namespace.SyntaxKind.AmpersandAmpersandToken:
+      t2.emit(n$1.AND);
       break;
-    case n__namespace.SyntaxKind.BarBarToken:
-      t2.emit(i$1.OR);
+    case i__namespace.SyntaxKind.BarBarToken:
+      t2.emit(n$1.OR);
       break;
   }
 }, q$1 = (e2, t2, { compileExpression: s2 }) => {
   s2(e2.condition);
-  const r2 = t2.emit(i$1.JUMP_IF_FALSE, -1);
+  const r = t2.emit(n$1.JUMP_IF_FALSE, -1);
   s2(e2.whenTrue);
-  const a2 = t2.emit(i$1.JUMP, -1), m2 = t2.currentAddress();
-  t2.patchJump(r2, m2), s2(e2.whenFalse);
-  const l2 = t2.currentAddress();
-  t2.patchJump(a2, l2);
+  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(i$1.TYPEOF);
+  s2(e2.expression), t2.emit(n$1.TYPEOF);
 }, V$1 = (e2, t2, { compileExpression: s2 }) => {
-  if (n__namespace.isPropertyAccessExpression(e2.expression) && n__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(i$1.PUSH, "."), e2.arguments.length > 1 && s2(e2.arguments[1]), t2.emit(i$1.FS_LIST_FILES);
-  else if (n__namespace.isPropertyAccessExpression(e2.expression) && n__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(i$1.JSON_PARSE);
-  else if (n__namespace.isPropertyAccessExpression(e2.expression) && n__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(i$1.PUSH_UNDEFINED), t2.emit(i$1.JSON_STRINGIFY);
-  else if (n__namespace.isIdentifier(e2.expression) && e2.expression.text === "CC")
-    e2.arguments.length > 0 && s2(e2.arguments[0]), t2.emit(i$1.CC);
-  else if (n__namespace.isPropertyAccessExpression(e2.expression)) {
-    const r2 = e2.expression.name.text;
-    if (r2 === "substring")
-      s2(e2.expression.expression), e2.arguments.length > 0 ? s2(e2.arguments[0]) : t2.emit(i$1.PUSH, 0), e2.arguments.length > 1 && s2(e2.arguments[1]), t2.emit(i$1.STRING_SUBSTRING);
-    else if (r2 === "indexOf")
-      s2(e2.expression.expression), e2.arguments.length > 0 ? s2(e2.arguments[0]) : t2.emit(i$1.PUSH, ""), t2.emit(i$1.STRING_INDEXOF);
-    else if (r2 === "split")
-      s2(e2.expression.expression), e2.arguments.length > 0 ? s2(e2.arguments[0]) : t2.emit(i$1.PUSH, ""), t2.emit(i$1.STRING_SPLIT);
-    else if (r2 === "slice")
-      s2(e2.expression.expression), e2.arguments.length > 0 ? s2(e2.arguments[0]) : t2.emit(i$1.PUSH, 0), e2.arguments.length > 1 && s2(e2.arguments[1]), t2.emit(i$1.STRING_SLICE);
-    else if (r2 === "charAt")
-      s2(e2.expression.expression), e2.arguments.length > 0 ? s2(e2.arguments[0]) : t2.emit(i$1.PUSH, 0), t2.emit(i$1.STRING_CHARAT);
-    else if (r2 === "toUpperCase")
-      s2(e2.expression.expression), t2.emit(i$1.STRING_TOUPPERCASE);
-    else if (r2 === "toLowerCase")
-      s2(e2.expression.expression), t2.emit(i$1.STRING_TOLOWERCASE);
+  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);
     else
-      throw new Error(`Method call '${r2}' is not supported`);
+      throw new Error(`Method call '${r}' is not supported`);
   } else
     throw new Error("Unsupported call expression");
 }, Q = (e2, t2, { compileExpression: s2 }) => {
-  t2.emit(i$1.OBJECT_CREATE);
-  for (const r2 of e2.properties)
-    if (n__namespace.isPropertyAssignment(r2)) {
+  t2.emit(n$1.OBJECT_CREATE);
+  for (const r of e2.properties)
+    if (i__namespace.isPropertyAssignment(r)) {
       let a2;
-      if (n__namespace.isIdentifier(r2.name))
-        a2 = r2.name.text;
-      else if (n__namespace.isStringLiteral(r2.name))
-        a2 = r2.name.text;
+      if (i__namespace.isIdentifier(r.name))
+        a2 = r.name.text;
+      else if (i__namespace.isStringLiteral(r.name))
+        a2 = r.name.text;
       else
         throw new Error("Computed property names are not supported");
-      t2.emit(i$1.PUSH, a2), s2(r2.initializer), t2.emit(i$1.PROPERTY_SET);
-    } else if (n__namespace.isShorthandPropertyAssignment(r2)) {
-      const a2 = r2.name.text;
-      t2.emit(i$1.PUSH, a2), t2.emit(i$1.LOAD, a2), t2.emit(i$1.PROPERTY_SET);
+      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);
     } else
       throw new Error("Unsupported property type in object literal");
-}, v = {
-  [n__namespace.SyntaxKind.StringLiteral]: d$1,
-  [n__namespace.SyntaxKind.NumericLiteral]: K,
-  [n__namespace.SyntaxKind.TrueKeyword]: b$2,
-  [n__namespace.SyntaxKind.FalseKeyword]: F$1,
-  [n__namespace.SyntaxKind.NullKeyword]: D$1,
-  [n__namespace.SyntaxKind.Identifier]: G,
-  [n__namespace.SyntaxKind.ArrayLiteralExpression]: H$1,
-  [n__namespace.SyntaxKind.BinaryExpression]: B$1,
-  [n__namespace.SyntaxKind.PrefixUnaryExpression]: Y$1,
-  [n__namespace.SyntaxKind.PostfixUnaryExpression]: w$1,
-  [n__namespace.SyntaxKind.CallExpression]: V$1,
-  [n__namespace.SyntaxKind.PropertyAccessExpression]: J$1,
-  [n__namespace.SyntaxKind.ElementAccessExpression]: C,
-  [n__namespace.SyntaxKind.ConditionalExpression]: q$1,
-  [n__namespace.SyntaxKind.TypeOfExpression]: O,
-  [n__namespace.SyntaxKind.ParenthesizedExpression]: M$1,
-  [n__namespace.SyntaxKind.ObjectLiteralExpression]: Q
+}, 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
 };
 function W$1(e2) {
   const t2 = R(e2);
@@ -461,95 +459,98 @@ function W$1(e2) {
       bytecode: [],
       errors: t2.errors
     };
-  const s2 = new A$1(), r2 = n__namespace.createSourceFile("program.ts", e2, n__namespace.ScriptTarget.Latest, true), a2 = {
-    compileStatement: m2,
-    compileExpression: l2,
-    reportError: (o2, c2) => {
-      throw new Error(c2);
+  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);
     }
   };
-  function m2(o2) {
-    const c2 = L$1[o2.kind];
-    c2 && c2(o2, s2, a2);
-  }
-  function l2(o2) {
-    const c2 = v[o2.kind];
-    c2 && c2(o2, s2, a2);
-  }
-  return r2.forEachChild((o2) => {
-    var c2;
-    n__namespace.isFunctionDeclaration(o2) && ((c2 = o2.name) == null ? void 0 : c2.text) === "main" && o2.body && o2.body.statements.forEach((S) => {
-      m2(S);
+  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);
     });
-  }), s2.emit(i$1.HALT), {
+  }), s2.emit(n$1.HALT), {
     success: true,
     bytecode: s2.getBytecode(),
     errors: []
   };
 }
-function n(r2) {
-  return typeof r2 == "string";
+function n(r) {
+  return typeof r == "string";
 }
-function t(r2) {
-  return typeof r2 == "number";
+function t(r) {
+  return typeof r == "number";
 }
-function i(r2) {
-  return typeof r2 == "boolean";
+function i$1(r) {
+  return typeof r == "boolean";
 }
-function e(r2) {
-  return r2 === null;
+function e(r) {
+  return r === null;
 }
-function f(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 o(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 c$1(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 y(r2) {
-  return n(r2) ? r2 : t(r2) || i(r2) ? r2.toString() : e(r2) ? "null" : o(r2) ? "undefined" : f(r2) ? `[array:${r2.elements.length}]` : c$1(r2) ? "[object Object]" : String(r2);
+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$1(r2) {
-  return i(r2) ? r2 : e(r2) || o(r2) ? false : t(r2) ? r2 !== 0 : n(r2) ? r2 !== "" : f(r2) || c$1(r2) ? true : !!r2;
+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 n(r2) ? "string" : t(r2) ? "number" : i(r2) ? "boolean" : e(r2) ? "null" : o(r2) ? "undefined" : f(r2) ? "array" : c$1(r2) ? "object" : "unknown";
+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 m(r2) {
-  if (t(r2)) return r2;
-  if (i(r2)) return r2 ? 1 : 0;
-  if (e(r2)) return 0;
-  if (o(r2)) return NaN;
-  if (n(r2)) {
-    const u2 = r2.trim();
+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(r2) ? NaN : Number(r2);
+  return f(r) ? NaN : Number(r);
 }
-function d(r2 = []) {
-  return { type: "array", elements: r2 };
+function d(r = []) {
+  return { type: "array", elements: r };
 }
-function s$1() {
+function s() {
   return { type: "undefined" };
 }
-function j$1(r2 = {}) {
-  return { type: "object", properties: r2 };
+function j$1(r = {}) {
+  return { type: "object", properties: r };
 }
 var l = Object.defineProperty;
-var u = (s2, t2, n2) => t2 in s2 ? l(s2, t2, { enumerable: true, configurable: true, writable: true, value: n2 }) : s2[t2] = n2;
-var r = (s2, t2, n2) => u(s2, typeof t2 != "symbol" ? t2 + "" : t2, n2);
+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 {
   constructor(t2) {
-    r(this, "connected", false);
-    r(this, "programsDir");
-    r(this, "executionsDir");
-    r(this, "outputsDir");
+    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");
   }
+  get metadataFile() {
+    return c__namespace.join(this.dataDir, "metadata.json");
+  }
   async connect() {
-    await G$1.promises.mkdir(this.dataDir, { recursive: true }), await G$1.promises.mkdir(this.programsDir, { recursive: true }), await G$1.promises.mkdir(this.executionsDir, { recursive: true }), await G$1.promises.mkdir(this.outputsDir, { recursive: true }), this.connected = true;
+    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;
   }
   async disconnect() {
     this.connected = false;
@@ -559,63 +560,105 @@ let h$1 = class h {
   }
   async saveProgram(t2) {
     if (!this.connected) throw new Error("Not connected");
-    const n2 = c__namespace.join(this.programsDir, `${t2.id}.json`), e2 = JSON.stringify(t2, null, 2);
-    await G$1.promises.writeFile(n2, e2, "utf-8");
+    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");
   }
   async getProgram(t2) {
     if (!this.connected) throw new Error("Not connected");
-    const n2 = c__namespace.join(this.programsDir, `${t2}.json`);
+    const e2 = c__namespace.join(this.programsDir, `${t2}.json`);
     try {
-      const e2 = await G$1.promises.readFile(n2, "utf-8"), o2 = JSON.parse(e2);
+      const n2 = await M$2.promises.readFile(e2, "utf-8"), o2 = JSON.parse(n2);
       return o2.created = new Date(o2.created), o2.updated && (o2.updated = new Date(o2.updated)), o2;
-    } catch (e2) {
-      if (e2.code === "ENOENT")
+    } catch (n2) {
+      if (n2.code === "ENOENT")
         return null;
-      throw e2;
+      throw n2;
     }
   }
   async saveExecution(t2) {
     if (!this.connected) throw new Error("Not connected");
-    const n2 = c__namespace.join(this.executionsDir, `${t2.id}.json`), e2 = JSON.stringify(t2, null, 2);
-    await G$1.promises.writeFile(n2, e2, "utf-8");
+    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");
   }
   async getExecution(t2) {
     if (!this.connected) throw new Error("Not connected");
-    const n2 = c__namespace.join(this.executionsDir, `${t2}.json`);
+    const e2 = c__namespace.join(this.executionsDir, `${t2}.json`);
     try {
-      const e2 = await G$1.promises.readFile(n2, "utf-8"), o2 = JSON.parse(e2);
+      const n2 = await M$2.promises.readFile(e2, "utf-8"), o2 = JSON.parse(n2);
       return o2.created = new Date(o2.created), o2.updated && (o2.updated = new Date(o2.updated)), o2;
-    } catch (e2) {
-      if (e2.code === "ENOENT")
+    } catch (n2) {
+      if (n2.code === "ENOENT")
         return null;
-      throw e2;
+      throw n2;
     }
   }
-  async appendOutput(t2, n2) {
+  async appendOutput(t2, e2) {
     if (!this.connected) throw new Error("Not connected");
-    const e2 = c__namespace.join(this.outputsDir, `${t2}.output`), o2 = n2.join(`
+    const n2 = c__namespace.join(this.outputsDir, `${t2}.output`), o2 = e2.join(`
 `) + `
 `;
-    await G$1.promises.appendFile(e2, o2, "utf-8");
+    await M$2.promises.appendFile(n2, o2, "utf-8");
   }
   async getOutput(t2) {
     if (!this.connected) throw new Error("Not connected");
-    const n2 = c__namespace.join(this.outputsDir, `${t2}.output`);
+    const e2 = c__namespace.join(this.outputsDir, `${t2}.output`);
     try {
-      return (await G$1.promises.readFile(n2, "utf-8")).split(`
+      return (await M$2.promises.readFile(e2, "utf-8")).split(`
 `).filter((o2) => o2.length > 0);
-    } catch (e2) {
-      if (e2.code === "ENOENT")
+    } catch (n2) {
+      if (n2.code === "ENOENT")
         return [];
-      throw e2;
+      throw n2;
+    }
+  }
+  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);
+      }
+    return e2;
+  }
+  async getCurrentExecutionId() {
+    if (!this.connected) throw new Error("Not connected");
+    try {
+      const t2 = await M$2.promises.readFile(this.metadataFile, "utf-8");
+      return JSON.parse(t2).currentExecutionId || null;
+    } catch (t2) {
+      if (t2.code === "ENOENT")
+        return null;
+      throw t2;
     }
   }
+  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");
+  }
+  async deleteExecution(t2) {
+    if (!this.connected) throw new Error("Not connected");
+    const e2 = c__namespace.join(this.executionsDir, `${t2}.json`);
+    try {
+      await M$2.promises.unlink(e2);
+    } catch (r) {
+      if (r.code !== "ENOENT") throw r;
+    }
+    const n2 = c__namespace.join(this.outputsDir, `${t2}.output`);
+    try {
+      await M$2.promises.unlink(n2);
+    } catch (r) {
+      if (r.code !== "ENOENT") throw r;
+    }
+    await this.getCurrentExecutionId() === t2 && await this.setCurrentExecutionId(null);
+  }
 };
-class p {
+class w {
   constructor(t2) {
-    r(this, "client");
-    r(this, "db", null);
-    r(this, "connected", false);
+    a(this, "client");
+    a(this, "db", null);
+    a(this, "connected", false);
     this.connectionString = t2, this.client = new mongodb.MongoClient(t2);
   }
   async connect() {
@@ -623,8 +666,8 @@ class p {
     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 e2 = (await this.db.listCollections().toArray()).map((a2) => a2.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");
+    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");
   }
   async disconnect() {
     await this.client.close(), this.connected = false, this.db = null;
@@ -634,7 +677,7 @@ class p {
   }
   async getCollections() {
     if (!this.db) throw new Error("Not connected to database");
-    return (await this.db.listCollections().toArray()).map((n2) => n2.name);
+    return (await this.db.listCollections().toArray()).map((e2) => e2.name);
   }
   getCollection(t2) {
     if (!this.db) throw new Error("Not connected to database");
@@ -660,145 +703,162 @@ class p {
   async getExecution(t2) {
     return await this.getCollection("executions").findOne({ id: t2 });
   }
-  async appendOutput(t2, n2) {
-    const e2 = this.getCollection("outputs");
-    await e2.findOne({ executionId: t2 }) ? await e2.updateOne(
+  async appendOutput(t2, e2) {
+    const n2 = this.getCollection("outputs");
+    await n2.findOne({ executionId: t2 }) ? await n2.updateOne(
       { executionId: t2 },
-      { $push: { lines: { $each: n2 } } }
-    ) : await e2.insertOne({ executionId: t2, lines: n2 });
+      { $push: { lines: { $each: e2 } } }
+    ) : await n2.insertOne({ executionId: t2, lines: e2 });
   }
   async getOutput(t2) {
-    const e2 = await this.getCollection("outputs").findOne({ executionId: t2 });
-    return (e2 == null ? void 0 : e2.lines) || [];
+    const n2 = await this.getCollection("outputs").findOne({ executionId: t2 });
+    return (n2 == null ? void 0 : n2.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;
+  }
+  async setCurrentExecutionId(t2) {
+    await this.getCollection("metadata").replaceOne(
+      { _id: "current" },
+      { _id: "current", currentExecutionId: t2 },
+      { upsert: true }
+    );
+  }
+  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);
   }
 }
-let g$1 = class g {
+class E {
   static create(t2) {
-    const n2 = (t2 == null ? void 0 : t2.type) || process.env.CVM_STORAGE_TYPE || "file";
-    switch (n2) {
+    const e2 = (t2 == null ? void 0 : t2.type) || process.env.CVM_STORAGE_TYPE || "file";
+    switch (e2) {
       case "file": {
-        const e2 = (t2 == null ? void 0 : t2.dataDir) || process.env.CVM_DATA_DIR || ".cvm";
-        return new h$1(e2);
+        const n2 = (t2 == null ? void 0 : t2.dataDir) || process.env.CVM_DATA_DIR || ".cvm";
+        return new h$1(n2);
       }
       case "mongodb": {
-        const e2 = (t2 == null ? void 0 : t2.mongoUri) || process.env.MONGODB_URI || "mongodb://localhost:27017/cvm";
-        return new p(e2);
+        const n2 = (t2 == null ? void 0 : t2.mongoUri) || process.env.MONGODB_URI || "mongodb://localhost:27017/cvm";
+        return new w(n2);
       }
       default:
-        throw new Error(`Unsupported storage type: ${n2}`);
+        throw new Error(`Unsupported storage type: ${e2}`);
     }
   }
-};
-var b = Object.defineProperty;
-var P = (e2, r2, t2) => r2 in e2 ? b(e2, r2, { enumerable: true, configurable: true, writable: true, value: t2 }) : e2[r2] = t2;
-var h2 = (e2, r2, t2) => P(e2, typeof r2 != "symbol" ? r2 + "" : r2, t2);
-const L = {
-  [i$1.ADD]: {
+}
+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]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2) => {
-      const r2 = e2.stack.pop(), t2 = e2.stack.pop(), s2 = m(t2), o2 = m(r2);
+      const r = e2.stack.pop(), t2 = e2.stack.pop(), s2 = m(t2), o2 = m(r);
       e2.stack.push(s2 + o2);
     }
   },
-  [i$1.SUB]: {
+  [n$1.SUB]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2) => {
-      const r2 = e2.stack.pop(), t2 = e2.stack.pop(), s2 = m(t2), o2 = m(r2);
+      const r = e2.stack.pop(), t2 = e2.stack.pop(), s2 = m(t2), o2 = m(r);
       e2.stack.push(s2 - o2);
     }
   },
-  [i$1.MUL]: {
+  [n$1.MUL]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2) => {
-      const r2 = e2.stack.pop(), t2 = e2.stack.pop(), s2 = m(t2), o2 = m(r2);
+      const r = e2.stack.pop(), t2 = e2.stack.pop(), s2 = m(t2), o2 = m(r);
       e2.stack.push(s2 * o2);
     }
   },
-  [i$1.DIV]: {
+  [n$1.DIV]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e2, r2) => {
+    execute: (e2, r) => {
       const t2 = e2.stack.pop(), s2 = e2.stack.pop(), o2 = m(s2), n2 = m(t2);
       if (n2 === 0)
         return {
           type: "DivisionByZero",
           message: "Division by zero",
           pc: e2.pc,
-          opcode: r2.op
+          opcode: r.op
         };
       e2.stack.push(o2 / n2);
     }
   },
-  [i$1.MOD]: {
+  [n$1.MOD]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2) => {
-      const r2 = e2.stack.pop(), t2 = e2.stack.pop(), s2 = m(t2), o2 = m(r2);
+      const r = e2.stack.pop(), t2 = e2.stack.pop(), s2 = m(t2), o2 = m(r);
       e2.stack.push(s2 % o2);
     }
   },
-  [i$1.UNARY_MINUS]: {
+  [n$1.UNARY_MINUS]: {
     stackIn: 1,
     stackOut: 1,
     execute: (e2) => {
-      const r2 = e2.stack.pop(), t2 = m(r2);
+      const r = e2.stack.pop(), t2 = m(r);
       e2.stack.push(-t2);
     }
   },
-  [i$1.UNARY_PLUS]: {
+  [n$1.UNARY_PLUS]: {
     stackIn: 1,
     stackOut: 1,
     execute: (e2) => {
-      const r2 = e2.stack.pop(), t2 = m(r2);
+      const r = e2.stack.pop(), t2 = m(r);
       e2.stack.push(t2);
     }
   }
-}, V = {
-  [i$1.PUSH]: {
+}, L = {
+  [n$1.PUSH]: {
     stackIn: 0,
     stackOut: 1,
-    execute: (e2, r2) => {
-      e2.stack.push(r2.arg);
+    execute: (e2, r) => {
+      e2.stack.push(r.arg);
     }
   },
-  [i$1.PUSH_UNDEFINED]: {
+  [n$1.PUSH_UNDEFINED]: {
     stackIn: 0,
     stackOut: 1,
     execute: (e2) => {
-      e2.stack.push(s$1());
+      e2.stack.push(s());
     }
   },
-  [i$1.POP]: {
+  [n$1.POP]: {
     stackIn: 1,
     stackOut: 0,
     execute: (e2) => {
       e2.stack.pop();
     }
   }
-}, M = {
-  [i$1.PRINT]: {
+}, V = {
+  [n$1.PRINT]: {
     stackIn: 1,
     stackOut: 0,
     execute: (e2) => {
-      const r2 = e2.stack.pop();
-      r2 !== void 0 && e2.output.push(y(r2));
+      const r = e2.stack.pop();
+      r !== void 0 && e2.output.push(y(r));
     }
   },
-  [i$1.CC]: {
+  [n$1.CC]: {
     stackIn: 1,
     stackOut: 0,
     controlsPC: true,
     // CC pauses execution
-    execute: (e2, r2) => {
+    execute: (e2, r) => {
       const t2 = e2.stack.pop();
       e2.ccPrompt = y(t2), e2.status = "waiting_cc";
     }
   }
-}, j = {
-  [i$1.HALT]: {
+}, F = {
+  [n$1.HALT]: {
     stackIn: 0,
     stackOut: 0,
     controlsPC: true,
@@ -806,96 +866,155 @@ const L = {
       e2.status = "complete";
     }
   },
-  [i$1.JUMP]: {
+  [n$1.JUMP]: {
     stackIn: 0,
     stackOut: 0,
     controlsPC: true,
-    execute: (e2, r2) => {
-      if (r2.arg === void 0)
+    execute: (e2, r) => {
+      if (r.arg === void 0)
         return {
           type: "RuntimeError",
           message: "JUMP requires a target address",
           pc: e2.pc,
-          opcode: r2.op
+          opcode: r.op
         };
-      const t2 = r2.arg;
+      const t2 = r.arg;
       if (t2 < 0)
         return {
           type: "RuntimeError",
           message: `Invalid jump target: ${t2}`,
           pc: e2.pc,
-          opcode: r2.op
+          opcode: r.op
         };
       e2.pc = t2;
     }
   },
-  [i$1.JUMP_IF_FALSE]: {
+  [n$1.JUMP_IF_FALSE]: {
     stackIn: 1,
     stackOut: 0,
     controlsPC: true,
-    execute: (e2, r2) => {
+    execute: (e2, r) => {
       const t2 = e2.stack.pop();
-      if (r2.arg === void 0)
+      if (r.arg === void 0)
         return {
           type: "RuntimeError",
           message: "JUMP_IF_FALSE requires a target address",
           pc: e2.pc,
-          opcode: r2.op
+          opcode: r.op
         };
-      const s2 = r2.arg;
+      const s2 = r.arg;
       if (s2 < 0)
         return {
           type: "RuntimeError",
           message: `Invalid jump target: ${s2}`,
           pc: e2.pc,
-          opcode: r2.op
+          opcode: r.op
         };
       b$1(t2) ? e2.pc++ : e2.pc = s2;
     }
+  },
+  [n$1.JUMP_IF]: {
+    stackIn: 1,
+    stackOut: 0,
+    controlsPC: true,
+    execute: (e2, r) => {
+      const t2 = e2.stack.pop();
+      if (r.arg === void 0)
+        return {
+          type: "RuntimeError",
+          message: "JUMP_IF requires a target address",
+          pc: e2.pc,
+          opcode: r.op
+        };
+      const s2 = r.arg;
+      if (s2 < 0)
+        return {
+          type: "RuntimeError",
+          message: `Invalid jump target: ${s2}`,
+          pc: e2.pc,
+          opcode: r.op
+        };
+      b$1(t2) ? e2.pc = s2 : e2.pc++;
+    }
+  },
+  [n$1.JUMP_IF_TRUE]: {
+    stackIn: 1,
+    stackOut: 0,
+    controlsPC: true,
+    execute: (e2, r) => {
+      const t2 = e2.stack.pop();
+      if (r.arg === void 0)
+        return {
+          type: "RuntimeError",
+          message: "JUMP_IF_TRUE requires a target address",
+          pc: e2.pc,
+          opcode: r.op
+        };
+      const s2 = r.arg;
+      if (s2 < 0)
+        return {
+          type: "RuntimeError",
+          message: `Invalid jump target: ${s2}`,
+          pc: e2.pc,
+          opcode: r.op
+        };
+      b$1(t2) ? e2.pc = s2 : e2.pc++;
+    }
+  },
+  [n$1.CALL]: {
+    stackIn: 1,
+    stackOut: 0,
+    controlsPC: false,
+    execute: (e2) => (e2.stack.pop(), {
+      type: "RuntimeError",
+      message: "Functions not implemented",
+      pc: e2.pc,
+      opcode: n$1.CALL
+    })
   }
-}, F = {
-  [i$1.LOAD]: {
+}, j = {
+  [n$1.LOAD]: {
     stackIn: 0,
     stackOut: 1,
-    execute: (e2, r2) => {
-      const t2 = r2.arg;
-      e2.variables.has(t2) ? e2.stack.push(e2.variables.get(t2)) : e2.stack.push(s$1());
+    execute: (e2, r) => {
+      const t2 = r.arg;
+      e2.variables.has(t2) ? e2.stack.push(e2.variables.get(t2)) : e2.stack.push(s());
     }
   },
-  [i$1.STORE]: {
+  [n$1.STORE]: {
     stackIn: 1,
     stackOut: 0,
-    execute: (e2, r2) => {
+    execute: (e2, r) => {
       const t2 = e2.stack.pop();
-      e2.variables.set(r2.arg, t2);
+      e2.variables.set(r.arg, t2);
     }
   }
 }, D = {
-  [i$1.ITER_START]: {
+  [n$1.ITER_START]: {
     stackIn: 1,
     stackOut: 0,
-    execute: (e2, r2) => {
+    execute: (e2, r) => {
       const t2 = e2.stack.pop();
       if (t2 == null)
         return {
           type: "TypeError",
           message: "TypeError: Cannot iterate over null or undefined",
           pc: e2.pc,
-          opcode: r2.op
+          opcode: r.op
         };
       if (!f(t2))
         return {
           type: "TypeError",
           message: "TypeError: Cannot iterate over non-array value",
           pc: e2.pc,
-          opcode: r2.op
+          opcode: r.op
         };
       if (e2.iterators.length >= 10)
         return {
           type: "RuntimeError",
           message: "RuntimeError: Maximum iterator depth exceeded",
           pc: e2.pc,
-          opcode: r2.op
+          opcode: r.op
         };
       e2.iterators.push({
         array: t2,
@@ -904,46 +1023,46 @@ const L = {
       });
     }
   },
-  [i$1.ITER_NEXT]: {
+  [n$1.ITER_NEXT]: {
     stackIn: 0,
     stackOut: 2,
     // Pushes element and hasMore flag
-    execute: (e2, r2) => {
+    execute: (e2, r) => {
       if (e2.iterators.length === 0)
         return {
           type: "RuntimeError",
           message: "ITER_NEXT: No active iterator",
           pc: e2.pc,
-          opcode: r2.op
+          opcode: r.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$1()), e2.stack.push(true), t2.index++) : (e2.stack.push(null), e2.stack.push(false));
+      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));
     }
   },
-  [i$1.ITER_END]: {
+  [n$1.ITER_END]: {
     stackIn: 0,
     stackOut: 0,
-    execute: (e2, r2) => {
+    execute: (e2, r) => {
       if (e2.iterators.length === 0)
         return {
           type: "RuntimeError",
           message: "ITER_END: No active iterator",
           pc: e2.pc,
-          opcode: r2.op
+          opcode: r.op
         };
       e2.iterators.pop();
     }
   }
 };
-function g2(e2, r2, t2) {
+function g(e2, r, t2) {
   const s2 = e2.stack.pop(), o2 = e2.stack.pop(), n2 = t2(o2, s2);
   e2.stack.push(n2);
 }
 const q = {
-  [i$1.EQ]: {
+  [n$1.EQ]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e$1, r2) => g2(e$1, r2, (t2, s2) => {
+    execute: (e$1, r) => g(e$1, r, (t2, s2) => {
       if (e(t2) && o(s2) || o(t2) && e(s2))
         return true;
       if (o(t2) && o(s2))
@@ -954,10 +1073,10 @@ const q = {
       }
     })
   },
-  [i$1.NEQ]: {
+  [n$1.NEQ]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e$1, r2) => g2(e$1, r2, (t2, s2) => {
+    execute: (e$1, r) => g(e$1, r, (t2, s2) => {
       if (e(t2) && o(s2) || o(t2) && e(s2))
         return false;
       if (o(t2) && o(s2))
@@ -968,100 +1087,100 @@ const q = {
       }
     })
   },
-  [i$1.LT]: {
+  [n$1.LT]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e2, r2) => g2(e2, r2, (t2, s2) => {
+    execute: (e2, r) => g(e2, r, (t2, s2) => {
       const o2 = m(t2), n2 = m(s2);
       return o2 < n2;
     })
   },
-  [i$1.GT]: {
+  [n$1.GT]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e2, r2) => g2(e2, r2, (t2, s2) => {
+    execute: (e2, r) => g(e2, r, (t2, s2) => {
       const o2 = m(t2), n2 = m(s2);
       return o2 > n2;
     })
   },
-  [i$1.LTE]: {
+  [n$1.LTE]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e2, r2) => g2(e2, r2, (t2, s2) => {
+    execute: (e2, r) => g(e2, r, (t2, s2) => {
       const o2 = m(t2), n2 = m(s2);
       return o2 <= n2;
     })
   },
-  [i$1.GTE]: {
+  [n$1.GTE]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e2, r2) => g2(e2, r2, (t2, s2) => {
+    execute: (e2, r) => g(e2, r, (t2, s2) => {
       const o2 = m(t2), n2 = m(s2);
       return o2 >= n2;
     })
   },
-  [i$1.EQ_STRICT]: {
+  [n$1.EQ_STRICT]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e2, r2) => g2(e2, r2, (t2, s2) => t2 === s2)
+    execute: (e2, r) => g(e2, r, (t2, s2) => t2 === s2)
   },
-  [i$1.NEQ_STRICT]: {
+  [n$1.NEQ_STRICT]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e2, r2) => g2(e2, r2, (t2, s2) => t2 !== s2)
+    execute: (e2, r) => g(e2, r, (t2, s2) => t2 !== s2)
   }
 }, H = {
-  [i$1.AND]: {
+  [n$1.AND]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e2, r2) => {
+    execute: (e2, r) => {
       const t2 = e2.stack.pop(), s2 = e2.stack.pop(), o2 = b$1(s2) ? t2 : s2;
       e2.stack.push(o2);
     }
   },
-  [i$1.OR]: {
+  [n$1.OR]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e2, r2) => {
+    execute: (e2, r) => {
       const t2 = e2.stack.pop(), s2 = e2.stack.pop(), o2 = b$1(s2) ? s2 : t2;
       e2.stack.push(o2);
     }
   },
-  [i$1.NOT]: {
+  [n$1.NOT]: {
     stackIn: 1,
     stackOut: 1,
-    execute: (e2, r2) => {
+    execute: (e2, r) => {
       const t2 = e2.stack.pop(), s2 = !b$1(t2);
       e2.stack.push(s2);
     }
   }
-}, Y = {
-  [i$1.ARRAY_NEW]: {
+}, $ = {
+  [n$1.ARRAY_NEW]: {
     stackIn: 0,
     stackOut: 1,
-    execute: (e2, r2) => {
+    execute: (e2, r) => {
       e2.stack.push(d());
     }
   },
-  [i$1.ARRAY_PUSH]: {
+  [n$1.ARRAY_PUSH]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e2, r2) => {
+    execute: (e2, r) => {
       const t2 = e2.stack.pop(), s2 = e2.stack.pop();
       if (!f(s2))
         return {
           type: "RuntimeError",
           message: "ARRAY_PUSH requires an array",
           pc: e2.pc,
-          opcode: r2.op
+          opcode: r.op
         };
       s2.elements.push(t2), e2.stack.push(s2);
     }
   },
-  [i$1.ARRAY_GET]: {
+  [n$1.ARRAY_GET]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e2, r2) => {
+    execute: (e2, r) => {
       const t$1 = e2.stack.pop(), s2 = e2.stack.pop();
       if (f(s2)) {
         if (!t(t$1))
@@ -1069,19 +1188,19 @@ const q = {
             type: "RuntimeError",
             message: "ARRAY_GET requires numeric index for arrays",
             pc: e2.pc,
-            opcode: r2.op
+            opcode: r.op
           };
         const o2 = s2.elements[t$1] ?? null;
         e2.stack.push(o2);
         return;
       }
-      if (c$1(s2)) {
+      if (c(s2)) {
         if (!n(t$1))
           return {
             type: "RuntimeError",
             message: "ARRAY_GET requires string key for objects",
             pc: e2.pc,
-            opcode: r2.op
+            opcode: r.op
           };
         const o2 = s2.properties[t$1] ?? null;
         e2.stack.push(o2);
@@ -1091,14 +1210,14 @@ const q = {
         type: "RuntimeError",
         message: "ARRAY_GET requires an array or object",
         pc: e2.pc,
-        opcode: r2.op
+        opcode: r.op
       };
     }
   },
-  [i$1.ARRAY_SET]: {
+  [n$1.ARRAY_SET]: {
     stackIn: 3,
     stackOut: 1,
-    execute: (e2, r2) => {
+    execute: (e2, r) => {
       const t$1 = e2.stack.pop(), s2 = e2.stack.pop(), o2 = e2.stack.pop();
       if (f(o2)) {
         if (!t(s2))
@@ -1106,7 +1225,7 @@ const q = {
             type: "RuntimeError",
             message: "ARRAY_SET requires numeric index for arrays",
             pc: e2.pc,
-            opcode: r2.op
+            opcode: r.op
           };
         const n2 = Math.floor(s2);
         if (n2 < 0)
@@ -1114,18 +1233,18 @@ const q = {
             type: "RuntimeError",
             message: "ARRAY_SET: Negative index not allowed",
             pc: e2.pc,
-            opcode: r2.op
+            opcode: r.op
           };
         o2.elements[n2] = t$1, e2.stack.push(o2);
         return;
       }
-      if (c$1(o2)) {
+      if (c(o2)) {
         if (!n(s2))
           return {
             type: "RuntimeError",
             message: "ARRAY_SET requires string key for objects",
             pc: e2.pc,
-            opcode: r2.op
+            opcode: r.op
           };
         o2.properties[s2] = t$1, e2.stack.push(o2);
         return;
@@ -1134,74 +1253,74 @@ const q = {
         type: "RuntimeError",
         message: "ARRAY_SET requires an array or object",
         pc: e2.pc,
-        opcode: r2.op
+        opcode: r.op
       };
     }
   },
-  [i$1.ARRAY_LEN]: {
+  [n$1.ARRAY_LEN]: {
     stackIn: 1,
     stackOut: 1,
-    execute: (e2, r2) => {
+    execute: (e2, r) => {
       const t2 = e2.stack.pop();
       if (!f(t2))
         return {
           type: "RuntimeError",
           message: "ARRAY_LEN requires an array",
           pc: e2.pc,
-          opcode: r2.op
+          opcode: r.op
         };
       e2.stack.push(t2.elements.length);
     }
   }
 };
-function x(e2) {
+function T(e2) {
   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 r2 = d();
-      return r2.elements = e2.map(x), r2;
+      const r = d();
+      return r.elements = e2.map(T), r;
     }
     if (e2 && typeof e2 == "object" && e2.type === "object" && e2.properties)
       return e2;
     if (typeof e2 == "object") {
-      const r2 = j$1();
+      const r = j$1();
       for (const [t2, s2] of Object.entries(e2))
-        r2.properties[t2] = x(s2);
-      return r2;
+        r.properties[t2] = T(s2);
+      return r;
     }
     return null;
   }
 }
-const $ = {
-  [i$1.CONCAT]: {
+const J = {
+  [n$1.CONCAT]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e2, r2) => {
+    execute: (e2, r) => {
       const t2 = e2.stack.pop(), s2 = e2.stack.pop();
       e2.stack.push(y(s2) + y(t2));
     }
   },
-  [i$1.STRING_LEN]: {
+  [n$1.STRING_LEN]: {
     stackIn: 1,
     stackOut: 1,
-    execute: (e2, r2) => {
+    execute: (e2, r) => {
       const t2 = e2.stack.pop();
       if (!n(t2))
         return {
           type: "RuntimeError",
           message: "STRING_LEN requires a string",
           pc: e2.pc,
-          opcode: r2.op
+          opcode: r.op
         };
       e2.stack.push(t2.length);
     }
   },
-  [i$1.LENGTH]: {
+  [n$1.LENGTH]: {
     stackIn: 1,
     stackOut: 1,
-    execute: (e2, r2) => {
+    execute: (e2, r) => {
       const t2 = e2.stack.pop();
       if (n(t2))
         e2.stack.push(t2.length);
@@ -1212,143 +1331,143 @@ const $ = {
           type: "RuntimeError",
           message: "LENGTH requires a string or array",
           pc: e2.pc,
-          opcode: r2.op
+          opcode: r.op
         };
     }
   },
-  [i$1.JSON_PARSE]: {
+  [n$1.JSON_PARSE]: {
     stackIn: 1,
     stackOut: 1,
-    execute: (e2, r2) => {
+    execute: (e2, r) => {
       const t2 = e2.stack.pop();
       if (!n(t2))
         return {
           type: "RuntimeError",
           message: "JSON_PARSE requires a string",
           pc: e2.pc,
-          opcode: r2.op
+          opcode: r.op
         };
       try {
         const s2 = JSON.parse(t2);
-        e2.stack.push(x(s2));
+        e2.stack.push(T(s2));
       } catch {
         e2.stack.push(null);
       }
     }
   },
-  [i$1.TYPEOF]: {
+  [n$1.TYPEOF]: {
     stackIn: 1,
     stackOut: 1,
-    execute: (e2, r2) => {
+    execute: (e2, r) => {
       const t2 = e2.stack.pop();
-      e2.stack.push(p$1(t2));
+      e2.stack.push(p(t2));
     }
   }
-}, B = {
-  [i$1.INC]: {
+}, Y = {
+  [n$1.INC]: {
     stackIn: 1,
     stackOut: 1,
-    execute: (e2, r2) => {
+    execute: (e2, r) => {
       const t2 = e2.stack.pop();
       if (typeof t2 != "string")
         return {
           type: "RuntimeError",
           message: "INC: Invalid variable name",
           pc: e2.pc,
-          opcode: r2.op
+          opcode: r.op
         };
       const s2 = e2.variables.get(t2) ?? 0, o2 = m(s2) + 1;
       e2.variables.set(t2, o2);
-      const n2 = r2.arg === true;
+      const n2 = r.arg === true;
       e2.stack.push(n2 ? m(s2) : o2);
     }
   },
-  [i$1.DEC]: {
+  [n$1.DEC]: {
     stackIn: 1,
     stackOut: 1,
-    execute: (e2, r2) => {
+    execute: (e2, r) => {
       const t2 = e2.stack.pop();
       if (typeof t2 != "string")
         return {
           type: "RuntimeError",
           message: "DEC: Invalid variable name",
           pc: e2.pc,
-          opcode: r2.op
+          opcode: r.op
         };
       const s2 = e2.variables.get(t2) ?? 0, o2 = m(s2) - 1;
       e2.variables.set(t2, o2);
-      const n2 = r2.arg === true;
+      const n2 = r.arg === true;
       e2.stack.push(n2 ? m(s2) : o2);
     }
   }
-}, J = {
-  [i$1.RETURN]: {
+}, B = {
+  [n$1.RETURN]: {
     stackIn: 0,
     stackOut: 0,
     controlsPC: true,
-    execute: (e2, r2) => {
+    execute: (e2, r) => {
       const t2 = e2.stack.pop() ?? null;
       e2.returnValue = t2, e2.status = "complete";
     }
   },
-  [i$1.BREAK]: {
+  [n$1.BREAK]: {
     stackIn: 0,
     stackOut: 0,
     controlsPC: true,
-    execute: (e2, r2) => {
-      if (r2.arg === void 0)
+    execute: (e2, r) => {
+      if (r.arg === void 0)
         return {
           type: "RuntimeError",
           message: "BREAK requires a target address",
           pc: e2.pc,
-          opcode: r2.op
+          opcode: r.op
         };
-      const t2 = r2.arg;
+      const t2 = r.arg;
       if (t2 < 0)
         return {
           type: "RuntimeError",
           message: `Invalid break target: ${t2}`,
           pc: e2.pc,
-          opcode: r2.op
+          opcode: r.op
         };
       e2.pc = t2;
     }
   },
-  [i$1.CONTINUE]: {
+  [n$1.CONTINUE]: {
     stackIn: 0,
     stackOut: 0,
     controlsPC: true,
-    execute: (e2, r2) => {
-      if (r2.arg === void 0)
+    execute: (e2, r) => {
+      if (r.arg === void 0)
         return {
           type: "RuntimeError",
           message: "CONTINUE requires a target address",
           pc: e2.pc,
-          opcode: r2.op
+          opcode: r.op
         };
-      const t2 = r2.arg;
+      const t2 = r.arg;
       if (t2 < 0)
         return {
           type: "RuntimeError",
           message: `Invalid continue target: ${t2}`,
           pc: e2.pc,
-          opcode: r2.op
+          opcode: r.op
         };
       e2.pc = t2;
     }
   },
-  [i$1.FS_LIST_FILES]: {
+  [n$1.FS_LIST_FILES]: {
     stackIn: 1,
     // Minimum 1 argument (path), optionally 2 (path + options)
     stackOut: 0,
     controlsPC: true,
-    execute: (e2, r2) => {
+    execute: (e2, r) => {
       if (e2.stack.length < 1)
         return {
           type: "StackUnderflow",
           message: "FS_LIST_FILES: Stack underflow",
           pc: e2.pc,
-          opcode: r2.op
+          opcode: r.op
         };
       let t2, s2 = {};
       const o2 = e2.stack[e2.stack.length - 1];
@@ -1357,7 +1476,7 @@ const $ = {
           type: "RuntimeError",
           message: "FS_LIST_FILES requires a string path",
           pc: e2.pc,
-          opcode: r2.op
+          opcode: r.op
         };
       e2.fsOperation = {
         type: "listFiles",
@@ -1367,17 +1486,17 @@ const $ = {
     }
   },
   // String method handlers
-  [i$1.STRING_SUBSTRING]: {
+  [n$1.STRING_SUBSTRING]: {
     stackIn: 2,
     // Minimum 2 (string, start), optionally 3 (string, start, end)
     stackOut: 1,
-    execute: (e2, r2) => {
+    execute: (e2, r) => {
       if (e2.stack.length < 2)
         return {
           type: "StackUnderflow",
           message: "STRING_SUBSTRING: Stack underflow",
           pc: e2.pc,
-          opcode: r2.op
+          opcode: r.op
         };
       const t2 = e2.stack.length;
       let s2, o2, n$12;
@@ -1387,63 +1506,63 @@ const $ = {
           type: "RuntimeError",
           message: "STRING_SUBSTRING requires a string",
           pc: e2.pc,
-          opcode: r2.op
+          opcode: r.op
         };
       if (typeof o2 != "number")
         return {
           type: "RuntimeError",
           message: "STRING_SUBSTRING requires numeric start index",
           pc: e2.pc,
-          opcode: r2.op
+          opcode: r.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 I2 = n$12 !== void 0 ? s2.substring(o2, n$12) : s2.substring(o2);
-      e2.stack.push(I2);
+      const O2 = n$12 !== void 0 ? s2.substring(o2, n$12) : s2.substring(o2);
+      e2.stack.push(O2);
     }
   },
-  [i$1.STRING_INDEXOF]: {
+  [n$1.STRING_INDEXOF]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e2, r2) => {
+    execute: (e2, r) => {
       const t2 = e2.stack.pop(), s2 = e2.stack.pop();
       if (!n(s2) || !n(t2))
         return {
           type: "RuntimeError",
           message: "STRING_INDEXOF requires string arguments",
           pc: e2.pc,
-          opcode: r2.op
+          opcode: r.op
         };
       e2.stack.push(s2.indexOf(t2));
     }
   },
-  [i$1.STRING_SPLIT]: {
+  [n$1.STRING_SPLIT]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e2, r2) => {
+    execute: (e2, r) => {
       const t2 = e2.stack.pop(), s2 = e2.stack.pop();
       if (!n(s2) || !n(t2))
         return {
           type: "RuntimeError",
           message: "STRING_SPLIT requires string arguments",
           pc: e2.pc,
-          opcode: r2.op
+          opcode: r.op
         };
       let o2;
       t2 === "" ? o2 = s2.split("") : o2 = s2.split(t2), e2.stack.push(d(o2));
     }
   },
-  [i$1.STRING_SLICE]: {
+  [n$1.STRING_SLICE]: {
     stackIn: 2,
     // Minimum 2 (string, start), optionally 3 (string, start, end)
     stackOut: 1,
-    execute: (e2, r2) => {
+    execute: (e2, r) => {
       if (e2.stack.length < 2)
         return {
           type: "StackUnderflow",
           message: "STRING_SLICE: Stack underflow",
           pc: e2.pc,
-          opcode: r2.op
+          opcode: r.op
         };
       const t2 = e2.stack.length;
       let s2, o2, n$12;
@@ -1453,169 +1572,185 @@ const $ = {
           type: "RuntimeError",
           message: "STRING_SLICE requires a string",
           pc: e2.pc,
-          opcode: r2.op
+          opcode: r.op
         };
       if (typeof o2 != "number")
         return {
           type: "RuntimeError",
           message: "STRING_SLICE requires numeric start index",
           pc: e2.pc,
-          opcode: r2.op
+          opcode: r.op
         };
       const u2 = n$12 !== void 0 ? s2.slice(o2, n$12) : s2.slice(o2);
       e2.stack.push(u2);
     }
   },
-  [i$1.STRING_CHARAT]: {
+  [n$1.STRING_CHARAT]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e2, r2) => {
+    execute: (e2, r) => {
       const t2 = e2.stack.pop(), s2 = e2.stack.pop();
       if (!n(s2))
         return {
           type: "RuntimeError",
           message: "STRING_CHARAT requires a string",
           pc: e2.pc,
-          opcode: r2.op
+          opcode: r.op
         };
       if (typeof t2 != "number")
         return {
           type: "RuntimeError",
           message: "STRING_CHARAT requires numeric index",
           pc: e2.pc,
-          opcode: r2.op
+          opcode: r.op
         };
       const o2 = s2.charAt(t2);
       e2.stack.push(o2);
     }
   },
-  [i$1.STRING_TOUPPERCASE]: {
+  [n$1.STRING_TOUPPERCASE]: {
     stackIn: 1,
     stackOut: 1,
-    execute: (e2, r2) => {
+    execute: (e2, r) => {
       const t2 = e2.stack.pop();
       if (!n(t2))
         return {
           type: "RuntimeError",
           message: "STRING_TOUPPERCASE requires a string",
           pc: e2.pc,
-          opcode: r2.op
+          opcode: r.op
         };
       e2.stack.push(t2.toUpperCase());
     }
   },
-  [i$1.STRING_TOLOWERCASE]: {
+  [n$1.STRING_TOLOWERCASE]: {
     stackIn: 1,
     stackOut: 1,
-    execute: (e2, r2) => {
+    execute: (e2, r) => {
       const t2 = e2.stack.pop();
       if (!n(t2))
         return {
           type: "RuntimeError",
           message: "STRING_TOLOWERCASE requires a string",
           pc: e2.pc,
-          opcode: r2.op
+          opcode: r.op
         };
       e2.stack.push(t2.toLowerCase());
     }
+  },
+  [n$1.TO_STRING]: {
+    stackIn: 1,
+    stackOut: 1,
+    execute: (e2, r) => {
+      const t2 = e2.stack.pop();
+      if (t2 === void 0)
+        return {
+          type: "StackUnderflow",
+          message: "TO_STRING: Stack underflow",
+          pc: e2.pc,
+          opcode: r.op
+        };
+      const s2 = y(t2);
+      e2.stack.push(s2);
+    }
   }
 };
 function _(e2) {
   if (f(e2))
     return e2.elements.map(_);
-  if (c$1(e2)) {
-    const r2 = {};
+  if (c(e2)) {
+    const r = {};
     for (const [t2, s2] of Object.entries(e2.properties))
-      r2[t2] = _(s2);
-    return r2;
+      r[t2] = _(s2);
+    return r;
   }
   if (!o(e2))
     return e2;
 }
 const W = {
-  [i$1.OBJECT_CREATE]: {
+  [n$1.OBJECT_CREATE]: {
     stackIn: 0,
     stackOut: 1,
     execute: (e2) => {
       e2.stack.push(j$1());
     }
   },
-  [i$1.PROPERTY_SET]: {
+  [n$1.PROPERTY_SET]: {
     stackIn: 3,
     stackOut: 1,
-    execute: (e2, r2) => {
+    execute: (e2, r) => {
       const t2 = e2.stack.pop(), s2 = e2.stack.pop(), o2 = e2.stack.pop();
-      if (!c$1(o2))
+      if (!c(o2))
         return {
           type: "RuntimeError",
-          message: `Cannot set property '${s2}' on ${p$1(o2)}`,
+          message: `Cannot set property '${s2}' on ${p(o2)}`,
           pc: e2.pc,
-          opcode: r2.op
+          opcode: r.op
         };
       if (!n(s2))
         return {
           type: "RuntimeError",
           message: "Property key must be a string",
           pc: e2.pc,
-          opcode: r2.op
+          opcode: r.op
         };
       o2.properties[s2] = t2, e2.stack.push(o2);
     }
   },
-  [i$1.PROPERTY_GET]: {
+  [n$1.PROPERTY_GET]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e$1, r2) => {
-      const t2 = e$1.stack.pop(), s2 = e$1.stack.pop();
-      if (e(s2) || o(s2))
+    execute: (e$1, r) => {
+      const t2 = e$1.stack.pop(), s$1 = e$1.stack.pop();
+      if (e(s$1) || o(s$1))
         return {
           type: "RuntimeError",
-          message: `Cannot read property '${t2}' of ${p$1(s2)}`,
+          message: `Cannot read property '${t2}' of ${p(s$1)}`,
           pc: e$1.pc,
-          opcode: r2.op
+          opcode: r.op
         };
-      if (!c$1(s2)) {
-        e$1.stack.push(s$1());
+      if (!c(s$1)) {
+        e$1.stack.push(s());
         return;
       }
-      const o$1 = s2.properties[y(t2)];
-      e$1.stack.push(o$1 ?? s$1());
+      const o$1 = s$1.properties[y(t2)];
+      e$1.stack.push(o$1 ?? s());
     }
   },
-  [i$1.JSON_STRINGIFY]: {
+  [n$1.JSON_STRINGIFY]: {
     stackIn: 1,
     stackOut: 1,
     execute: (e2) => {
-      const r2 = e2.stack.pop(), t2 = _(r2);
+      const r = e2.stack.pop(), t2 = _(r);
       e2.stack.push(JSON.stringify(t2));
     }
   }
 }, z = {
+  ...G,
   ...L,
   ...V,
-  ...M,
-  ...j,
   ...F,
+  ...j,
   ...D,
   ...q,
   ...H,
-  ...Y,
   ...$,
-  ...B,
   ...J,
+  ...Y,
+  ...B,
   ...W
 };
 class N {
-  validateStack(r2, t2, s2) {
-    if (s2.stack.length < r2.stackIn)
+  validateStack(r, t2, s2) {
+    if (s2.stack.length < r.stackIn)
       return {
         type: "StackUnderflow",
-        message: `${i$1[t2.op]}: Stack underflow`,
+        message: `${n$1[t2.op]}: Stack underflow`,
         pc: s2.pc,
         opcode: t2.op
       };
   }
-  execute(r2, t2) {
+  execute(r, t2) {
     const s2 = {
       pc: (t2 == null ? void 0 : t2.pc) ?? 0,
       stack: (t2 == null ? void 0 : t2.stack) ?? [],
@@ -1625,17 +1760,17 @@ class N {
       iterators: (t2 == null ? void 0 : t2.iterators) ?? [],
       ...t2
     };
-    for (; s2.status === "running" && s2.pc < r2.length; ) {
-      const o2 = r2[s2.pc], n2 = z[o2.op];
+    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;
           break;
         }
-        if ((o2.op === i$1.JUMP || o2.op === i$1.JUMP_IF_FALSE || o2.op === i$1.BREAK || o2.op === i$1.CONTINUE) && o2.arg !== void 0 && o2.arg >= r2.length) {
+        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) {
           s2.status = "error";
-          const u2 = o2.op === i$1.JUMP || o2.op === i$1.JUMP_IF_FALSE ? "jump" : o2.op === i$1.BREAK ? "break" : "continue";
+          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}`;
           break;
         }
@@ -1647,86 +1782,86 @@ class N {
         n2.controlsPC || s2.pc++;
         continue;
       }
-      s2.status = "error", s2.error = `Unknown opcode: ${i$1[o2.op]}`;
+      s2.status = "error", s2.error = `Unknown opcode: ${n$1[o2.op]}`;
       break;
     }
     return s2;
   }
-  resume(r2, t2, s2) {
-    if (r2.status !== "waiting_cc")
+  resume(r, t2, s2) {
+    if (r.status !== "waiting_cc")
       throw new Error("Cannot resume: VM not waiting for CC");
     const o2 = {
-      ...r2,
-      stack: [...r2.stack, t2],
+      ...r,
+      stack: [...r.stack, t2],
       status: "running",
       ccPrompt: void 0,
-      pc: r2.pc + 1
+      pc: r.pc + 1
     };
     return this.execute(s2, o2);
   }
-  resumeWithFsResult(r2, t2, s2) {
-    if (r2.status !== "waiting_fs")
+  resumeWithFsResult(r, t2, s2) {
+    if (r.status !== "waiting_fs")
       throw new Error("Cannot resume: VM not waiting for FS operation");
     const o2 = {
-      ...r2,
-      stack: [...r2.stack, t2],
+      ...r,
+      stack: [...r.stack, t2],
       status: "running",
       fsOperation: void 0,
-      pc: r2.pc + 1
+      pc: r.pc + 1
     };
     return this.execute(s2, o2);
   }
 }
-class A2 {
+class P {
   constructor() {
     h2(this, "sandboxPaths", []);
-    const r2 = process.env.CVM_SANDBOX_PATHS, t2 = process.env.CVM_SANDBOX_ROOT;
-    r2 ? this.sandboxPaths = r2.split(",").map((s2) => c__namespace.resolve(s2.trim())) : t2 && (this.sandboxPaths = [c__namespace.resolve(t2)]);
+    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(r2) {
-    const t2 = c__namespace.resolve(r2);
+  isPathAllowed(r) {
+    const t2 = c__namespace.resolve(r);
     return t2.includes("..") || this.sandboxPaths.length === 0 ? false : this.sandboxPaths.some(
       (s2) => t2.startsWith(s2)
     );
   }
-  listFiles(r2, t2 = {}) {
+  listFiles(r, t2 = {}) {
     const s2 = d();
-    if (!this.isPathAllowed(r2))
+    if (!this.isPathAllowed(r))
       return s2;
     try {
-      const o2 = c__namespace.resolve(r2);
+      const o2 = c__namespace.resolve(r);
       this.listFilesRecursive(o2, o2, s2.elements, t2);
     } catch {
     }
     return s2;
   }
-  matchesPattern(r2, t2) {
+  matchesPattern(r, t2) {
     let s2 = t2.replace(/\./g, "\\.").replace(/\*\*/g, "__DOUBLESTAR__").replace(/\*/g, "[^/]*").replace(/__DOUBLESTAR__/g, ".*").replace(/\?/g, ".");
     s2 = "^" + s2 + "$";
     try {
-      return new RegExp(s2).test(r2);
+      return new RegExp(s2).test(r);
     } catch {
       return true;
     }
   }
-  listFilesRecursive(r2, t2, s2, o2, n2 = 0) {
+  listFilesRecursive(r, t2, s2, o2, n2 = 0) {
     try {
-      const a2 = G__namespace.readdirSync(t2, { withFileTypes: true });
+      const a2 = M__namespace.readdirSync(t2, { withFileTypes: true });
       for (const i2 of a2) {
-        const u2 = c__namespace.join(t2, i2.name), I2 = c__namespace.relative(r2, u2);
-        i2.isSymbolicLink() || o2.filter && !this.matchesPattern(I2, o2.filter) || (s2.push(u2), i2.isDirectory() && o2.recursive && this.listFilesRecursive(r2, u2, s2, o2, n2 + 1));
+        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));
       }
     } catch {
     }
   }
 }
-new A2();
+new P();
 class te {
-  constructor(r2, t2) {
+  constructor(r, t2) {
     h2(this, "vms", /* @__PURE__ */ new Map());
     h2(this, "storage");
     h2(this, "fileSystem");
-    r2 ? this.storage = r2 : this.storage = g$1.create(), this.fileSystem = t2 || new A2();
+    r ? this.storage = r : this.storage = E.create(), this.fileSystem = t2 || new P();
   }
   /**
    * Initialize the VMManager (connect to database)
@@ -1743,13 +1878,13 @@ class te {
   /**
    * Load and compile a program from source code
    */
-  async loadProgram(r2, t2) {
+  async loadProgram(r, t2) {
     const s2 = W$1(t2);
     if (!s2.success)
       throw new Error(`Compilation failed: ${s2.errors.join(", ")}`);
     const o2 = {
-      id: r2,
-      name: r2,
+      id: r,
+      name: r,
       source: t2,
       bytecode: s2.bytecode,
       // VM decides internal format
@@ -1760,12 +1895,12 @@ class te {
   /**
    * Start execution of a loaded program
    */
-  async startExecution(r2, t2) {
-    if (!await this.storage.getProgram(r2))
-      throw new Error(`Program not found: ${r2}`);
+  async startExecution(r, t2) {
+    if (!await this.storage.getProgram(r))
+      throw new Error(`Program not found: ${r}`);
     const o2 = {
       id: t2,
-      programId: r2,
+      programId: r,
       state: "READY",
       pc: 0,
       stack: [],
@@ -1780,24 +1915,24 @@ class te {
    * Get next action from execution (Claude polls this)
    * This is READ-ONLY - just returns current state
    */
-  async getNext(r2) {
-    const t2 = await this.storage.getExecution(r2);
+  async getNext(r) {
+    const t2 = await this.storage.getExecution(r);
     if (!t2)
-      throw new Error(`Execution not found: ${r2}`);
+      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(r2);
-      o2 || (o2 = new N(), this.vms.set(r2, o2));
+      let o2 = this.vms.get(r);
+      o2 || (o2 = new N(), this.vms.set(r, o2));
       const n2 = {
         pc: 0,
         stack: [],
         variables: /* @__PURE__ */ new Map(),
         output: []
       }, a2 = o2.execute(s2.bytecode, n2);
-      if (a2.output.length > 0 && await this.storage.appendOutput(r2, 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(r2), {
+      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), {
           type: "completed",
           message: "Execution completed",
           result: a2.returnValue
@@ -1810,20 +1945,20 @@ class te {
       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(r2, 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(r2), {
+          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(r2), {
+          }) : 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(r2));
+          }) : (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(r2), {
+        return t2.state = "ERROR", t2.error = a2.error, await this.storage.saveExecution(t2), this.vms.delete(r), {
           type: "error",
           error: a2.error
         };
@@ -1848,15 +1983,15 @@ class te {
   /**
    * Report result from cognitive operation and continue execution
    */
-  async reportCCResult(r2, t2) {
-    const s2 = await this.storage.getExecution(r2);
+  async reportCCResult(r, t2) {
+    const s2 = await this.storage.getExecution(r);
     if (!s2)
-      throw new Error(`Execution not found: ${r2}`);
+      throw new Error(`Execution not found: ${r}`);
     const o2 = await this.storage.getProgram(s2.programId);
     if (!o2)
       throw new Error(`Program not found: ${s2.programId}`);
-    let n2 = this.vms.get(r2);
-    n2 || (n2 = new N(), this.vms.set(r2, n2));
+    let n2 = this.vms.get(r);
+    n2 || (n2 = new N(), this.vms.set(r, n2));
     const a2 = {
       pc: s2.pc,
       stack: s2.stack,
@@ -1867,15 +2002,15 @@ class te {
       ccPrompt: void 0,
       iterators: s2.iterators || []
     }, i2 = n2.resume(a2, t2, o2.bytecode);
-    i2.output.length > 0 && await this.storage.appendOutput(r2, 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(r2)) : i2.status === "error" ? (s2.state = "ERROR", s2.error = i2.error, this.vms.delete(r2)) : i2.status === "waiting_cc" ? (s2.state = "AWAITING_COGNITIVE_RESULT", s2.ccPrompt = i2.ccPrompt) : s2.state = "RUNNING", await this.storage.saveExecution(s2);
+    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);
   }
   /**
    * Get current execution status
    */
-  async getExecutionStatus(r2) {
-    const t2 = await this.storage.getExecution(r2);
+  async getExecutionStatus(r) {
+    const t2 = await this.storage.getExecution(r);
     if (!t2)
-      throw new Error(`Execution not found: ${r2}`);
+      throw new Error(`Execution not found: ${r}`);
     return {
       id: t2.id,
       state: t2.state,
@@ -1887,20 +2022,53 @@ class te {
   /**
    * Get output for an execution
    */
-  async getExecutionOutput(r2) {
-    return await this.storage.getOutput(r2);
+  async getExecutionOutput(r) {
+    return await this.storage.getOutput(r);
+  }
+  /**
+   * List all executions
+   */
+  async listExecutions() {
+    return await this.storage.listExecutions();
+  }
+  /**
+   * Get current execution ID
+   */
+  async getCurrentExecutionId() {
+    return await this.storage.getCurrentExecutionId();
+  }
+  /**
+   * Set current execution ID
+   */
+  async setCurrentExecutionId(r) {
+    return await this.storage.setCurrentExecutionId(r);
+  }
+  /**
+   * Delete an execution
+   */
+  async deleteExecution(r) {
+    return await this.storage.deleteExecution(r);
+  }
+  /**
+   * Get execution with attempt tracking
+   */
+  async getExecutionWithAttempts(r) {
+    const t2 = await this.storage.getExecution(r);
+    if (!t2)
+      throw new Error(`Execution not found: ${r}`);
+    return t2;
   }
 }
-var a = Object.defineProperty;
-var c = (o2, r2, t2) => r2 in o2 ? a(o2, r2, { enumerable: true, configurable: true, writable: true, value: t2 }) : o2[r2] = t2;
-var s = (o2, r2, t2) => c(o2, typeof r2 != "symbol" ? r2 + "" : r2, t2);
-class w {
-  constructor(r2 = "0.0.1") {
-    s(this, "server");
-    s(this, "transport", null);
-    s(this, "vmManager");
-    s(this, "version");
-    this.version = r2, this.vmManager = new te(), this.server = new mcp_js.McpServer({
+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") {
+    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({
       name: "cvm-server",
       version: this.version
     }), this.setupTools();
@@ -1918,14 +2086,14 @@ class w {
         programId: zod.z.string(),
         source: zod.z.string()
       },
-      async ({ programId: r2, source: t2 }) => {
+      async ({ programId: r, source: e2 }) => {
         try {
-          return await this.vmManager.loadProgram(r2, t2), {
-            content: [{ type: "text", text: `Program loaded successfully: ${r2}` }]
+          return await this.vmManager.loadProgram(r, e2), {
+            content: [{ type: "text", text: `Program loaded successfully: ${r}` }]
           };
-        } catch (e2) {
+        } catch (t2) {
           return {
-            content: [{ type: "text", text: `Error: ${e2 instanceof Error ? e2.message : "Unknown error"}` }],
+            content: [{ type: "text", text: `Error: ${t2 instanceof Error ? t2.message : "Unknown error"}` }],
             isError: true
           };
         }
@@ -1936,28 +2104,28 @@ class w {
         programId: zod.z.string(),
         filePath: zod.z.string()
       },
-      async ({ programId: r2, filePath: t2 }) => {
+      async ({ programId: r, filePath: e2 }) => {
         try {
-          const e2 = c$2.resolve(t2), i2 = await promises.readFile(e2, "utf-8");
-          return await this.vmManager.loadProgram(r2, i2), {
-            content: [{ type: "text", text: `Program loaded successfully from ${t2}: ${r2}` }]
+          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}` }]
           };
-        } catch (e2) {
-          if (e2 instanceof Error) {
-            const i2 = e2;
-            if (i2.code === "ENOENT")
+        } catch (t2) {
+          if (t2 instanceof Error) {
+            const n2 = t2;
+            if (n2.code === "ENOENT")
               return {
-                content: [{ type: "text", text: `Error: File not found: ${t2}` }],
+                content: [{ type: "text", text: `Error: File not found: ${e2}` }],
                 isError: true
               };
-            if (i2.code === "EACCES")
+            if (n2.code === "EACCES")
               return {
-                content: [{ type: "text", text: `Error: Permission denied: ${t2}` }],
+                content: [{ type: "text", text: `Error: Permission denied: ${e2}` }],
                 isError: true
               };
           }
           return {
-            content: [{ type: "text", text: `Error: ${e2 instanceof Error ? e2.message : "Unknown error"}` }],
+            content: [{ type: "text", text: `Error: ${t2 instanceof Error ? t2.message : "Unknown error"}` }],
             isError: true
           };
         }
@@ -1966,16 +2134,17 @@ class w {
       "start",
       {
         programId: zod.z.string(),
-        executionId: zod.z.string()
+        executionId: zod.z.string(),
+        setCurrent: zod.z.boolean().optional()
       },
-      async ({ programId: r2, executionId: t2 }) => {
+      async ({ programId: r, executionId: e2, setCurrent: t2 = true }) => {
         try {
-          return await this.vmManager.startExecution(r2, t2), {
-            content: [{ type: "text", text: `Execution started: ${t2}` }]
+          return await this.vmManager.startExecution(r, e2), t2 && await this.vmManager.setCurrentExecutionId(e2), {
+            content: [{ type: "text", text: `Execution started: ${e2}${t2 ? " (set as current)" : ""}` }]
           };
-        } catch (e2) {
+        } catch (n2) {
           return {
-            content: [{ type: "text", text: `Error: ${e2 instanceof Error ? e2.message : "Unknown error"}` }],
+            content: [{ type: "text", text: `Error: ${n2 instanceof Error ? n2.message : "Unknown error"}` }],
             isError: true
           };
         }
@@ -1983,11 +2152,20 @@ class w {
     ), this.server.tool(
       "getTask",
       {
-        executionId: zod.z.string()
+        executionId: zod.z.string().optional()
       },
-      async ({ executionId: r2 }) => {
+      async ({ executionId: r }) => {
         try {
-          const t2 = await this.vmManager.getNext(r2);
+          let e2 = r;
+          if (!e2) {
+            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;
+          }
+          const t2 = await this.vmManager.getNext(e2);
           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" ? {
@@ -1999,9 +2177,9 @@ class w {
             content: [{ type: "text", text: "Unexpected state" }],
             isError: true
           };
-        } catch (t2) {
+        } catch (e2) {
           return {
-            content: [{ type: "text", text: `Error: ${t2 instanceof Error ? t2.message : "Unknown error"}` }],
+            content: [{ type: "text", text: `Error: ${e2 instanceof Error ? e2.message : "Unknown error"}` }],
             isError: true
           };
         }
@@ -2009,14 +2187,52 @@ class w {
     ), this.server.tool(
       "submitTask",
       {
-        executionId: zod.z.string(),
+        executionId: zod.z.string().optional(),
         result: zod.z.string()
       },
-      async ({ executionId: r2, result: t2 }) => {
+      async ({ executionId: r, result: e2 }) => {
         try {
-          return await this.vmManager.reportCCResult(r2, t2), {
+          let t2 = r;
+          if (!t2) {
+            const n2 = await this.vmManager.getCurrentExecutionId();
+            if (!n2)
+              return {
+                content: [{ type: "text", text: "Error: No current execution set" }],
+                isError: true
+              };
+            t2 = n2;
+          }
+          return await this.vmManager.reportCCResult(t2, e2), {
             content: [{ type: "text", text: "Execution resumed" }]
           };
+        } catch (t2) {
+          return {
+            content: [{ type: "text", text: `Error: ${t2 instanceof Error ? t2.message : "Unknown error"}` }],
+            isError: true
+          };
+        }
+      }
+    ), this.server.tool(
+      "status",
+      {
+        executionId: zod.z.string().optional()
+      },
+      async ({ executionId: r }) => {
+        try {
+          let e2 = r;
+          if (!e2) {
+            const n2 = await this.vmManager.getCurrentExecutionId();
+            if (!n2)
+              return {
+                content: [{ type: "text", text: "Error: No current execution set" }],
+                isError: true
+              };
+            e2 = n2;
+          }
+          const t2 = await this.vmManager.getExecutionStatus(e2);
+          return {
+            content: [{ type: "text", text: JSON.stringify(t2, null, 2) }]
+          };
         } catch (e2) {
           return {
             content: [{ type: "text", text: `Error: ${e2 instanceof Error ? e2.message : "Unknown error"}` }],
@@ -2025,15 +2241,117 @@ class w {
         }
       }
     ), this.server.tool(
-      "status",
+      "list_executions",
+      {},
+      async () => {
+        try {
+          const r = await this.vmManager.listExecutions(), e2 = await this.vmManager.getCurrentExecutionId(), t2 = r.map((n2) => ({
+            executionId: n2.id,
+            programId: n2.programId,
+            state: n2.state,
+            created: n2.created,
+            isCurrent: n2.id === e2,
+            summary: {
+              currentPrompt: n2.state === "AWAITING_COGNITIVE_RESULT" ? n2.ccPrompt : void 0,
+              tasksCompleted: 0
+              // TODO: Track this in future
+            }
+          }));
+          return {
+            content: [{ type: "text", text: JSON.stringify(t2, null, 2) }]
+          };
+        } catch (r) {
+          return {
+            content: [{ type: "text", text: `Error: ${r instanceof Error ? r.message : "Unknown error"}` }],
+            isError: true
+          };
+        }
+      }
+    ), this.server.tool(
+      "get_execution",
+      {
+        executionId: zod.z.string().optional()
+      },
+      async ({ executionId: r }) => {
+        try {
+          let e2 = r;
+          if (!e2) {
+            const a2 = await this.vmManager.getCurrentExecutionId();
+            if (!a2)
+              return {
+                content: [{ type: "text", text: "Error: No current execution set" }],
+                isError: true
+              };
+            e2 = a2;
+          }
+          const t2 = await this.vmManager.getExecutionWithAttempts(e2), n2 = await this.vmManager.getCurrentExecutionId(), c2 = {
+            executionId: t2.id,
+            programId: t2.programId,
+            state: t2.state,
+            created: t2.created,
+            isCurrent: t2.id === n2,
+            currentTask: t2.state === "AWAITING_COGNITIVE_RESULT" ? {
+              prompt: t2.ccPrompt,
+              attempts: t2.attempts || 1,
+              firstAttemptAt: t2.firstAttemptAt || t2.created,
+              lastAttemptAt: t2.lastAttemptAt || t2.created
+            } : void 0,
+            variables: t2.variables,
+            stats: {
+              tasksCompleted: 0
+              // TODO: Track this
+            }
+          };
+          return {
+            content: [{ type: "text", text: JSON.stringify(c2, null, 2) }]
+          };
+        } catch (e2) {
+          return {
+            content: [{ type: "text", text: `Error: ${e2 instanceof Error ? e2.message : "Unknown error"}` }],
+            isError: true
+          };
+        }
+      }
+    ), this.server.tool(
+      "set_current",
       {
         executionId: zod.z.string()
       },
-      async ({ executionId: r2 }) => {
+      async ({ executionId: r }) => {
         try {
-          const t2 = await this.vmManager.getExecutionStatus(r2);
+          return await this.vmManager.setCurrentExecutionId(r), {
+            content: [{ type: "text", text: `Current execution set to: ${r}` }]
+          };
+        } catch (e2) {
           return {
-            content: [{ type: "text", text: JSON.stringify(t2, null, 2) }]
+            content: [{ type: "text", text: `Error: ${e2 instanceof Error ? e2.message : "Unknown error"}` }],
+            isError: true
+          };
+        }
+      }
+    ), this.server.tool(
+      "delete_execution",
+      {
+        executionId: zod.z.string(),
+        confirmToken: zod.z.string().optional()
+      },
+      async ({ executionId: r, confirmToken: e2 }) => {
+        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}` }]
+          }) : {
+            content: [{ type: "text", text: "Invalid confirmation token" }],
+            isError: true
+          } : {
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                confirmationRequired: true,
+                message: `To delete execution '${r}', call this tool again with the confirmation token`,
+                token: t2
+              }, null, 2)
+            }]
           };
         } catch (t2) {
           return {
@@ -2044,8 +2362,8 @@ class w {
       }
     );
   }
-  async start(r2) {
-    await this.vmManager.initialize(), this.transport = r2 || new stdio_js.StdioServerTransport(), await this.server.connect(this.transport);
+  async start(r) {
+    await this.vmManager.initialize(), this.transport = r || 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();
@@ -2055,7 +2373,7 @@ class w {
     return this.vmManager;
   }
 }
-dotenv__namespace.config({ path: c$2.resolve(__dirname, "../../../.env") });
+dotenv__namespace.config({ path: c$1.resolve(__dirname, "../../../.env") });
 function loadConfig() {
   const env = process.env.NODE_ENV || "development";
   const storageType = process.env.CVM_STORAGE_TYPE || "file";
@@ -2136,7 +2454,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$2.dirname(__filename$1);
+const __dirname$1 = c$1.dirname(__filename$1);
 async function main() {
   let cvmServer;
   try {
@@ -2145,16 +2463,16 @@ async function main() {
     const logger2 = getLogger();
     let version = "0.4.3";
     const possiblePaths = [
-      c$2.join(__dirname$1, "..", "package.json"),
+      c$1.join(__dirname$1, "..", "package.json"),
       // Development
-      c$2.join(__dirname$1, "package.json"),
+      c$1.join(__dirname$1, "package.json"),
       // Bundled dist
-      c$2.join(process.cwd(), "package.json")
+      c$1.join(process.cwd(), "package.json")
       // Current directory
     ];
     for (const packageJsonPath of possiblePaths) {
       try {
-        const packageJson = JSON.parse(G$1.readFileSync(packageJsonPath, "utf-8"));
+        const packageJson = JSON.parse(M$2.readFileSync(packageJsonPath, "utf-8"));
         if (packageJson.name === "cvm-server" && packageJson.version) {
           version = packageJson.version;
           break;
@@ -2169,13 +2487,13 @@ async function main() {
     });
     if (config.storage.type === "file") {
       const dataDir = config.storage.dataDir || ".cvm";
-      const fullPath = c$2.resolve(process.cwd(), dataDir);
+      const fullPath = c$1.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 w(version);
+    cvmServer = new M(version);
     await cvmServer.start();
     logger2.info("CVM Server is running and ready to accept MCP connections");
     process.on("SIGINT", async () => {