cvm-server 0.8.0 → 0.9.0

package/main.cjs

@@ -3,7 +3,7 @@ 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 P$1 = require("fs");
+const G$1 = require("fs");
 const c$2 = require("path");
 const mongodb = require("mongodb");
 const promises = require("fs/promises");
@@ -27,24 +27,24 @@ function _interopNamespaceDefault(e2) {
   return Object.freeze(n2);
 }
 const n__namespace = /* @__PURE__ */ _interopNamespaceDefault(n$1);
-const P__namespace = /* @__PURE__ */ _interopNamespaceDefault(P$1);
+const G__namespace = /* @__PURE__ */ _interopNamespaceDefault(G$1);
 const c__namespace = /* @__PURE__ */ _interopNamespaceDefault(c$2);
 const dotenv__namespace = /* @__PURE__ */ _interopNamespaceDefault(dotenv);
-var f$1 = Object.defineProperty;
-var p$2 = (e2, t2, i2) => t2 in e2 ? f$1(e2, t2, { enumerable: true, configurable: true, writable: true, value: i2 }) : e2[t2] = i2;
-var m$2 = (e2, t2, i2) => p$2(e2, typeof t2 != "symbol" ? t2 + "" : t2, i2);
-var s$2 = /* @__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.CC = "CC", e2.PRINT = "PRINT", e2.HALT = "HALT", e2))(s$2 || {});
-function A(e2) {
-  const t2 = [], i2 = [];
+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 || {});
+function R(e2) {
+  const t2 = [], s2 = [];
   let r2 = false, a2 = false;
-  const l2 = n__namespace.createSourceFile(
+  const m2 = n__namespace.createSourceFile(
     "program.ts",
     e2,
     n__namespace.ScriptTarget.Latest,
     true
   );
-  function S(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 === l2) {
+  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);
     }
@@ -52,25 +52,25 @@ function A(e2) {
       const c2 = o2.expression.text;
       ["setTimeout", "fetch", "require", "import"].includes(c2) && t2.push(`Unsupported function: ${c2}`);
     }
-    n__namespace.forEachChild(o2, S);
+    n__namespace.forEachChild(o2, l2);
   }
-  return S(l2), r2 || t2.push("Program must have a main() function"), r2 && !a2 && t2.push("main() must be called at the top level"), t2.length === 0 && i2.push({ op: s$2.HALT }), {
-    bytecode: i2,
+  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 }), {
+    bytecode: s2,
     errors: t2,
     hasMain: r2
   };
 }
-class R {
+let A$1 = class A {
   constructor() {
-    m$2(this, "bytecode", []);
-    m$2(this, "contextStack", []);
+    x$1(this, "bytecode", []);
+    x$1(this, "contextStack", []);
   }
   /**
    * Emit an instruction and return its index
    */
-  emit(t2, i2) {
+  emit(t2, s2) {
     const r2 = this.bytecode.length;
-    return this.bytecode.push({ op: t2, arg: i2 }), r2;
+    return this.bytecode.push({ op: t2, arg: s2 }), r2;
   }
   /**
    * Get the current address (next instruction index)
@@ -81,14 +81,14 @@ class R {
   /**
    * Patch a jump instruction with the target address
    */
-  patchJump(t2, i2) {
-    t2 >= 0 && t2 < this.bytecode.length && (this.bytecode[t2].arg = i2);
+  patchJump(t2, s2) {
+    t2 >= 0 && t2 < this.bytecode.length && (this.bytecode[t2].arg = s2);
   }
   /**
    * Patch multiple jump instructions with the same target
    */
-  patchJumps(t2, i2) {
-    t2.forEach((r2) => this.patchJump(r2, i2));
+  patchJumps(t2, s2) {
+    t2.forEach((r2) => this.patchJump(r2, s2));
   }
   /**
    * Push a new jump context onto the stack
@@ -113,9 +113,9 @@ class R {
    */
   findLoopContext() {
     for (let t2 = this.contextStack.length - 1; t2 >= 0; t2--) {
-      const i2 = this.contextStack[t2];
-      if (i2.type === "loop" || i2.type === "foreach")
-        return i2;
+      const s2 = this.contextStack[t2];
+      if (s2.type === "loop" || s2.type === "foreach")
+        return s2;
     }
     return null;
   }
@@ -137,330 +137,353 @@ class R {
   getUnclosedContexts() {
     return [...this.contextStack];
   }
-}
-const h$1 = (e2, t2, { compileExpression: i2, compileStatement: r2 }) => {
-  i2(e2.expression);
-  const a2 = t2.emit(s$2.JUMP_IF_FALSE, -1), l2 = {
+};
+const P$1 = (e2, t2, { compileExpression: s2, compileStatement: r2 }) => {
+  s2(e2.expression);
+  const a2 = t2.emit(i$1.JUMP_IF_FALSE, -1), m2 = {
     type: "if",
     endTargets: []
   };
-  if (e2.elseStatement ? l2.elseTarget = a2 : l2.endTargets.push(a2), t2.pushContext(l2), r2(e2.thenStatement), e2.elseStatement) {
-    const o2 = t2.emit(s$2.JUMP, -1);
-    l2.endTargets.push(o2);
+  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 S = t2.popContext();
-  if (S) {
+  const l2 = t2.popContext();
+  if (l2) {
     const o2 = t2.currentAddress();
-    t2.patchJumps(S.endTargets, o2);
+    t2.patchJumps(l2.endTargets, o2);
   }
-}, I = (e2, t2, { compileExpression: i2, compileStatement: r2 }) => {
+}, I = (e2, t2, { compileExpression: s2, compileStatement: r2 }) => {
   const a2 = t2.currentAddress();
-  i2(e2.expression);
-  const S = {
+  s2(e2.expression);
+  const l2 = {
     type: "loop",
-    breakTargets: [t2.emit(s$2.JUMP_IF_FALSE, -1)],
+    breakTargets: [t2.emit(i$1.JUMP_IF_FALSE, -1)],
     continueTargets: [],
     endTargets: [],
     startAddress: a2
   };
-  t2.pushContext(S), r2(e2.statement), t2.emit(s$2.JUMP, a2);
+  t2.pushContext(l2), r2(e2.statement), t2.emit(i$1.JUMP, a2);
   const o2 = t2.popContext();
   if (o2) {
     const c2 = t2.currentAddress();
     t2.patchJumps(o2.breakTargets || [], c2);
   }
-}, y$1 = (e2, t2, { compileExpression: i2, compileStatement: r2 }) => {
-  const a2 = e2.initializer, l2 = e2.expression;
-  let S;
+}, h$2 = (e2, t2, { compileExpression: s2, compileStatement: r2 }) => {
+  const a2 = e2.initializer, m2 = e2.expression;
+  let l2;
   if (n__namespace.isVariableDeclarationList(a2))
-    S = a2.declarations[0].name.getText();
+    l2 = a2.declarations[0].name.getText();
   else if (n__namespace.isIdentifier(a2))
-    S = a2.text;
+    l2 = a2.text;
   else
     throw new Error("Unsupported for-of variable declaration");
-  i2(l2), t2.emit(s$2.ITER_START);
+  s2(m2), t2.emit(i$1.ITER_START);
   const o2 = t2.currentAddress();
-  t2.emit(s$2.ITER_NEXT);
-  const c2 = t2.emit(s$2.JUMP_IF_FALSE, -1);
-  t2.emit(s$2.STORE, S);
-  const x2 = {
+  t2.emit(i$1.ITER_NEXT);
+  const c2 = t2.emit(i$1.JUMP_IF_FALSE, -1);
+  t2.emit(i$1.STORE, l2);
+  const S = {
     type: "foreach",
     breakTargets: [c2],
     continueTargets: [],
     endTargets: [],
     startAddress: o2,
-    iterVariable: S
+    iterVariable: l2
   };
-  t2.pushContext(x2), r2(e2.statement), t2.emit(s$2.JUMP, o2);
+  t2.pushContext(S), r2(e2.statement), t2.emit(i$1.JUMP, o2);
   const u2 = t2.popContext();
   if (u2) {
-    const E2 = t2.currentAddress();
-    t2.patchJumps(u2.breakTargets || [], E2), t2.emit(s$2.ITER_END);
+    const E = t2.currentAddress();
+    t2.patchJumps(u2.breakTargets || [], E), t2.emit(i$1.ITER_END);
   }
-}, N$1 = (e2, t2, { compileStatement: i2 }) => {
+}, y$1 = (e2, t2, { compileStatement: s2 }) => {
   e2.statements.forEach((r2) => {
-    i2(r2);
+    s2(r2);
   });
-}, g$1 = (e2, t2, { compileExpression: i2 }) => {
+}, N$1 = (e2, t2, { compileExpression: s2 }) => {
   const r2 = e2.declarationList.declarations[0];
-  r2.initializer && (i2(r2.initializer), t2.emit(s$2.STORE, r2.name.getText()));
-}, P = (e2, t2, { compileExpression: i2 }) => {
+  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(s$2.LOAD, r2.left.text), i2(r2.right), a2) {
+        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(s$2.CONCAT) : t2.emit(s$2.ADD);
+            n__namespace.isStringLiteral(r2.right) ? t2.emit(i$1.CONCAT) : t2.emit(i$1.ADD);
             break;
           case n__namespace.SyntaxKind.MinusEqualsToken:
-            t2.emit(s$2.SUB);
+            t2.emit(i$1.SUB);
             break;
           case n__namespace.SyntaxKind.AsteriskEqualsToken:
-            t2.emit(s$2.MUL);
+            t2.emit(i$1.MUL);
             break;
           case n__namespace.SyntaxKind.SlashEqualsToken:
-            t2.emit(s$2.DIV);
+            t2.emit(i$1.DIV);
             break;
           case n__namespace.SyntaxKind.PercentEqualsToken:
-            t2.emit(s$2.MOD);
+            t2.emit(i$1.MOD);
             break;
         }
-        t2.emit(s$2.STORE, r2.left.text);
+        t2.emit(i$1.STORE, r2.left.text);
       } else if (n__namespace.isElementAccessExpression(r2.left))
         throw new Error("Compound assignment to array elements not yet supported");
       return;
     } else if (a2 === n__namespace.SyntaxKind.EqualsToken) {
-      if (i2(r2.right), n__namespace.isIdentifier(r2.left))
-        t2.emit(s$2.STORE, r2.left.text);
+      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 l2 = `__temp_${t2.getBytecode().length}`;
-        t2.emit(s$2.STORE, l2), i2(r2.left.expression), i2(r2.left.argumentExpression), t2.emit(s$2.LOAD, l2), t2.emit(s$2.ARRAY_SET);
+        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);
       }
       return;
     }
   }
   n__namespace.isCallExpression(r2) && n__namespace.isPropertyAccessExpression(r2.expression) && r2.expression.expression.getText() === "console" && r2.expression.name.getText() === "log" ? (r2.arguments.forEach((a2) => {
-    i2(a2);
-  }), t2.emit(s$2.PRINT)) : n__namespace.isCallExpression(r2) && n__namespace.isIdentifier(r2.expression) && r2.expression.text === "CC" ? (r2.arguments.length > 0 && i2(r2.arguments[0]), t2.emit(s$2.CC), t2.emit(s$2.POP)) : n__namespace.isCallExpression(r2) && n__namespace.isPropertyAccessExpression(r2.expression) && r2.expression.name.getText() === "push" ? (i2(r2.expression.expression), r2.arguments.length > 0 && i2(r2.arguments[0]), t2.emit(s$2.ARRAY_PUSH)) : (n__namespace.isPostfixUnaryExpression(r2) || n__namespace.isPrefixUnaryExpression(r2)) && (i2(r2), t2.emit(s$2.POP));
-}, k = (e2, t2, { compileExpression: i2 }) => {
-  e2.expression ? i2(e2.expression) : t2.emit(s$2.PUSH, null), t2.emit(s$2.RETURN);
-}, _ = (e2, t2, i2) => {
+    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);
+}, k = (e2, t2, s2) => {
   const r2 = t2.findLoopContext();
   if (r2) {
-    r2.type === "foreach" && t2.emit(s$2.ITER_END);
-    const a2 = t2.emit(s$2.BREAK, -1);
+    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);
   } else
     throw new Error("break statement not in loop");
-}, U$1 = (e2, t2, i2) => {
+}, U = (e2, t2, s2) => {
   const r2 = t2.findLoopContext();
   if (r2 && r2.startAddress !== void 0) {
-    const a2 = t2.emit(s$2.CONTINUE, r2.startAddress);
+    const a2 = t2.emit(i$1.CONTINUE, r2.startAddress);
     r2.continueTargets = r2.continueTargets || [], r2.continueTargets.push(a2);
   } else
     throw new Error("continue statement not in loop");
 }, L$1 = {
-  [n__namespace.SyntaxKind.IfStatement]: h$1,
+  [n__namespace.SyntaxKind.IfStatement]: P$1,
   [n__namespace.SyntaxKind.WhileStatement]: I,
-  [n__namespace.SyntaxKind.ForOfStatement]: y$1,
-  [n__namespace.SyntaxKind.Block]: N$1,
-  [n__namespace.SyntaxKind.VariableStatement]: g$1,
-  [n__namespace.SyntaxKind.ExpressionStatement]: P,
-  [n__namespace.SyntaxKind.ReturnStatement]: k,
-  [n__namespace.SyntaxKind.BreakStatement]: _,
-  [n__namespace.SyntaxKind.ContinueStatement]: U$1
-}, d$1 = (e2, t2, i2) => {
-  t2.emit(s$2.PUSH, e2.text);
-}, K = (e2, t2, i2) => {
-  t2.emit(s$2.PUSH, Number(e2.text));
-}, b$1 = (e2, t2, i2) => {
-  t2.emit(s$2.PUSH, true);
-}, F$1 = (e2, t2, i2) => {
-  t2.emit(s$2.PUSH, false);
-}, D$1 = (e2, t2, i2) => {
-  t2.emit(s$2.PUSH, null);
-}, G$1 = (e2, t2, i2) => {
-  e2.text === "undefined" ? t2.emit(s$2.PUSH_UNDEFINED) : t2.emit(s$2.LOAD, e2.text);
-}, M$1 = (e2, t2, { compileExpression: i2 }) => {
-  t2.emit(s$2.ARRAY_NEW), e2.elements.forEach((r2) => {
-    i2(r2), t2.emit(s$2.ARRAY_PUSH);
+  [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);
+}, K = (e2, t2, s2) => {
+  t2.emit(i$1.PUSH, Number(e2.text));
+}, b$2 = (e2, t2, s2) => {
+  t2.emit(i$1.PUSH, true);
+}, F$1 = (e2, t2, s2) => {
+  t2.emit(i$1.PUSH, false);
+}, 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);
+}, H$1 = (e2, t2, { compileExpression: s2 }) => {
+  t2.emit(i$1.ARRAY_NEW), e2.elements.forEach((r2) => {
+    s2(r2), t2.emit(i$1.ARRAY_PUSH);
   });
-}, H$1 = (e2, t2, { compileExpression: i2 }) => {
-  i2(e2.expression);
-}, C$1 = (e2, t2, { compileExpression: i2 }) => {
-  e2.name.text === "length" && (i2(e2.expression), t2.emit(s$2.LENGTH));
-}, J = (e2, t2, { compileExpression: i2 }) => {
-  i2(e2.expression), e2.argumentExpression && i2(e2.argumentExpression), t2.emit(s$2.ARRAY_GET);
-}, w$2 = (e2, t2, { compileExpression: i2 }) => {
+}, 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 }) => {
   switch (e2.operator) {
     case n__namespace.SyntaxKind.ExclamationToken:
-      i2(e2.operand), t2.emit(s$2.NOT);
+      s2(e2.operand), t2.emit(i$1.NOT);
       break;
     case n__namespace.SyntaxKind.MinusToken:
-      i2(e2.operand), t2.emit(s$2.UNARY_MINUS);
+      s2(e2.operand), t2.emit(i$1.UNARY_MINUS);
       break;
     case n__namespace.SyntaxKind.PlusToken:
-      i2(e2.operand), t2.emit(s$2.UNARY_PLUS);
+      s2(e2.operand), t2.emit(i$1.UNARY_PLUS);
       break;
     case n__namespace.SyntaxKind.PlusPlusToken:
-      n__namespace.isIdentifier(e2.operand) && (t2.emit(s$2.PUSH, e2.operand.text), t2.emit(s$2.INC, false));
+      n__namespace.isIdentifier(e2.operand) && (t2.emit(i$1.PUSH, e2.operand.text), t2.emit(i$1.INC, false));
       break;
     case n__namespace.SyntaxKind.MinusMinusToken:
-      n__namespace.isIdentifier(e2.operand) && (t2.emit(s$2.PUSH, e2.operand.text), t2.emit(s$2.DEC, false));
+      n__namespace.isIdentifier(e2.operand) && (t2.emit(i$1.PUSH, e2.operand.text), t2.emit(i$1.DEC, false));
       break;
   }
-}, B = (e2, t2, { compileExpression: i2 }) => {
+}, w$1 = (e2, t2, { compileExpression: s2 }) => {
   switch (e2.operator) {
     case n__namespace.SyntaxKind.PlusPlusToken:
-      n__namespace.isIdentifier(e2.operand) && (t2.emit(s$2.PUSH, e2.operand.text), t2.emit(s$2.INC, true));
+      n__namespace.isIdentifier(e2.operand) && (t2.emit(i$1.PUSH, e2.operand.text), t2.emit(i$1.INC, true));
       break;
     case n__namespace.SyntaxKind.MinusMinusToken:
-      n__namespace.isIdentifier(e2.operand) && (t2.emit(s$2.PUSH, e2.operand.text), t2.emit(s$2.DEC, true));
+      n__namespace.isIdentifier(e2.operand) && (t2.emit(i$1.PUSH, e2.operand.text), t2.emit(i$1.DEC, true));
       break;
   }
 };
-function T$1(e2, t2) {
-  return !!(n__namespace.isStringLiteral(e2) || n__namespace.isStringLiteral(t2) || n__namespace.isBinaryExpression(e2) && e2.operatorToken.kind === n__namespace.SyntaxKind.PlusToken && T$1(e2.left, e2.right) || n__namespace.isBinaryExpression(t2) && t2.operatorToken.kind === n__namespace.SyntaxKind.PlusToken && T$1(t2.left, t2.right));
+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));
 }
-const Y$1 = (e2, t2, { compileExpression: i2 }) => {
+const B$1 = (e2, t2, { compileExpression: s2 }) => {
   const r2 = e2.operatorToken.kind;
-  switch (i2(e2.left), i2(e2.right), r2) {
+  switch (s2(e2.left), s2(e2.right), r2) {
     case n__namespace.SyntaxKind.PlusToken:
-      T$1(e2.left, e2.right) ? t2.emit(s$2.CONCAT) : t2.emit(s$2.ADD);
+      T(e2.left, e2.right) ? t2.emit(i$1.CONCAT) : t2.emit(i$1.ADD);
       break;
     case n__namespace.SyntaxKind.MinusToken:
-      t2.emit(s$2.SUB);
+      t2.emit(i$1.SUB);
       break;
     case n__namespace.SyntaxKind.AsteriskToken:
-      t2.emit(s$2.MUL);
+      t2.emit(i$1.MUL);
       break;
     case n__namespace.SyntaxKind.SlashToken:
-      t2.emit(s$2.DIV);
+      t2.emit(i$1.DIV);
       break;
     case n__namespace.SyntaxKind.PercentToken:
-      t2.emit(s$2.MOD);
+      t2.emit(i$1.MOD);
       break;
     case n__namespace.SyntaxKind.EqualsEqualsToken:
-      t2.emit(s$2.EQ);
+      t2.emit(i$1.EQ);
       break;
     case n__namespace.SyntaxKind.ExclamationEqualsToken:
-      t2.emit(s$2.NEQ);
+      t2.emit(i$1.NEQ);
       break;
     case n__namespace.SyntaxKind.LessThanToken:
-      t2.emit(s$2.LT);
+      t2.emit(i$1.LT);
       break;
     case n__namespace.SyntaxKind.GreaterThanToken:
-      t2.emit(s$2.GT);
+      t2.emit(i$1.GT);
       break;
     case n__namespace.SyntaxKind.LessThanEqualsToken:
-      t2.emit(s$2.LTE);
+      t2.emit(i$1.LTE);
       break;
     case n__namespace.SyntaxKind.GreaterThanEqualsToken:
-      t2.emit(s$2.GTE);
+      t2.emit(i$1.GTE);
       break;
     case n__namespace.SyntaxKind.EqualsEqualsEqualsToken:
-      t2.emit(s$2.EQ_STRICT);
+      t2.emit(i$1.EQ_STRICT);
       break;
     case n__namespace.SyntaxKind.ExclamationEqualsEqualsToken:
-      t2.emit(s$2.NEQ_STRICT);
+      t2.emit(i$1.NEQ_STRICT);
       break;
     case n__namespace.SyntaxKind.AmpersandAmpersandToken:
-      t2.emit(s$2.AND);
+      t2.emit(i$1.AND);
       break;
     case n__namespace.SyntaxKind.BarBarToken:
-      t2.emit(s$2.OR);
+      t2.emit(i$1.OR);
       break;
   }
-}, q$1 = (e2, t2, { compileExpression: i2 }) => {
-  i2(e2.condition);
-  const r2 = t2.emit(s$2.JUMP_IF_FALSE, -1);
-  i2(e2.whenTrue);
-  const a2 = t2.emit(s$2.JUMP, -1), l2 = t2.currentAddress();
-  t2.patchJump(r2, l2), i2(e2.whenFalse);
-  const S = t2.currentAddress();
-  t2.patchJump(a2, S);
-}, Q = (e2, t2, { compileExpression: i2 }) => {
-  i2(e2.expression), t2.emit(s$2.TYPEOF);
-}, V$1 = (e2, t2, { compileExpression: i2 }) => {
+}, q$1 = (e2, t2, { compileExpression: s2 }) => {
+  s2(e2.condition);
+  const r2 = t2.emit(i$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);
+}, O = (e2, t2, { compileExpression: s2 }) => {
+  s2(e2.expression), t2.emit(i$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 ? i2(e2.arguments[0]) : t2.emit(s$2.PUSH, "."), e2.arguments.length > 1 && i2(e2.arguments[1]), t2.emit(s$2.FS_LIST_FILES);
+    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 && i2(e2.arguments[0]), t2.emit(s$2.JSON_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 && i2(e2.arguments[0]), t2.emit(s$2.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")
-      i2(e2.expression.expression), e2.arguments.length > 0 ? i2(e2.arguments[0]) : t2.emit(s$2.PUSH, 0), e2.arguments.length > 1 && i2(e2.arguments[1]), t2.emit(s$2.STRING_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")
-      i2(e2.expression.expression), e2.arguments.length > 0 ? i2(e2.arguments[0]) : t2.emit(s$2.PUSH, ""), t2.emit(s$2.STRING_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")
-      i2(e2.expression.expression), e2.arguments.length > 0 ? i2(e2.arguments[0]) : t2.emit(s$2.PUSH, ""), t2.emit(s$2.STRING_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")
-      i2(e2.expression.expression), e2.arguments.length > 0 ? i2(e2.arguments[0]) : t2.emit(s$2.PUSH, 0), e2.arguments.length > 1 && i2(e2.arguments[1]), t2.emit(s$2.STRING_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")
-      i2(e2.expression.expression), e2.arguments.length > 0 ? i2(e2.arguments[0]) : t2.emit(s$2.PUSH, 0), t2.emit(s$2.STRING_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")
-      i2(e2.expression.expression), t2.emit(s$2.STRING_TOUPPERCASE);
+      s2(e2.expression.expression), t2.emit(i$1.STRING_TOUPPERCASE);
     else if (r2 === "toLowerCase")
-      i2(e2.expression.expression), t2.emit(s$2.STRING_TOLOWERCASE);
+      s2(e2.expression.expression), t2.emit(i$1.STRING_TOLOWERCASE);
     else
       throw new Error(`Method call '${r2}' 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)) {
+      let a2;
+      if (n__namespace.isIdentifier(r2.name))
+        a2 = r2.name.text;
+      else if (n__namespace.isStringLiteral(r2.name))
+        a2 = r2.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);
+    } 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$1,
+  [n__namespace.SyntaxKind.TrueKeyword]: b$2,
   [n__namespace.SyntaxKind.FalseKeyword]: F$1,
   [n__namespace.SyntaxKind.NullKeyword]: D$1,
-  [n__namespace.SyntaxKind.Identifier]: G$1,
-  [n__namespace.SyntaxKind.ArrayLiteralExpression]: M$1,
-  [n__namespace.SyntaxKind.BinaryExpression]: Y$1,
-  [n__namespace.SyntaxKind.PrefixUnaryExpression]: w$2,
-  [n__namespace.SyntaxKind.PostfixUnaryExpression]: B,
+  [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]: C$1,
-  [n__namespace.SyntaxKind.ElementAccessExpression]: J,
+  [n__namespace.SyntaxKind.PropertyAccessExpression]: J$1,
+  [n__namespace.SyntaxKind.ElementAccessExpression]: C,
   [n__namespace.SyntaxKind.ConditionalExpression]: q$1,
-  [n__namespace.SyntaxKind.TypeOfExpression]: Q,
-  [n__namespace.SyntaxKind.ParenthesizedExpression]: H$1
+  [n__namespace.SyntaxKind.TypeOfExpression]: O,
+  [n__namespace.SyntaxKind.ParenthesizedExpression]: M$1,
+  [n__namespace.SyntaxKind.ObjectLiteralExpression]: Q
 };
-function j(e2) {
-  const t2 = A(e2);
+function W$1(e2) {
+  const t2 = R(e2);
   if (t2.errors.length > 0)
     return {
       success: false,
       bytecode: [],
       errors: t2.errors
     };
-  const i2 = new R(), r2 = n__namespace.createSourceFile("program.ts", e2, n__namespace.ScriptTarget.Latest, true), a2 = {
-    compileStatement: l2,
-    compileExpression: S,
+  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);
     }
   };
-  function l2(o2) {
+  function m2(o2) {
     const c2 = L$1[o2.kind];
-    c2 && c2(o2, i2, a2);
+    c2 && c2(o2, s2, a2);
   }
-  function S(o2) {
+  function l2(o2) {
     const c2 = v[o2.kind];
-    c2 && c2(o2, i2, a2);
+    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((x2) => {
-      l2(x2);
+    n__namespace.isFunctionDeclaration(o2) && ((c2 = o2.name) == null ? void 0 : c2.text) === "main" && o2.body && o2.body.statements.forEach((S) => {
+      m2(S);
     });
-  }), i2.emit(s$2.HALT), {
+  }), s2.emit(i$1.HALT), {
     success: true,
-    bytecode: i2.getBytecode(),
+    bytecode: s2.getBytecode(),
     errors: []
   };
 }
@@ -473,45 +496,51 @@ function t(r2) {
 function i(r2) {
   return typeof r2 == "boolean";
 }
-function f(r2) {
+function e(r2) {
   return r2 === null;
 }
-function e(r2) {
+function f(r2) {
   return r2 !== null && typeof r2 == "object" && "type" in r2 && r2.type === "array";
 }
 function o(r2) {
   return r2 !== null && typeof r2 == "object" && "type" in r2 && r2.type === "undefined";
 }
 function c$1(r2) {
-  return n(r2) ? r2 : t(r2) || i(r2) ? r2.toString() : f(r2) ? "null" : o(r2) ? "undefined" : e(r2) ? `[array:${r2.elements.length}]` : String(r2);
+  return r2 !== null && typeof r2 == "object" && "type" in r2 && r2.type === "object";
 }
 function y(r2) {
-  return i(r2) ? r2 : f(r2) || o(r2) ? false : t(r2) ? r2 !== 0 : n(r2) ? r2 !== "" : e(r2) ? true : !!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 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 m$1(r2) {
-  return n(r2) ? "string" : t(r2) ? "number" : i(r2) ? "boolean" : f(r2) ? "null" : o(r2) ? "undefined" : e(r2) ? "array" : "unknown";
+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 d(r2) {
+function m(r2) {
   if (t(r2)) return r2;
   if (i(r2)) return r2 ? 1 : 0;
-  if (f(r2)) return 0;
+  if (e(r2)) return 0;
   if (o(r2)) return NaN;
   if (n(r2)) {
     const u2 = r2.trim();
     return u2 === "" ? 0 : Number(u2);
   }
-  return e(r2) ? NaN : Number(r2);
+  return f(r2) ? NaN : Number(r2);
 }
-function p$1(r2 = []) {
+function d(r2 = []) {
   return { type: "array", elements: r2 };
 }
 function s$1() {
   return { type: "undefined" };
 }
+function j$1(r2 = {}) {
+  return { type: "object", properties: r2 };
+}
 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);
-class h {
+let h$1 = class h {
   constructor(t2) {
     r(this, "connected", false);
     r(this, "programsDir");
@@ -520,7 +549,7 @@ class h {
     this.dataDir = t2, this.programsDir = c__namespace.join(t2, "programs"), this.executionsDir = c__namespace.join(t2, "executions"), this.outputsDir = c__namespace.join(t2, "outputs");
   }
   async connect() {
-    await P$1.promises.mkdir(this.dataDir, { recursive: true }), await P$1.promises.mkdir(this.programsDir, { recursive: true }), await P$1.promises.mkdir(this.executionsDir, { recursive: true }), await P$1.promises.mkdir(this.outputsDir, { recursive: true }), this.connected = true;
+    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;
   }
   async disconnect() {
     this.connected = false;
@@ -531,13 +560,13 @@ 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 P$1.promises.writeFile(n2, e2, "utf-8");
+    await G$1.promises.writeFile(n2, e2, "utf-8");
   }
   async getProgram(t2) {
     if (!this.connected) throw new Error("Not connected");
     const n2 = c__namespace.join(this.programsDir, `${t2}.json`);
     try {
-      const e2 = await P$1.promises.readFile(n2, "utf-8"), o2 = JSON.parse(e2);
+      const e2 = await G$1.promises.readFile(n2, "utf-8"), o2 = JSON.parse(e2);
       return o2.created = new Date(o2.created), o2.updated && (o2.updated = new Date(o2.updated)), o2;
     } catch (e2) {
       if (e2.code === "ENOENT")
@@ -548,13 +577,13 @@ class h {
   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 P$1.promises.writeFile(n2, e2, "utf-8");
+    await G$1.promises.writeFile(n2, e2, "utf-8");
   }
   async getExecution(t2) {
     if (!this.connected) throw new Error("Not connected");
     const n2 = c__namespace.join(this.executionsDir, `${t2}.json`);
     try {
-      const e2 = await P$1.promises.readFile(n2, "utf-8"), o2 = JSON.parse(e2);
+      const e2 = await G$1.promises.readFile(n2, "utf-8"), o2 = JSON.parse(e2);
       return o2.created = new Date(o2.created), o2.updated && (o2.updated = new Date(o2.updated)), o2;
     } catch (e2) {
       if (e2.code === "ENOENT")
@@ -567,13 +596,13 @@ class h {
     const e2 = c__namespace.join(this.outputsDir, `${t2}.output`), o2 = n2.join(`
 `) + `
 `;
-    await P$1.promises.appendFile(e2, o2, "utf-8");
+    await G$1.promises.appendFile(e2, o2, "utf-8");
   }
   async getOutput(t2) {
     if (!this.connected) throw new Error("Not connected");
     const n2 = c__namespace.join(this.outputsDir, `${t2}.output`);
     try {
-      return (await P$1.promises.readFile(n2, "utf-8")).split(`
+      return (await G$1.promises.readFile(n2, "utf-8")).split(`
 `).filter((o2) => o2.length > 0);
     } catch (e2) {
       if (e2.code === "ENOENT")
@@ -581,7 +610,7 @@ class h {
       throw e2;
     }
   }
-}
+};
 class p {
   constructor(t2) {
     r(this, "client");
@@ -643,13 +672,13 @@ class p {
     return (e2 == null ? void 0 : e2.lines) || [];
   }
 }
-class g {
+let g$1 = class g {
   static create(t2) {
     const n2 = (t2 == null ? void 0 : t2.type) || process.env.CVM_STORAGE_TYPE || "file";
     switch (n2) {
       case "file": {
         const e2 = (t2 == null ? void 0 : t2.dataDir) || process.env.CVM_DATA_DIR || ".cvm";
-        return new h(e2);
+        return new h$1(e2);
       }
       case "mongodb": {
         const e2 = (t2 == null ? void 0 : t2.mongoUri) || process.env.MONGODB_URI || "mongodb://localhost:27017/cvm";
@@ -659,40 +688,40 @@ class g {
         throw new Error(`Unsupported storage type: ${n2}`);
     }
   }
-}
-var T = Object.defineProperty;
-var w$1 = (e2, r2, t2) => r2 in e2 ? T(e2, r2, { enumerable: true, configurable: true, writable: true, value: t2 }) : e2[r2] = t2;
-var E = (e2, r2, t2) => w$1(e2, typeof r2 != "symbol" ? r2 + "" : r2, t2);
-const C = {
-  [s$2.ADD]: {
+};
+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]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2) => {
-      const r2 = e2.stack.pop(), t2 = e2.stack.pop(), s2 = d(t2), c2 = d(r2);
-      e2.stack.push(s2 + c2);
+      const r2 = e2.stack.pop(), t2 = e2.stack.pop(), s2 = m(t2), o2 = m(r2);
+      e2.stack.push(s2 + o2);
     }
   },
-  [s$2.SUB]: {
+  [i$1.SUB]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2) => {
-      const r2 = e2.stack.pop(), t2 = e2.stack.pop(), s2 = d(t2), c2 = d(r2);
-      e2.stack.push(s2 - c2);
+      const r2 = e2.stack.pop(), t2 = e2.stack.pop(), s2 = m(t2), o2 = m(r2);
+      e2.stack.push(s2 - o2);
     }
   },
-  [s$2.MUL]: {
+  [i$1.MUL]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2) => {
-      const r2 = e2.stack.pop(), t2 = e2.stack.pop(), s2 = d(t2), c2 = d(r2);
-      e2.stack.push(s2 * c2);
+      const r2 = e2.stack.pop(), t2 = e2.stack.pop(), s2 = m(t2), o2 = m(r2);
+      e2.stack.push(s2 * o2);
     }
   },
-  [s$2.DIV]: {
+  [i$1.DIV]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, r2) => {
-      const t2 = e2.stack.pop(), s2 = e2.stack.pop(), c2 = d(s2), n2 = d(t2);
+      const t2 = e2.stack.pop(), s2 = e2.stack.pop(), o2 = m(s2), n2 = m(t2);
       if (n2 === 0)
         return {
           type: "DivisionByZero",
@@ -700,76 +729,76 @@ const C = {
           pc: e2.pc,
           opcode: r2.op
         };
-      e2.stack.push(c2 / n2);
+      e2.stack.push(o2 / n2);
     }
   },
-  [s$2.MOD]: {
+  [i$1.MOD]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2) => {
-      const r2 = e2.stack.pop(), t2 = e2.stack.pop(), s2 = d(t2), c2 = d(r2);
-      e2.stack.push(s2 % c2);
+      const r2 = e2.stack.pop(), t2 = e2.stack.pop(), s2 = m(t2), o2 = m(r2);
+      e2.stack.push(s2 % o2);
     }
   },
-  [s$2.UNARY_MINUS]: {
+  [i$1.UNARY_MINUS]: {
     stackIn: 1,
     stackOut: 1,
     execute: (e2) => {
-      const r2 = e2.stack.pop(), t2 = d(r2);
+      const r2 = e2.stack.pop(), t2 = m(r2);
       e2.stack.push(-t2);
     }
   },
-  [s$2.UNARY_PLUS]: {
+  [i$1.UNARY_PLUS]: {
     stackIn: 1,
     stackOut: 1,
     execute: (e2) => {
-      const r2 = e2.stack.pop(), t2 = d(r2);
+      const r2 = e2.stack.pop(), t2 = m(r2);
       e2.stack.push(t2);
     }
   }
-}, b = {
-  [s$2.PUSH]: {
+}, V = {
+  [i$1.PUSH]: {
     stackIn: 0,
     stackOut: 1,
     execute: (e2, r2) => {
       e2.stack.push(r2.arg);
     }
   },
-  [s$2.PUSH_UNDEFINED]: {
+  [i$1.PUSH_UNDEFINED]: {
     stackIn: 0,
     stackOut: 1,
     execute: (e2) => {
       e2.stack.push(s$1());
     }
   },
-  [s$2.POP]: {
+  [i$1.POP]: {
     stackIn: 1,
     stackOut: 0,
     execute: (e2) => {
       e2.stack.pop();
     }
   }
-}, U = {
-  [s$2.PRINT]: {
+}, M = {
+  [i$1.PRINT]: {
     stackIn: 1,
     stackOut: 0,
     execute: (e2) => {
       const r2 = e2.stack.pop();
-      r2 !== void 0 && e2.output.push(c$1(r2));
+      r2 !== void 0 && e2.output.push(y(r2));
     }
   },
-  [s$2.CC]: {
+  [i$1.CC]: {
     stackIn: 1,
     stackOut: 0,
     controlsPC: true,
     // CC pauses execution
     execute: (e2, r2) => {
       const t2 = e2.stack.pop();
-      e2.ccPrompt = c$1(t2), e2.status = "waiting_cc";
+      e2.ccPrompt = y(t2), e2.status = "waiting_cc";
     }
   }
-}, G = {
-  [s$2.HALT]: {
+}, j = {
+  [i$1.HALT]: {
     stackIn: 0,
     stackOut: 0,
     controlsPC: true,
@@ -777,7 +806,7 @@ const C = {
       e2.status = "complete";
     }
   },
-  [s$2.JUMP]: {
+  [i$1.JUMP]: {
     stackIn: 0,
     stackOut: 0,
     controlsPC: true,
@@ -800,7 +829,7 @@ const C = {
       e2.pc = t2;
     }
   },
-  [s$2.JUMP_IF_FALSE]: {
+  [i$1.JUMP_IF_FALSE]: {
     stackIn: 1,
     stackOut: 0,
     controlsPC: true,
@@ -821,11 +850,11 @@ const C = {
           pc: e2.pc,
           opcode: r2.op
         };
-      y(t2) ? e2.pc++ : e2.pc = s2;
+      b$1(t2) ? e2.pc++ : e2.pc = s2;
     }
   }
-}, L = {
-  [s$2.LOAD]: {
+}, F = {
+  [i$1.LOAD]: {
     stackIn: 0,
     stackOut: 1,
     execute: (e2, r2) => {
@@ -833,7 +862,7 @@ const C = {
       e2.variables.has(t2) ? e2.stack.push(e2.variables.get(t2)) : e2.stack.push(s$1());
     }
   },
-  [s$2.STORE]: {
+  [i$1.STORE]: {
     stackIn: 1,
     stackOut: 0,
     execute: (e2, r2) => {
@@ -841,41 +870,41 @@ const C = {
       e2.variables.set(r2.arg, t2);
     }
   }
-}, M = {
-  [s$2.ITER_START]: {
+}, D = {
+  [i$1.ITER_START]: {
     stackIn: 1,
     stackOut: 0,
-    execute: (e$1, r2) => {
-      const t2 = e$1.stack.pop();
+    execute: (e2, r2) => {
+      const t2 = e2.stack.pop();
       if (t2 == null)
         return {
           type: "TypeError",
           message: "TypeError: Cannot iterate over null or undefined",
-          pc: e$1.pc,
+          pc: e2.pc,
           opcode: r2.op
         };
-      if (!e(t2))
+      if (!f(t2))
         return {
           type: "TypeError",
           message: "TypeError: Cannot iterate over non-array value",
-          pc: e$1.pc,
+          pc: e2.pc,
           opcode: r2.op
         };
-      if (e$1.iterators.length >= 10)
+      if (e2.iterators.length >= 10)
         return {
           type: "RuntimeError",
           message: "RuntimeError: Maximum iterator depth exceeded",
-          pc: e$1.pc,
+          pc: e2.pc,
           opcode: r2.op
         };
-      e$1.iterators.push({
+      e2.iterators.push({
         array: t2,
         index: 0,
         length: t2.elements.length
       });
     }
   },
-  [s$2.ITER_NEXT]: {
+  [i$1.ITER_NEXT]: {
     stackIn: 0,
     stackOut: 2,
     // Pushes element and hasMore flag
@@ -891,7 +920,7 @@ const C = {
       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));
     }
   },
-  [s$2.ITER_END]: {
+  [i$1.ITER_END]: {
     stackIn: 0,
     stackOut: 0,
     execute: (e2, r2) => {
@@ -906,207 +935,255 @@ const C = {
     }
   }
 };
-function m(e2, r2, t2) {
-  const s2 = e2.stack.pop(), c2 = e2.stack.pop(), n2 = t2(c2, s2);
+function g2(e2, r2, t2) {
+  const s2 = e2.stack.pop(), o2 = e2.stack.pop(), n2 = t2(o2, s2);
   e2.stack.push(n2);
 }
-const V = {
-  [s$2.EQ]: {
+const q = {
+  [i$1.EQ]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e2, r2) => m(e2, r2, (t2, s2) => {
-      if (f(t2) && o(s2) || o(t2) && f(s2))
+    execute: (e$1, r2) => g2(e$1, r2, (t2, s2) => {
+      if (e(t2) && o(s2) || o(t2) && e(s2))
         return true;
       if (o(t2) && o(s2))
         return true;
       {
-        const c2 = d(t2), n2 = d(s2);
-        return !isNaN(c2) && !isNaN(n2) ? c2 === n2 : c$1(t2) === c$1(s2);
+        const o2 = m(t2), n2 = m(s2);
+        return !isNaN(o2) && !isNaN(n2) ? o2 === n2 : y(t2) === y(s2);
       }
     })
   },
-  [s$2.NEQ]: {
+  [i$1.NEQ]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e2, r2) => m(e2, r2, (t2, s2) => {
-      if (f(t2) && o(s2) || o(t2) && f(s2))
+    execute: (e$1, r2) => g2(e$1, r2, (t2, s2) => {
+      if (e(t2) && o(s2) || o(t2) && e(s2))
         return false;
       if (o(t2) && o(s2))
         return false;
       {
-        const c2 = d(t2), n2 = d(s2);
-        return !isNaN(c2) && !isNaN(n2) ? c2 !== n2 : c$1(t2) !== c$1(s2);
+        const o2 = m(t2), n2 = m(s2);
+        return !isNaN(o2) && !isNaN(n2) ? o2 !== n2 : y(t2) !== y(s2);
       }
     })
   },
-  [s$2.LT]: {
+  [i$1.LT]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e2, r2) => m(e2, r2, (t2, s2) => {
-      const c2 = d(t2), n2 = d(s2);
-      return c2 < n2;
+    execute: (e2, r2) => g2(e2, r2, (t2, s2) => {
+      const o2 = m(t2), n2 = m(s2);
+      return o2 < n2;
     })
   },
-  [s$2.GT]: {
+  [i$1.GT]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e2, r2) => m(e2, r2, (t2, s2) => {
-      const c2 = d(t2), n2 = d(s2);
-      return c2 > n2;
+    execute: (e2, r2) => g2(e2, r2, (t2, s2) => {
+      const o2 = m(t2), n2 = m(s2);
+      return o2 > n2;
     })
   },
-  [s$2.LTE]: {
+  [i$1.LTE]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e2, r2) => m(e2, r2, (t2, s2) => {
-      const c2 = d(t2), n2 = d(s2);
-      return c2 <= n2;
+    execute: (e2, r2) => g2(e2, r2, (t2, s2) => {
+      const o2 = m(t2), n2 = m(s2);
+      return o2 <= n2;
     })
   },
-  [s$2.GTE]: {
+  [i$1.GTE]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e2, r2) => m(e2, r2, (t2, s2) => {
-      const c2 = d(t2), n2 = d(s2);
-      return c2 >= n2;
+    execute: (e2, r2) => g2(e2, r2, (t2, s2) => {
+      const o2 = m(t2), n2 = m(s2);
+      return o2 >= n2;
     })
   },
-  [s$2.EQ_STRICT]: {
+  [i$1.EQ_STRICT]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e2, r2) => m(e2, r2, (t2, s2) => t2 === s2)
+    execute: (e2, r2) => g2(e2, r2, (t2, s2) => t2 === s2)
   },
-  [s$2.NEQ_STRICT]: {
+  [i$1.NEQ_STRICT]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e2, r2) => m(e2, r2, (t2, s2) => t2 !== s2)
+    execute: (e2, r2) => g2(e2, r2, (t2, s2) => t2 !== s2)
   }
-}, F = {
-  [s$2.AND]: {
+}, H = {
+  [i$1.AND]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, r2) => {
-      const t2 = e2.stack.pop(), s2 = e2.stack.pop(), c2 = y(s2) ? t2 : s2;
-      e2.stack.push(c2);
+      const t2 = e2.stack.pop(), s2 = e2.stack.pop(), o2 = b$1(s2) ? t2 : s2;
+      e2.stack.push(o2);
     }
   },
-  [s$2.OR]: {
+  [i$1.OR]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, r2) => {
-      const t2 = e2.stack.pop(), s2 = e2.stack.pop(), c2 = y(s2) ? s2 : t2;
-      e2.stack.push(c2);
+      const t2 = e2.stack.pop(), s2 = e2.stack.pop(), o2 = b$1(s2) ? s2 : t2;
+      e2.stack.push(o2);
     }
   },
-  [s$2.NOT]: {
+  [i$1.NOT]: {
     stackIn: 1,
     stackOut: 1,
     execute: (e2, r2) => {
-      const t2 = e2.stack.pop(), s2 = !y(t2);
+      const t2 = e2.stack.pop(), s2 = !b$1(t2);
       e2.stack.push(s2);
     }
   }
-}, D = {
-  [s$2.ARRAY_NEW]: {
+}, Y = {
+  [i$1.ARRAY_NEW]: {
     stackIn: 0,
     stackOut: 1,
     execute: (e2, r2) => {
-      e2.stack.push(p$1());
+      e2.stack.push(d());
     }
   },
-  [s$2.ARRAY_PUSH]: {
+  [i$1.ARRAY_PUSH]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e$1, r2) => {
-      const t2 = e$1.stack.pop(), s2 = e$1.stack.pop();
-      if (!e(s2))
+    execute: (e2, r2) => {
+      const t2 = e2.stack.pop(), s2 = e2.stack.pop();
+      if (!f(s2))
         return {
           type: "RuntimeError",
           message: "ARRAY_PUSH requires an array",
-          pc: e$1.pc,
+          pc: e2.pc,
           opcode: r2.op
         };
-      s2.elements.push(t2), e$1.stack.push(s2);
+      s2.elements.push(t2), e2.stack.push(s2);
     }
   },
-  [s$2.ARRAY_GET]: {
+  [i$1.ARRAY_GET]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e$1, r2) => {
-      const t$1 = e$1.stack.pop(), s2 = e$1.stack.pop();
-      if (!e(s2))
-        return {
-          type: "RuntimeError",
-          message: "ARRAY_GET requires an array",
-          pc: e$1.pc,
-          opcode: r2.op
-        };
-      if (!t(t$1))
-        return {
-          type: "RuntimeError",
-          message: "ARRAY_GET requires numeric index",
-          pc: e$1.pc,
-          opcode: r2.op
-        };
-      const c2 = s2.elements[t$1] ?? null;
-      e$1.stack.push(c2);
+    execute: (e2, r2) => {
+      const t$1 = e2.stack.pop(), s2 = e2.stack.pop();
+      if (f(s2)) {
+        if (!t(t$1))
+          return {
+            type: "RuntimeError",
+            message: "ARRAY_GET requires numeric index for arrays",
+            pc: e2.pc,
+            opcode: r2.op
+          };
+        const o2 = s2.elements[t$1] ?? null;
+        e2.stack.push(o2);
+        return;
+      }
+      if (c$1(s2)) {
+        if (!n(t$1))
+          return {
+            type: "RuntimeError",
+            message: "ARRAY_GET requires string key for objects",
+            pc: e2.pc,
+            opcode: r2.op
+          };
+        const o2 = s2.properties[t$1] ?? null;
+        e2.stack.push(o2);
+        return;
+      }
+      return {
+        type: "RuntimeError",
+        message: "ARRAY_GET requires an array or object",
+        pc: e2.pc,
+        opcode: r2.op
+      };
     }
   },
-  [s$2.ARRAY_SET]: {
+  [i$1.ARRAY_SET]: {
     stackIn: 3,
-    stackOut: 0,
-    execute: (e$1, r2) => {
-      const t$1 = e$1.stack.pop(), s2 = e$1.stack.pop(), c2 = e$1.stack.pop();
-      if (!e(c2))
-        return {
-          type: "RuntimeError",
-          message: "ARRAY_SET requires an array",
-          pc: e$1.pc,
-          opcode: r2.op
-        };
-      if (!t(s2))
-        return {
-          type: "RuntimeError",
-          message: "ARRAY_SET requires numeric index",
-          pc: e$1.pc,
-          opcode: r2.op
-        };
-      const n2 = Math.floor(s2);
-      if (n2 < 0)
-        return {
-          type: "RuntimeError",
-          message: "ARRAY_SET: Negative index not allowed",
-          pc: e$1.pc,
-          opcode: r2.op
-        };
-      c2.elements[n2] = t$1;
+    stackOut: 1,
+    execute: (e2, r2) => {
+      const t$1 = e2.stack.pop(), s2 = e2.stack.pop(), o2 = e2.stack.pop();
+      if (f(o2)) {
+        if (!t(s2))
+          return {
+            type: "RuntimeError",
+            message: "ARRAY_SET requires numeric index for arrays",
+            pc: e2.pc,
+            opcode: r2.op
+          };
+        const n2 = Math.floor(s2);
+        if (n2 < 0)
+          return {
+            type: "RuntimeError",
+            message: "ARRAY_SET: Negative index not allowed",
+            pc: e2.pc,
+            opcode: r2.op
+          };
+        o2.elements[n2] = t$1, e2.stack.push(o2);
+        return;
+      }
+      if (c$1(o2)) {
+        if (!n(s2))
+          return {
+            type: "RuntimeError",
+            message: "ARRAY_SET requires string key for objects",
+            pc: e2.pc,
+            opcode: r2.op
+          };
+        o2.properties[s2] = t$1, e2.stack.push(o2);
+        return;
+      }
+      return {
+        type: "RuntimeError",
+        message: "ARRAY_SET requires an array or object",
+        pc: e2.pc,
+        opcode: r2.op
+      };
     }
   },
-  [s$2.ARRAY_LEN]: {
+  [i$1.ARRAY_LEN]: {
     stackIn: 1,
     stackOut: 1,
-    execute: (e$1, r2) => {
-      const t2 = e$1.stack.pop();
-      if (!e(t2))
+    execute: (e2, r2) => {
+      const t2 = e2.stack.pop();
+      if (!f(t2))
         return {
           type: "RuntimeError",
           message: "ARRAY_LEN requires an array",
-          pc: e$1.pc,
+          pc: e2.pc,
           opcode: r2.op
         };
-      e$1.stack.push(t2.elements.length);
+      e2.stack.push(t2.elements.length);
     }
   }
-}, q = {
-  [s$2.CONCAT]: {
+};
+function x(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;
+    }
+    if (e2 && typeof e2 == "object" && e2.type === "object" && e2.properties)
+      return e2;
+    if (typeof e2 == "object") {
+      const r2 = j$1();
+      for (const [t2, s2] of Object.entries(e2))
+        r2.properties[t2] = x(s2);
+      return r2;
+    }
+    return null;
+  }
+}
+const $ = {
+  [i$1.CONCAT]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, r2) => {
       const t2 = e2.stack.pop(), s2 = e2.stack.pop();
-      e2.stack.push(c$1(s2) + c$1(t2));
+      e2.stack.push(y(s2) + y(t2));
     }
   },
-  [s$2.STRING_LEN]: {
+  [i$1.STRING_LEN]: {
     stackIn: 1,
     stackOut: 1,
     execute: (e2, r2) => {
@@ -1121,25 +1198,25 @@ const V = {
       e2.stack.push(t2.length);
     }
   },
-  [s$2.LENGTH]: {
+  [i$1.LENGTH]: {
     stackIn: 1,
     stackOut: 1,
-    execute: (e$1, r2) => {
-      const t2 = e$1.stack.pop();
+    execute: (e2, r2) => {
+      const t2 = e2.stack.pop();
       if (n(t2))
-        e$1.stack.push(t2.length);
-      else if (e(t2))
-        e$1.stack.push(t2.elements.length);
+        e2.stack.push(t2.length);
+      else if (f(t2))
+        e2.stack.push(t2.elements.length);
       else
         return {
           type: "RuntimeError",
           message: "LENGTH requires a string or array",
-          pc: e$1.pc,
+          pc: e2.pc,
           opcode: r2.op
         };
     }
   },
-  [s$2.JSON_PARSE]: {
+  [i$1.JSON_PARSE]: {
     stackIn: 1,
     stackOut: 1,
     execute: (e2, r2) => {
@@ -1153,22 +1230,22 @@ const V = {
         };
       try {
         const s2 = JSON.parse(t2);
-        Array.isArray(s2) ? e2.stack.push(p$1(s2)) : e2.stack.push(p$1());
+        e2.stack.push(x(s2));
       } catch {
-        e2.stack.push(p$1());
+        e2.stack.push(null);
       }
     }
   },
-  [s$2.TYPEOF]: {
+  [i$1.TYPEOF]: {
     stackIn: 1,
     stackOut: 1,
     execute: (e2, r2) => {
       const t2 = e2.stack.pop();
-      e2.stack.push(m$1(t2));
+      e2.stack.push(p$1(t2));
     }
   }
-}, H = {
-  [s$2.INC]: {
+}, B = {
+  [i$1.INC]: {
     stackIn: 1,
     stackOut: 1,
     execute: (e2, r2) => {
@@ -1180,13 +1257,13 @@ const V = {
           pc: e2.pc,
           opcode: r2.op
         };
-      const s2 = e2.variables.get(t2) ?? 0, c2 = d(s2) + 1;
-      e2.variables.set(t2, c2);
+      const s2 = e2.variables.get(t2) ?? 0, o2 = m(s2) + 1;
+      e2.variables.set(t2, o2);
       const n2 = r2.arg === true;
-      e2.stack.push(n2 ? d(s2) : c2);
+      e2.stack.push(n2 ? m(s2) : o2);
     }
   },
-  [s$2.DEC]: {
+  [i$1.DEC]: {
     stackIn: 1,
     stackOut: 1,
     execute: (e2, r2) => {
@@ -1198,14 +1275,14 @@ const V = {
           pc: e2.pc,
           opcode: r2.op
         };
-      const s2 = e2.variables.get(t2) ?? 0, c2 = d(s2) - 1;
-      e2.variables.set(t2, c2);
+      const s2 = e2.variables.get(t2) ?? 0, o2 = m(s2) - 1;
+      e2.variables.set(t2, o2);
       const n2 = r2.arg === true;
-      e2.stack.push(n2 ? d(s2) : c2);
+      e2.stack.push(n2 ? m(s2) : o2);
     }
   }
-}, Y = {
-  [s$2.RETURN]: {
+}, J = {
+  [i$1.RETURN]: {
     stackIn: 0,
     stackOut: 0,
     controlsPC: true,
@@ -1214,7 +1291,7 @@ const V = {
       e2.returnValue = t2, e2.status = "complete";
     }
   },
-  [s$2.BREAK]: {
+  [i$1.BREAK]: {
     stackIn: 0,
     stackOut: 0,
     controlsPC: true,
@@ -1237,7 +1314,7 @@ const V = {
       e2.pc = t2;
     }
   },
-  [s$2.CONTINUE]: {
+  [i$1.CONTINUE]: {
     stackIn: 0,
     stackOut: 0,
     controlsPC: true,
@@ -1260,37 +1337,37 @@ const V = {
       e2.pc = t2;
     }
   },
-  [s$2.FS_LIST_FILES]: {
+  [i$1.FS_LIST_FILES]: {
     stackIn: 1,
     // Minimum 1 argument (path), optionally 2 (path + options)
     stackOut: 0,
     controlsPC: true,
-    execute: (e$1, r2) => {
-      if (e$1.stack.length < 1)
+    execute: (e2, r2) => {
+      if (e2.stack.length < 1)
         return {
           type: "StackUnderflow",
           message: "FS_LIST_FILES: Stack underflow",
-          pc: e$1.pc,
+          pc: e2.pc,
           opcode: r2.op
         };
       let t2, s2 = {};
-      const c2 = e$1.stack[e$1.stack.length - 1];
-      if (e$1.stack.length >= 2 && typeof c2 == "object" && c2 !== null && !e(c2) && (s2 = e$1.stack.pop()), t2 = e$1.stack.pop(), !n(t2))
+      const o2 = e2.stack[e2.stack.length - 1];
+      if (e2.stack.length >= 2 && typeof o2 == "object" && o2 !== null && !f(o2) && (s2 = e2.stack.pop()), t2 = e2.stack.pop(), !n(t2))
         return {
           type: "RuntimeError",
           message: "FS_LIST_FILES requires a string path",
-          pc: e$1.pc,
+          pc: e2.pc,
           opcode: r2.op
         };
-      e$1.fsOperation = {
+      e2.fsOperation = {
         type: "listFiles",
         path: t2,
         options: s2
-      }, e$1.status = "waiting_fs";
+      }, e2.status = "waiting_fs";
     }
   },
   // String method handlers
-  [s$2.STRING_SUBSTRING]: {
+  [i$1.STRING_SUBSTRING]: {
     stackIn: 2,
     // Minimum 2 (string, start), optionally 3 (string, start, end)
     stackOut: 1,
@@ -1303,29 +1380,29 @@ const V = {
           opcode: r2.op
         };
       const t2 = e2.stack.length;
-      let s2, c2, n$12;
+      let s2, o2, n$12;
       const a2 = e2.stack[t2 - 1], i2 = e2.stack[t2 - 2];
-      if (t2 >= 3 && typeof a2 == "number" && typeof i2 == "number" ? (n$12 = e2.stack.pop(), c2 = e2.stack.pop(), s2 = e2.stack.pop()) : (c2 = e2.stack.pop(), s2 = e2.stack.pop(), n$12 = void 0), !n(s2))
+      if (t2 >= 3 && typeof a2 == "number" && typeof i2 == "number" ? (n$12 = e2.stack.pop(), o2 = e2.stack.pop(), s2 = e2.stack.pop()) : (o2 = e2.stack.pop(), s2 = e2.stack.pop(), n$12 = void 0), !n(s2))
         return {
           type: "RuntimeError",
           message: "STRING_SUBSTRING requires a string",
           pc: e2.pc,
           opcode: r2.op
         };
-      if (typeof c2 != "number")
+      if (typeof o2 != "number")
         return {
           type: "RuntimeError",
           message: "STRING_SUBSTRING requires numeric start index",
           pc: e2.pc,
           opcode: r2.op
         };
-      const p2 = s2.length;
-      c2 < 0 && (c2 = Math.max(0, p2 + c2)), n$12 !== void 0 && n$12 < 0 && (n$12 = Math.max(0, p2 + n$12));
-      const I2 = n$12 !== void 0 ? s2.substring(c2, n$12) : s2.substring(c2);
+      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);
     }
   },
-  [s$2.STRING_INDEXOF]: {
+  [i$1.STRING_INDEXOF]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, r2) => {
@@ -1340,7 +1417,7 @@ const V = {
       e2.stack.push(s2.indexOf(t2));
     }
   },
-  [s$2.STRING_SPLIT]: {
+  [i$1.STRING_SPLIT]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, r2) => {
@@ -1352,11 +1429,11 @@ const V = {
           pc: e2.pc,
           opcode: r2.op
         };
-      let c2;
-      t2 === "" ? c2 = s2.split("") : c2 = s2.split(t2), e2.stack.push(p$1(c2));
+      let o2;
+      t2 === "" ? o2 = s2.split("") : o2 = s2.split(t2), e2.stack.push(d(o2));
     }
   },
-  [s$2.STRING_SLICE]: {
+  [i$1.STRING_SLICE]: {
     stackIn: 2,
     // Minimum 2 (string, start), optionally 3 (string, start, end)
     stackOut: 1,
@@ -1369,27 +1446,27 @@ const V = {
           opcode: r2.op
         };
       const t2 = e2.stack.length;
-      let s2, c2, n$12;
+      let s2, o2, n$12;
       const a2 = e2.stack.length >= 1 ? e2.stack[t2 - 1] : void 0, i2 = e2.stack.length >= 2 ? e2.stack[t2 - 2] : void 0;
-      if (t2 >= 3 && typeof a2 == "number" && typeof i2 == "number" ? (n$12 = e2.stack.pop(), c2 = e2.stack.pop(), s2 = e2.stack.pop()) : (c2 = e2.stack.pop(), s2 = e2.stack.pop(), n$12 = void 0), !n(s2))
+      if (t2 >= 3 && typeof a2 == "number" && typeof i2 == "number" ? (n$12 = e2.stack.pop(), o2 = e2.stack.pop(), s2 = e2.stack.pop()) : (o2 = e2.stack.pop(), s2 = e2.stack.pop(), n$12 = void 0), !n(s2))
         return {
           type: "RuntimeError",
           message: "STRING_SLICE requires a string",
           pc: e2.pc,
           opcode: r2.op
         };
-      if (typeof c2 != "number")
+      if (typeof o2 != "number")
         return {
           type: "RuntimeError",
           message: "STRING_SLICE requires numeric start index",
           pc: e2.pc,
           opcode: r2.op
         };
-      const p2 = n$12 !== void 0 ? s2.slice(c2, n$12) : s2.slice(c2);
-      e2.stack.push(p2);
+      const u2 = n$12 !== void 0 ? s2.slice(o2, n$12) : s2.slice(o2);
+      e2.stack.push(u2);
     }
   },
-  [s$2.STRING_CHARAT]: {
+  [i$1.STRING_CHARAT]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, r2) => {
@@ -1408,11 +1485,11 @@ const V = {
           pc: e2.pc,
           opcode: r2.op
         };
-      const c2 = s2.charAt(t2);
-      e2.stack.push(c2);
+      const o2 = s2.charAt(t2);
+      e2.stack.push(o2);
     }
   },
-  [s$2.STRING_TOUPPERCASE]: {
+  [i$1.STRING_TOUPPERCASE]: {
     stackIn: 1,
     stackOut: 1,
     execute: (e2, r2) => {
@@ -1427,7 +1504,7 @@ const V = {
       e2.stack.push(t2.toUpperCase());
     }
   },
-  [s$2.STRING_TOLOWERCASE]: {
+  [i$1.STRING_TOLOWERCASE]: {
     stackIn: 1,
     stackOut: 1,
     execute: (e2, r2) => {
@@ -1442,26 +1519,98 @@ const V = {
       e2.stack.push(t2.toLowerCase());
     }
   }
-}, $ = {
-  ...C,
-  ...b,
-  ...U,
-  ...G,
+};
+function _(e2) {
+  if (f(e2))
+    return e2.elements.map(_);
+  if (c$1(e2)) {
+    const r2 = {};
+    for (const [t2, s2] of Object.entries(e2.properties))
+      r2[t2] = _(s2);
+    return r2;
+  }
+  if (!o(e2))
+    return e2;
+}
+const W = {
+  [i$1.OBJECT_CREATE]: {
+    stackIn: 0,
+    stackOut: 1,
+    execute: (e2) => {
+      e2.stack.push(j$1());
+    }
+  },
+  [i$1.PROPERTY_SET]: {
+    stackIn: 3,
+    stackOut: 1,
+    execute: (e2, r2) => {
+      const t2 = e2.stack.pop(), s2 = e2.stack.pop(), o2 = e2.stack.pop();
+      if (!c$1(o2))
+        return {
+          type: "RuntimeError",
+          message: `Cannot set property '${s2}' on ${p$1(o2)}`,
+          pc: e2.pc,
+          opcode: r2.op
+        };
+      if (!n(s2))
+        return {
+          type: "RuntimeError",
+          message: "Property key must be a string",
+          pc: e2.pc,
+          opcode: r2.op
+        };
+      o2.properties[s2] = t2, e2.stack.push(o2);
+    }
+  },
+  [i$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))
+        return {
+          type: "RuntimeError",
+          message: `Cannot read property '${t2}' of ${p$1(s2)}`,
+          pc: e$1.pc,
+          opcode: r2.op
+        };
+      if (!c$1(s2)) {
+        e$1.stack.push(s$1());
+        return;
+      }
+      const o$1 = s2.properties[y(t2)];
+      e$1.stack.push(o$1 ?? s$1());
+    }
+  },
+  [i$1.JSON_STRINGIFY]: {
+    stackIn: 1,
+    stackOut: 1,
+    execute: (e2) => {
+      const r2 = e2.stack.pop(), t2 = _(r2);
+      e2.stack.push(JSON.stringify(t2));
+    }
+  }
+}, z = {
   ...L,
-  ...M,
   ...V,
+  ...M,
+  ...j,
   ...F,
   ...D,
   ...q,
   ...H,
-  ...Y
+  ...Y,
+  ...$,
+  ...B,
+  ...J,
+  ...W
 };
 class N {
   validateStack(r2, t2, s2) {
     if (s2.stack.length < r2.stackIn)
       return {
         type: "StackUnderflow",
-        message: `${s$2[t2.op]}: Stack underflow`,
+        message: `${i$1[t2.op]}: Stack underflow`,
         pc: s2.pc,
         opcode: t2.op
       };
@@ -1477,20 +1626,20 @@ class N {
       ...t2
     };
     for (; s2.status === "running" && s2.pc < r2.length; ) {
-      const c2 = r2[s2.pc], n2 = $[c2.op];
+      const o2 = r2[s2.pc], n2 = z[o2.op];
       if (n2) {
-        const a2 = this.validateStack(n2, c2, s2);
+        const a2 = this.validateStack(n2, o2, s2);
         if (a2) {
           s2.status = "error", s2.error = a2.message;
           break;
         }
-        if ((c2.op === s$2.JUMP || c2.op === s$2.JUMP_IF_FALSE || c2.op === s$2.BREAK || c2.op === s$2.CONTINUE) && c2.arg !== void 0 && c2.arg >= r2.length) {
+        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) {
           s2.status = "error";
-          const p2 = c2.op === s$2.JUMP || c2.op === s$2.JUMP_IF_FALSE ? "jump" : c2.op === s$2.BREAK ? "break" : "continue";
-          s2.error = `Invalid ${p2} target: ${c2.arg}`;
+          const u2 = o2.op === i$1.JUMP || o2.op === i$1.JUMP_IF_FALSE ? "jump" : o2.op === i$1.BREAK ? "break" : "continue";
+          s2.error = `Invalid ${u2} target: ${o2.arg}`;
           break;
         }
-        const i2 = n2.execute(s2, c2);
+        const i2 = n2.execute(s2, o2);
         if (i2) {
           s2.status = "error", s2.error = i2.message;
           break;
@@ -1498,7 +1647,7 @@ class N {
         n2.controlsPC || s2.pc++;
         continue;
       }
-      s2.status = "error", s2.error = `Unknown opcode: ${s$2[c2.op]}`;
+      s2.status = "error", s2.error = `Unknown opcode: ${i$1[o2.op]}`;
       break;
     }
     return s2;
@@ -1506,31 +1655,31 @@ class N {
   resume(r2, t2, s2) {
     if (r2.status !== "waiting_cc")
       throw new Error("Cannot resume: VM not waiting for CC");
-    const c2 = {
+    const o2 = {
       ...r2,
       stack: [...r2.stack, t2],
       status: "running",
       ccPrompt: void 0,
       pc: r2.pc + 1
     };
-    return this.execute(s2, c2);
+    return this.execute(s2, o2);
   }
   resumeWithFsResult(r2, t2, s2) {
     if (r2.status !== "waiting_fs")
       throw new Error("Cannot resume: VM not waiting for FS operation");
-    const c2 = {
+    const o2 = {
       ...r2,
       stack: [...r2.stack, t2],
       status: "running",
       fsOperation: void 0,
       pc: r2.pc + 1
     };
-    return this.execute(s2, c2);
+    return this.execute(s2, o2);
   }
 }
-class x {
+class A2 {
   constructor() {
-    E(this, "sandboxPaths", []);
+    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)]);
   }
@@ -1541,12 +1690,12 @@ class x {
     );
   }
   listFiles(r2, t2 = {}) {
-    const s2 = p$1();
+    const s2 = d();
     if (!this.isPathAllowed(r2))
       return s2;
     try {
-      const c2 = c__namespace.resolve(r2);
-      this.listFilesRecursive(c2, c2, s2.elements, t2);
+      const o2 = c__namespace.resolve(r2);
+      this.listFilesRecursive(o2, o2, s2.elements, t2);
     } catch {
     }
     return s2;
@@ -1560,24 +1709,24 @@ class x {
       return true;
     }
   }
-  listFilesRecursive(r2, t2, s2, c2, n2 = 0) {
+  listFilesRecursive(r2, t2, s2, o2, n2 = 0) {
     try {
-      const a2 = P__namespace.readdirSync(t2, { withFileTypes: true });
+      const a2 = G__namespace.readdirSync(t2, { withFileTypes: true });
       for (const i2 of a2) {
-        const p2 = c__namespace.join(t2, i2.name), I2 = c__namespace.relative(r2, p2);
-        i2.isSymbolicLink() || c2.filter && !this.matchesPattern(I2, c2.filter) || (s2.push(p2), i2.isDirectory() && c2.recursive && this.listFilesRecursive(r2, p2, s2, c2, n2 + 1));
+        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));
       }
     } catch {
     }
   }
 }
-new x();
-class X {
+new A2();
+class te {
   constructor(r2, t2) {
-    E(this, "vms", /* @__PURE__ */ new Map());
-    E(this, "storage");
-    E(this, "fileSystem");
-    r2 ? this.storage = r2 : this.storage = g.create(), this.fileSystem = t2 || new x();
+    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();
   }
   /**
    * Initialize the VMManager (connect to database)
@@ -1595,10 +1744,10 @@ class X {
    * Load and compile a program from source code
    */
   async loadProgram(r2, t2) {
-    const s2 = j(t2);
+    const s2 = W$1(t2);
     if (!s2.success)
       throw new Error(`Compilation failed: ${s2.errors.join(", ")}`);
-    const c2 = {
+    const o2 = {
       id: r2,
       name: r2,
       source: t2,
@@ -1606,7 +1755,7 @@ class X {
       // VM decides internal format
       created: /* @__PURE__ */ new Date()
     };
-    await this.storage.saveProgram(c2);
+    await this.storage.saveProgram(o2);
   }
   /**
    * Start execution of a loaded program
@@ -1614,7 +1763,7 @@ class X {
   async startExecution(r2, t2) {
     if (!await this.storage.getProgram(r2))
       throw new Error(`Program not found: ${r2}`);
-    const c2 = {
+    const o2 = {
       id: t2,
       programId: r2,
       state: "READY",
@@ -1623,7 +1772,7 @@ class X {
       variables: {},
       created: /* @__PURE__ */ new Date()
     };
-    await this.storage.saveExecution(c2);
+    await this.storage.saveExecution(o2);
     const n2 = new N();
     this.vms.set(t2, n2);
   }
@@ -1639,14 +1788,14 @@ class X {
       const s2 = await this.storage.getProgram(t2.programId);
       if (!s2)
         throw new Error(`Program not found: ${t2.programId}`);
-      let c2 = this.vms.get(r2);
-      c2 || (c2 = new N(), this.vms.set(r2, c2));
+      let o2 = this.vms.get(r2);
+      o2 || (o2 = new N(), this.vms.set(r2, o2));
       const n2 = {
         pc: 0,
         stack: [],
         variables: /* @__PURE__ */ new Map(),
         output: []
-      }, a2 = c2.execute(s2.bytecode, n2);
+      }, 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), {
           type: "completed",
@@ -1660,17 +1809,17 @@ class X {
         };
       if (a2.status === "waiting_fs") {
         if (a2.fsOperation) {
-          const i2 = this.fileSystem.listFiles(a2.fsOperation.path, a2.fsOperation.options), p2 = c2.resumeWithFsResult(a2, i2, s2.bytecode);
-          return p2.output.length > 0 && await this.storage.appendOutput(r2, p2.output), t2.pc = p2.pc, t2.stack = p2.stack, t2.variables = Object.fromEntries(p2.variables), t2.iterators = p2.iterators, p2.status === "complete" ? (t2.state = "COMPLETED", p2.returnValue !== void 0 && (t2.returnValue = p2.returnValue), await this.storage.saveExecution(t2), this.vms.delete(r2), {
+          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), {
             type: "completed",
             message: "Execution completed",
-            result: p2.returnValue
-          }) : p2.status === "error" ? (t2.state = "ERROR", t2.error = p2.error, await this.storage.saveExecution(t2), this.vms.delete(r2), {
+            result: u2.returnValue
+          }) : u2.status === "error" ? (t2.state = "ERROR", t2.error = u2.error, await this.storage.saveExecution(t2), this.vms.delete(r2), {
             type: "error",
-            error: p2.error
-          }) : p2.status === "waiting_cc" ? (t2.state = "AWAITING_COGNITIVE_RESULT", t2.ccPrompt = p2.ccPrompt, await this.storage.saveExecution(t2), {
+            error: u2.error
+          }) : u2.status === "waiting_cc" ? (t2.state = "AWAITING_COGNITIVE_RESULT", t2.ccPrompt = u2.ccPrompt, await this.storage.saveExecution(t2), {
             type: "waiting",
-            message: p2.ccPrompt || "Waiting for input"
+            message: u2.ccPrompt || "Waiting for input"
           }) : (t2.state = "RUNNING", await this.storage.saveExecution(t2), this.getNext(r2));
         }
       } else if (a2.status === "error")
@@ -1703,8 +1852,8 @@ class X {
     const s2 = await this.storage.getExecution(r2);
     if (!s2)
       throw new Error(`Execution not found: ${r2}`);
-    const c2 = await this.storage.getProgram(s2.programId);
-    if (!c2)
+    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));
@@ -1717,7 +1866,7 @@ class X {
       // Start with empty output for resumed execution
       ccPrompt: void 0,
       iterators: s2.iterators || []
-    }, i2 = n2.resume(a2, t2, c2.bytecode);
+    }, 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);
   }
   /**
@@ -1751,7 +1900,7 @@ class w {
     s(this, "transport", null);
     s(this, "vmManager");
     s(this, "version");
-    this.version = r2, this.vmManager = new X(), this.server = new mcp_js.McpServer({
+    this.version = r2, this.vmManager = new te(), this.server = new mcp_js.McpServer({
       name: "cvm-server",
       version: this.version
     }), this.setupTools();
@@ -2005,7 +2154,7 @@ async function main() {
     ];
     for (const packageJsonPath of possiblePaths) {
       try {
-        const packageJson = JSON.parse(P$1.readFileSync(packageJsonPath, "utf-8"));
+        const packageJson = JSON.parse(G$1.readFileSync(packageJsonPath, "utf-8"));
         if (packageJson.name === "cvm-server" && packageJson.version) {
           version = packageJson.version;
           break;