npm - cvm-server - Versions diffs - 0.7.0 → 0.9.0 - Mend

cvm-server 0.7.0 → 0.9.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2) hide show

package/main.cjs +1493 -1102
package/package.json +1 -1

package/main.cjs CHANGED Viewed

@@ -2,8 +2,8 @@
 const mcp_js = require("@modelcontextprotocol/sdk/server/mcp.js");
 const stdio_js = require("@modelcontextprotocol/sdk/server/stdio.js");
 const zod = require("zod");
-const s$2 = require("typescript");
-const M = require("fs");
+const n$1 = require("typescript");
+const G$1 = require("fs");
 const c$2 = require("path");
 const mongodb = require("mongodb");
 const promises = require("fs/promises");
@@ -26,51 +26,51 @@ function _interopNamespaceDefault(e2) {
   n2.default = e2;
   return Object.freeze(n2);
 }
-const s__namespace = /* @__PURE__ */ _interopNamespaceDefault(s$2);
-const M__namespace = /* @__PURE__ */ _interopNamespaceDefault(M);
+const n__namespace = /* @__PURE__ */ _interopNamespaceDefault(n$1);
+const G__namespace = /* @__PURE__ */ _interopNamespaceDefault(G$1);
 const c__namespace = /* @__PURE__ */ _interopNamespaceDefault(c$2);
 const dotenv__namespace = /* @__PURE__ */ _interopNamespaceDefault(dotenv);
-var R = Object.defineProperty;
-var h$1 = (n2, l2, e2) => l2 in n2 ? R(n2, l2, { enumerable: true, configurable: true, writable: true, value: e2 }) : n2[l2] = e2;
-var u$1 = (n2, l2, e2) => h$1(n2, typeof l2 != "symbol" ? l2 + "" : l2, e2);
-var r$1 = /* @__PURE__ */ ((n2) => (n2.PUSH = "PUSH", n2.PUSH_UNDEFINED = "PUSH_UNDEFINED", n2.POP = "POP", n2.LOAD = "LOAD", n2.STORE = "STORE", n2.CONCAT = "CONCAT", n2.ARRAY_NEW = "ARRAY_NEW", n2.ARRAY_PUSH = "ARRAY_PUSH", n2.ARRAY_GET = "ARRAY_GET", n2.ARRAY_SET = "ARRAY_SET", n2.ARRAY_LEN = "ARRAY_LEN", n2.STRING_LEN = "STRING_LEN", n2.STRING_SUBSTRING = "STRING_SUBSTRING", n2.STRING_INDEXOF = "STRING_INDEXOF", n2.STRING_SPLIT = "STRING_SPLIT", n2.STRING_SLICE = "STRING_SLICE", n2.STRING_CHARAT = "STRING_CHARAT", n2.STRING_TOUPPERCASE = "STRING_TOUPPERCASE", n2.STRING_TOLOWERCASE = "STRING_TOLOWERCASE", n2.LENGTH = "LENGTH", n2.JSON_PARSE = "JSON_PARSE", n2.TYPEOF = "TYPEOF", n2.ADD = "ADD", n2.SUB = "SUB", n2.MUL = "MUL", n2.DIV = "DIV", n2.MOD = "MOD", n2.UNARY_MINUS = "UNARY_MINUS", n2.UNARY_PLUS = "UNARY_PLUS", n2.INC = "INC", n2.DEC = "DEC", n2.EQ = "EQ", n2.NEQ = "NEQ", n2.LT = "LT", n2.GT = "GT", n2.LTE = "LTE", n2.GTE = "GTE", n2.EQ_STRICT = "EQ_STRICT", n2.NEQ_STRICT = "NEQ_STRICT", n2.JUMP = "JUMP", n2.JUMP_IF = "JUMP_IF", n2.JUMP_IF_FALSE = "JUMP_IF_FALSE", n2.JUMP_IF_TRUE = "JUMP_IF_TRUE", n2.CALL = "CALL", n2.RETURN = "RETURN", n2.AND = "AND", n2.OR = "OR", n2.NOT = "NOT", n2.BREAK = "BREAK", n2.CONTINUE = "CONTINUE", n2.ITER_START = "ITER_START", n2.ITER_NEXT = "ITER_NEXT", n2.ITER_END = "ITER_END", n2.FS_LIST_FILES = "FS_LIST_FILES", n2.CC = "CC", n2.PRINT = "PRINT", n2.HALT = "HALT", n2))(r$1 || {});
-function I(n2) {
-  const l2 = [], e2 = [];
-  let o2 = false, T = false;
-  const a2 = s__namespace.createSourceFile(
+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 m2 = n__namespace.createSourceFile(
     "program.ts",
-    n2,
-    s__namespace.ScriptTarget.Latest,
+    e2,
+    n__namespace.ScriptTarget.Latest,
     true
   );
-  function t2(i2) {
-    if (s__namespace.isFunctionDeclaration(i2) && i2.name && i2.name.text === "main" && (o2 = true, i2.parameters.length > 0 && l2.push("main() must not have parameters")), s__namespace.isExpressionStatement(i2) && i2.parent === a2) {
-      const c2 = i2.expression;
-      s__namespace.isCallExpression(c2) && s__namespace.isIdentifier(c2.expression) && c2.expression.text === "main" && (T = 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);
     }
-    if (s__namespace.isCallExpression(i2) && s__namespace.isIdentifier(i2.expression)) {
-      const c2 = i2.expression.text;
-      ["setTimeout", "fetch", "require", "import"].includes(c2) && l2.push(`Unsupported function: ${c2}`);
+    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}`);
     }
-    s__namespace.forEachChild(i2, t2);
+    n__namespace.forEachChild(o2, l2);
   }
-  return t2(a2), o2 || l2.push("Program must have a main() function"), o2 && !T && l2.push("main() must be called at the top level"), l2.length === 0 && e2.push({ op: r$1.HALT }), {
-    bytecode: e2,
-    errors: l2,
-    hasMain: o2
+  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
   };
 }
-let N$1 = class N {
+let A$1 = class A {
   constructor() {
-    u$1(this, "bytecode", []);
-    u$1(this, "contextStack", []);
+    x$1(this, "bytecode", []);
+    x$1(this, "contextStack", []);
   }
   /**
    * Emit an instruction and return its index
    */
-  emit(l2, e2) {
-    const o2 = this.bytecode.length;
-    return this.bytecode.push({ op: l2, arg: e2 }), o2;
+  emit(t2, s2) {
+    const r2 = this.bytecode.length;
+    return this.bytecode.push({ op: t2, arg: s2 }), r2;
   }
   /**
    * Get the current address (next instruction index)
@@ -81,20 +81,20 @@ let N$1 = class N {
   /**
    * Patch a jump instruction with the target address
    */
-  patchJump(l2, e2) {
-    l2 >= 0 && l2 < this.bytecode.length && (this.bytecode[l2].arg = e2);
+  patchJump(t2, s2) {
+    t2 >= 0 && t2 < this.bytecode.length && (this.bytecode[t2].arg = s2);
   }
   /**
    * Patch multiple jump instructions with the same target
    */
-  patchJumps(l2, e2) {
-    l2.forEach((o2) => this.patchJump(o2, e2));
+  patchJumps(t2, s2) {
+    t2.forEach((r2) => this.patchJump(r2, s2));
   }
   /**
    * Push a new jump context onto the stack
    */
-  pushContext(l2) {
-    this.contextStack.push(l2);
+  pushContext(t2) {
+    this.contextStack.push(t2);
   }
   /**
    * Pop the current jump context from the stack
@@ -112,9 +112,11 @@ let N$1 = class N {
    * Find the nearest loop context (for break/continue)
    */
   findLoopContext() {
-    for (let l2 = this.contextStack.length - 1; l2 >= 0; l2--)
-      if (this.contextStack[l2].type === "loop" || this.contextStack[l2].type === "foreach")
-        return this.contextStack[l2];
+    for (let t2 = this.contextStack.length - 1; t2 >= 0; t2--) {
+      const s2 = this.contextStack[t2];
+      if (s2.type === "loop" || s2.type === "foreach")
+        return s2;
+    }
     return null;
   }
   /**
@@ -136,280 +138,355 @@ let N$1 = class N {
     return [...this.contextStack];
   }
 };
-function k(n2) {
-  const l2 = I(n2);
-  if (l2.errors.length > 0)
+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 ? 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) {
+    const o2 = t2.currentAddress();
+    t2.patchJumps(l2.endTargets, o2);
+  }
+}, I = (e2, t2, { compileExpression: s2, compileStatement: r2 }) => {
+  const a2 = t2.currentAddress();
+  s2(e2.expression);
+  const l2 = {
+    type: "loop",
+    breakTargets: [t2.emit(i$1.JUMP_IF_FALSE, -1)],
+    continueTargets: [],
+    endTargets: [],
+    startAddress: 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);
+  }
+}, 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;
+  else
+    throw new Error("Unsupported for-of variable declaration");
+  s2(m2), t2.emit(i$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 = {
+    type: "foreach",
+    breakTargets: [c2],
+    continueTargets: [],
+    endTargets: [],
+    startAddress: o2,
+    iterVariable: l2
+  };
+  t2.pushContext(S), r2(e2.statement), t2.emit(i$1.JUMP, o2);
+  const u2 = t2.popContext();
+  if (u2) {
+    const E = t2.currentAddress();
+    t2.patchJumps(u2.breakTargets || [], E), t2.emit(i$1.ITER_END);
+  }
+}, y$1 = (e2, t2, { compileStatement: s2 }) => {
+  e2.statements.forEach((r2) => {
+    s2(r2);
+  });
+}, 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);
+            break;
+          case n__namespace.SyntaxKind.MinusEqualsToken:
+            t2.emit(i$1.SUB);
+            break;
+          case n__namespace.SyntaxKind.AsteriskEqualsToken:
+            t2.emit(i$1.MUL);
+            break;
+          case n__namespace.SyntaxKind.SlashEqualsToken:
+            t2.emit(i$1.DIV);
+            break;
+          case n__namespace.SyntaxKind.PercentEqualsToken:
+            t2.emit(i$1.MOD);
+            break;
+        }
+        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 (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);
+      }
+      return;
+    }
+  }
+  n__namespace.isCallExpression(r2) && n__namespace.isPropertyAccessExpression(r2.expression) && r2.expression.expression.getText() === "console" && r2.expression.name.getText() === "log" ? (r2.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);
+}, 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);
+  } 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);
+  } 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);
+}, 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);
+  });
+}, 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:
+      s2(e2.operand), t2.emit(i$1.NOT);
+      break;
+    case n__namespace.SyntaxKind.MinusToken:
+      s2(e2.operand), t2.emit(i$1.UNARY_MINUS);
+      break;
+    case n__namespace.SyntaxKind.PlusToken:
+      s2(e2.operand), t2.emit(i$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));
+      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));
+      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));
+      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));
+      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));
+}
+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);
+      break;
+    case n__namespace.SyntaxKind.MinusToken:
+      t2.emit(i$1.SUB);
+      break;
+    case n__namespace.SyntaxKind.AsteriskToken:
+      t2.emit(i$1.MUL);
+      break;
+    case n__namespace.SyntaxKind.SlashToken:
+      t2.emit(i$1.DIV);
+      break;
+    case n__namespace.SyntaxKind.PercentToken:
+      t2.emit(i$1.MOD);
+      break;
+    case n__namespace.SyntaxKind.EqualsEqualsToken:
+      t2.emit(i$1.EQ);
+      break;
+    case n__namespace.SyntaxKind.ExclamationEqualsToken:
+      t2.emit(i$1.NEQ);
+      break;
+    case n__namespace.SyntaxKind.LessThanToken:
+      t2.emit(i$1.LT);
+      break;
+    case n__namespace.SyntaxKind.GreaterThanToken:
+      t2.emit(i$1.GT);
+      break;
+    case n__namespace.SyntaxKind.LessThanEqualsToken:
+      t2.emit(i$1.LTE);
+      break;
+    case n__namespace.SyntaxKind.GreaterThanEqualsToken:
+      t2.emit(i$1.GTE);
+      break;
+    case n__namespace.SyntaxKind.EqualsEqualsEqualsToken:
+      t2.emit(i$1.EQ_STRICT);
+      break;
+    case n__namespace.SyntaxKind.ExclamationEqualsEqualsToken:
+      t2.emit(i$1.NEQ_STRICT);
+      break;
+    case n__namespace.SyntaxKind.AmpersandAmpersandToken:
+      t2.emit(i$1.AND);
+      break;
+    case n__namespace.SyntaxKind.BarBarToken:
+      t2.emit(i$1.OR);
+      break;
+  }
+}, 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 ? 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);
+    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$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
+};
+function W$1(e2) {
+  const t2 = R(e2);
+  if (t2.errors.length > 0)
     return {
       success: false,
       bytecode: [],
-      errors: l2.errors
+      errors: t2.errors
     };
-  const e2 = new N$1(), o2 = s__namespace.createSourceFile("program.ts", n2, s__namespace.ScriptTarget.Latest, true);
-  function T(t2) {
-    if (s__namespace.isIfStatement(t2)) {
-      a2(t2.expression);
-      const i2 = e2.emit(r$1.JUMP_IF_FALSE, -1), c2 = {
-        type: "if",
-        endTargets: []
-      };
-      if (t2.elseStatement ? c2.elseTarget = i2 : c2.endTargets.push(i2), e2.pushContext(c2), T(t2.thenStatement), t2.elseStatement) {
-        const x = e2.emit(r$1.JUMP, -1);
-        c2.endTargets.push(x);
-        const S = e2.currentAddress();
-        e2.patchJump(i2, S), T(t2.elseStatement);
-      }
-      const m2 = e2.popContext();
-      if (m2) {
-        const x = e2.currentAddress();
-        e2.patchJumps(m2.endTargets, x);
-      }
-    } else if (s__namespace.isWhileStatement(t2)) {
-      const i2 = e2.currentAddress();
-      a2(t2.expression);
-      const m2 = {
-        type: "loop",
-        breakTargets: [e2.emit(r$1.JUMP_IF_FALSE, -1)],
-        continueTargets: [],
-        endTargets: [],
-        startAddress: i2
-      };
-      e2.pushContext(m2), T(t2.statement), e2.emit(r$1.JUMP, i2);
-      const x = e2.popContext();
-      if (x) {
-        const S = e2.currentAddress();
-        e2.patchJumps(x.breakTargets || [], S);
-      }
-    } else if (s__namespace.isForOfStatement(t2)) {
-      const i2 = t2.initializer, c2 = t2.expression;
-      let m2;
-      if (s__namespace.isVariableDeclarationList(i2))
-        m2 = i2.declarations[0].name.getText();
-      else if (s__namespace.isIdentifier(i2))
-        m2 = i2.text;
-      else
-        throw new Error("Unsupported for-of variable declaration");
-      a2(c2), e2.emit(r$1.ITER_START);
-      const x = e2.currentAddress();
-      e2.emit(r$1.ITER_NEXT);
-      const S = e2.emit(r$1.JUMP_IF_FALSE, -1);
-      e2.emit(r$1.STORE, m2);
-      const A2 = {
-        type: "foreach",
-        breakTargets: [S],
-        continueTargets: [],
-        endTargets: [],
-        startAddress: x,
-        iterVariable: m2
-      };
-      e2.pushContext(A2), T(t2.statement), e2.emit(r$1.JUMP, x);
-      const f2 = e2.popContext();
-      if (f2) {
-        e2.emit(r$1.ITER_END);
-        const p2 = e2.currentAddress();
-        e2.patchJumps(f2.breakTargets || [], p2);
-      }
-    } else if (s__namespace.isBlock(t2))
-      t2.statements.forEach((i2) => {
-        T(i2);
-      });
-    else if (s__namespace.isExpressionStatement(t2)) {
-      const i2 = t2.expression;
-      if (s__namespace.isBinaryExpression(i2)) {
-        const c2 = i2.operatorToken.kind;
-        if (c2 === s__namespace.SyntaxKind.PlusEqualsToken || c2 === s__namespace.SyntaxKind.MinusEqualsToken || c2 === s__namespace.SyntaxKind.AsteriskEqualsToken || c2 === s__namespace.SyntaxKind.SlashEqualsToken || c2 === s__namespace.SyntaxKind.PercentEqualsToken) {
-          if (s__namespace.isIdentifier(i2.left)) {
-            switch (e2.emit(r$1.LOAD, i2.left.text), a2(i2.right), c2) {
-              case s__namespace.SyntaxKind.PlusEqualsToken:
-                s__namespace.isStringLiteral(i2.right) ? e2.emit(r$1.CONCAT) : e2.emit(r$1.ADD);
-                break;
-              case s__namespace.SyntaxKind.MinusEqualsToken:
-                e2.emit(r$1.SUB);
-                break;
-              case s__namespace.SyntaxKind.AsteriskEqualsToken:
-                e2.emit(r$1.MUL);
-                break;
-              case s__namespace.SyntaxKind.SlashEqualsToken:
-                e2.emit(r$1.DIV);
-                break;
-              case s__namespace.SyntaxKind.PercentEqualsToken:
-                e2.emit(r$1.MOD);
-                break;
-            }
-            e2.emit(r$1.STORE, i2.left.text);
-          } else if (s__namespace.isElementAccessExpression(i2.left))
-            throw new Error("Compound assignment to array elements not yet supported");
-          return;
-        } else if (c2 === s__namespace.SyntaxKind.EqualsToken) {
-          if (a2(i2.right), s__namespace.isIdentifier(i2.left))
-            e2.emit(r$1.STORE, i2.left.text);
-          else if (s__namespace.isElementAccessExpression(i2.left)) {
-            const m2 = `__temp_${e2.getBytecode().length}`;
-            e2.emit(r$1.STORE, m2), a2(i2.left.expression), a2(i2.left.argumentExpression), e2.emit(r$1.LOAD, m2), e2.emit(r$1.ARRAY_SET);
-          }
-          return;
-        }
-      }
-      s__namespace.isCallExpression(i2) && s__namespace.isPropertyAccessExpression(i2.expression) && i2.expression.expression.getText() === "console" && i2.expression.name.getText() === "log" ? (i2.arguments.forEach((c2) => {
-        a2(c2);
-      }), e2.emit(r$1.PRINT)) : s__namespace.isCallExpression(i2) && s__namespace.isIdentifier(i2.expression) && i2.expression.text === "CC" ? (i2.arguments.length > 0 && a2(i2.arguments[0]), e2.emit(r$1.CC), e2.emit(r$1.POP)) : s__namespace.isCallExpression(i2) && s__namespace.isPropertyAccessExpression(i2.expression) && i2.expression.name.getText() === "push" ? (a2(i2.expression.expression), i2.arguments.length > 0 && a2(i2.arguments[0]), e2.emit(r$1.ARRAY_PUSH)) : (s__namespace.isPostfixUnaryExpression(i2) || s__namespace.isPrefixUnaryExpression(i2)) && (a2(i2), e2.emit(r$1.POP));
-    } else if (s__namespace.isVariableStatement(t2)) {
-      const i2 = t2.declarationList.declarations[0];
-      i2.initializer && (a2(i2.initializer), e2.emit(r$1.STORE, i2.name.getText()));
-    } else if (s__namespace.isReturnStatement(t2))
-      t2.expression ? a2(t2.expression) : e2.emit(r$1.PUSH, null), e2.emit(r$1.RETURN);
-    else if (s__namespace.isBreakStatement(t2)) {
-      const i2 = e2.findLoopContext();
-      if (i2) {
-        i2.type === "foreach" && e2.emit(r$1.ITER_END);
-        const c2 = e2.emit(r$1.BREAK, -1);
-        i2.breakTargets = i2.breakTargets || [], i2.breakTargets.push(c2);
-      } else
-        throw new Error("break statement not in loop");
-    } else if (s__namespace.isContinueStatement(t2)) {
-      const i2 = e2.findLoopContext();
-      if (i2 && i2.startAddress !== void 0) {
-        const c2 = e2.emit(r$1.CONTINUE, i2.startAddress);
-        i2.continueTargets = i2.continueTargets || [], i2.continueTargets.push(c2);
-      } else
-        throw new Error("continue statement not in loop");
-    }
-  }
-  function a2(t2) {
-    if (s__namespace.isStringLiteral(t2))
-      e2.emit(r$1.PUSH, t2.text);
-    else if (s__namespace.isNumericLiteral(t2))
-      e2.emit(r$1.PUSH, Number(t2.text));
-    else if (t2.kind === s__namespace.SyntaxKind.TrueKeyword)
-      e2.emit(r$1.PUSH, true);
-    else if (t2.kind === s__namespace.SyntaxKind.FalseKeyword)
-      e2.emit(r$1.PUSH, false);
-    else if (t2.kind === s__namespace.SyntaxKind.NullKeyword)
-      e2.emit(r$1.PUSH, null);
-    else if (s__namespace.isArrayLiteralExpression(t2))
-      e2.emit(r$1.ARRAY_NEW), t2.elements.forEach((i2) => {
-        a2(i2), e2.emit(r$1.ARRAY_PUSH);
-      });
-    else if (s__namespace.isElementAccessExpression(t2))
-      a2(t2.expression), t2.argumentExpression && a2(t2.argumentExpression), e2.emit(r$1.ARRAY_GET);
-    else if (s__namespace.isPropertyAccessExpression(t2) && t2.name.text === "length")
-      a2(t2.expression), e2.emit(r$1.LENGTH);
-    else if (s__namespace.isIdentifier(t2))
-      t2.text === "undefined" ? e2.emit(r$1.PUSH_UNDEFINED) : e2.emit(r$1.LOAD, t2.text);
-    else if (s__namespace.isCallExpression(t2)) {
-      if (s__namespace.isPropertyAccessExpression(t2.expression) && s__namespace.isIdentifier(t2.expression.expression) && t2.expression.expression.text === "fs" && t2.expression.name.text === "listFiles")
-        t2.arguments.length > 0 ? a2(t2.arguments[0]) : e2.emit(r$1.PUSH, "."), t2.arguments.length > 1 && a2(t2.arguments[1]), e2.emit(r$1.FS_LIST_FILES);
-      else if (s__namespace.isPropertyAccessExpression(t2.expression) && s__namespace.isIdentifier(t2.expression.expression) && t2.expression.expression.text === "JSON" && t2.expression.name.text === "parse")
-        t2.arguments.length > 0 && a2(t2.arguments[0]), e2.emit(r$1.JSON_PARSE);
-      else if (s__namespace.isIdentifier(t2.expression) && t2.expression.text === "CC")
-        t2.arguments.length > 0 && a2(t2.arguments[0]), e2.emit(r$1.CC);
-      else if (s__namespace.isPropertyAccessExpression(t2.expression)) {
-        const i2 = t2.expression.name.text;
-        i2 === "substring" ? (a2(t2.expression.expression), t2.arguments.length > 0 ? a2(t2.arguments[0]) : e2.emit(r$1.PUSH, 0), t2.arguments.length > 1 && a2(t2.arguments[1]), e2.emit(r$1.STRING_SUBSTRING)) : i2 === "indexOf" ? (a2(t2.expression.expression), t2.arguments.length > 0 ? a2(t2.arguments[0]) : e2.emit(r$1.PUSH, ""), e2.emit(r$1.STRING_INDEXOF)) : i2 === "split" ? (a2(t2.expression.expression), t2.arguments.length > 0 ? a2(t2.arguments[0]) : e2.emit(r$1.PUSH, ""), e2.emit(r$1.STRING_SPLIT)) : i2 === "slice" ? (a2(t2.expression.expression), t2.arguments.length > 0 ? a2(t2.arguments[0]) : e2.emit(r$1.PUSH, 0), t2.arguments.length > 1 && a2(t2.arguments[1]), e2.emit(r$1.STRING_SLICE)) : i2 === "charAt" ? (a2(t2.expression.expression), t2.arguments.length > 0 ? a2(t2.arguments[0]) : e2.emit(r$1.PUSH, 0), e2.emit(r$1.STRING_CHARAT)) : i2 === "toUpperCase" ? (a2(t2.expression.expression), e2.emit(r$1.STRING_TOUPPERCASE)) : i2 === "toLowerCase" && (a2(t2.expression.expression), e2.emit(r$1.STRING_TOLOWERCASE));
-      }
-    } else if (s__namespace.isParenthesizedExpression(t2))
-      a2(t2.expression);
-    else if (s__namespace.isBinaryExpression(t2)) {
-      const i2 = t2.operatorToken.kind;
-      switch (a2(t2.left), a2(t2.right), i2) {
-        case s__namespace.SyntaxKind.PlusToken:
-          E(t2.left, t2.right) ? e2.emit(r$1.CONCAT) : e2.emit(r$1.ADD);
-          break;
-        case s__namespace.SyntaxKind.MinusToken:
-          e2.emit(r$1.SUB);
-          break;
-        case s__namespace.SyntaxKind.AsteriskToken:
-          e2.emit(r$1.MUL);
-          break;
-        case s__namespace.SyntaxKind.SlashToken:
-          e2.emit(r$1.DIV);
-          break;
-        case s__namespace.SyntaxKind.PercentToken:
-          e2.emit(r$1.MOD);
-          break;
-        case s__namespace.SyntaxKind.EqualsEqualsToken:
-          e2.emit(r$1.EQ);
-          break;
-        case s__namespace.SyntaxKind.ExclamationEqualsToken:
-          e2.emit(r$1.NEQ);
-          break;
-        case s__namespace.SyntaxKind.LessThanToken:
-          e2.emit(r$1.LT);
-          break;
-        case s__namespace.SyntaxKind.GreaterThanToken:
-          e2.emit(r$1.GT);
-          break;
-        case s__namespace.SyntaxKind.LessThanEqualsToken:
-          e2.emit(r$1.LTE);
-          break;
-        case s__namespace.SyntaxKind.GreaterThanEqualsToken:
-          e2.emit(r$1.GTE);
-          break;
-        case s__namespace.SyntaxKind.EqualsEqualsEqualsToken:
-          e2.emit(r$1.EQ_STRICT);
-          break;
-        case s__namespace.SyntaxKind.ExclamationEqualsEqualsToken:
-          e2.emit(r$1.NEQ_STRICT);
-          break;
-        case s__namespace.SyntaxKind.AmpersandAmpersandToken:
-          e2.emit(r$1.AND);
-          break;
-        case s__namespace.SyntaxKind.BarBarToken:
-          e2.emit(r$1.OR);
-          break;
-      }
-    } else if (s__namespace.isPrefixUnaryExpression(t2))
-      switch (t2.operator) {
-        case s__namespace.SyntaxKind.ExclamationToken:
-          a2(t2.operand), e2.emit(r$1.NOT);
-          break;
-        case s__namespace.SyntaxKind.MinusToken:
-          a2(t2.operand), e2.emit(r$1.UNARY_MINUS);
-          break;
-        case s__namespace.SyntaxKind.PlusToken:
-          a2(t2.operand), e2.emit(r$1.UNARY_PLUS);
-          break;
-        case s__namespace.SyntaxKind.PlusPlusToken:
-          s__namespace.isIdentifier(t2.operand) && (e2.emit(r$1.PUSH, t2.operand.text), e2.emit(r$1.INC, false));
-          break;
-        case s__namespace.SyntaxKind.MinusMinusToken:
-          s__namespace.isIdentifier(t2.operand) && (e2.emit(r$1.PUSH, t2.operand.text), e2.emit(r$1.DEC, false));
-          break;
-      }
-    else if (s__namespace.isPostfixUnaryExpression(t2))
-      switch (t2.operator) {
-        case s__namespace.SyntaxKind.PlusPlusToken:
-          s__namespace.isIdentifier(t2.operand) && (e2.emit(r$1.PUSH, t2.operand.text), e2.emit(r$1.INC, true));
-          break;
-        case s__namespace.SyntaxKind.MinusMinusToken:
-          s__namespace.isIdentifier(t2.operand) && (e2.emit(r$1.PUSH, t2.operand.text), e2.emit(r$1.DEC, true));
-          break;
-      }
-    else if (s__namespace.isTypeOfExpression(t2))
-      a2(t2.expression), e2.emit(r$1.TYPEOF);
-    else if (s__namespace.isConditionalExpression(t2)) {
-      a2(t2.condition);
-      const i2 = e2.emit(r$1.JUMP_IF_FALSE, -1);
-      a2(t2.whenTrue);
-      const c2 = e2.emit(r$1.JUMP, -1), m2 = e2.currentAddress();
-      e2.patchJump(i2, m2), a2(t2.whenFalse);
-      const x = e2.currentAddress();
-      e2.patchJump(c2, x);
-    }
-  }
-  return o2.forEachChild((t2) => {
-    var i2;
-    s__namespace.isFunctionDeclaration(t2) && ((i2 = t2.name) == null ? void 0 : i2.text) === "main" && t2.body && t2.body.statements.forEach((c2) => {
-      T(c2);
+  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 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);
     });
-  }), e2.emit(r$1.HALT), {
+  }), s2.emit(i$1.HALT), {
     success: true,
-    bytecode: e2.getBytecode(),
+    bytecode: s2.getBytecode(),
     errors: []
   };
 }
-function E(n2, l2) {
-  return !!(s__namespace.isStringLiteral(n2) || s__namespace.isStringLiteral(l2) || s__namespace.isBinaryExpression(n2) && n2.operatorToken.kind === s__namespace.SyntaxKind.PlusToken && E(n2.left, n2.right) || s__namespace.isBinaryExpression(l2) && l2.operatorToken.kind === s__namespace.SyntaxKind.PlusToken && E(l2.left, l2.right));
-}
 function n(r2) {
   return typeof r2 == "string";
 }
@@ -419,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 m(r2) {
-  return n(r2) ? "string" : t(r2) ? "number" : i(r2) ? "boolean" : f(r2) ? "null" : o(r2) ? "undefined" : e(r2) ? "array" : "unknown";
+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 d(r2) {
+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 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");
@@ -466,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 M.promises.mkdir(this.dataDir, { recursive: true }), await M.promises.mkdir(this.programsDir, { recursive: true }), await M.promises.mkdir(this.executionsDir, { recursive: true }), await M.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;
@@ -477,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 M.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 M.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")
@@ -494,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 M.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 M.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")
@@ -513,13 +596,13 @@ class h {
     const e2 = c__namespace.join(this.outputsDir, `${t2}.output`), o2 = n2.join(`
 `) + `
 `;
-    await M.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 M.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")
@@ -527,7 +610,7 @@ class h {
       throw e2;
     }
   }
-}
+};
 class p {
   constructor(t2) {
     r(this, "client");
@@ -589,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";
@@ -605,737 +688,1045 @@ class g {
         throw new Error(`Unsupported storage type: ${n2}`);
     }
   }
+};
+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 = m(t2), o2 = m(r2);
+      e2.stack.push(s2 + o2);
+    }
+  },
+  [i$1.SUB]: {
+    stackIn: 2,
+    stackOut: 1,
+    execute: (e2) => {
+      const r2 = e2.stack.pop(), t2 = e2.stack.pop(), s2 = m(t2), o2 = m(r2);
+      e2.stack.push(s2 - o2);
+    }
+  },
+  [i$1.MUL]: {
+    stackIn: 2,
+    stackOut: 1,
+    execute: (e2) => {
+      const r2 = e2.stack.pop(), t2 = e2.stack.pop(), s2 = m(t2), o2 = m(r2);
+      e2.stack.push(s2 * o2);
+    }
+  },
+  [i$1.DIV]: {
+    stackIn: 2,
+    stackOut: 1,
+    execute: (e2, r2) => {
+      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
+        };
+      e2.stack.push(o2 / n2);
+    }
+  },
+  [i$1.MOD]: {
+    stackIn: 2,
+    stackOut: 1,
+    execute: (e2) => {
+      const r2 = e2.stack.pop(), t2 = e2.stack.pop(), s2 = m(t2), o2 = m(r2);
+      e2.stack.push(s2 % o2);
+    }
+  },
+  [i$1.UNARY_MINUS]: {
+    stackIn: 1,
+    stackOut: 1,
+    execute: (e2) => {
+      const r2 = e2.stack.pop(), t2 = m(r2);
+      e2.stack.push(-t2);
+    }
+  },
+  [i$1.UNARY_PLUS]: {
+    stackIn: 1,
+    stackOut: 1,
+    execute: (e2) => {
+      const r2 = e2.stack.pop(), t2 = m(r2);
+      e2.stack.push(t2);
+    }
+  }
+}, V = {
+  [i$1.PUSH]: {
+    stackIn: 0,
+    stackOut: 1,
+    execute: (e2, r2) => {
+      e2.stack.push(r2.arg);
+    }
+  },
+  [i$1.PUSH_UNDEFINED]: {
+    stackIn: 0,
+    stackOut: 1,
+    execute: (e2) => {
+      e2.stack.push(s$1());
+    }
+  },
+  [i$1.POP]: {
+    stackIn: 1,
+    stackOut: 0,
+    execute: (e2) => {
+      e2.stack.pop();
+    }
+  }
+}, M = {
+  [i$1.PRINT]: {
+    stackIn: 1,
+    stackOut: 0,
+    execute: (e2) => {
+      const r2 = e2.stack.pop();
+      r2 !== void 0 && e2.output.push(y(r2));
+    }
+  },
+  [i$1.CC]: {
+    stackIn: 1,
+    stackOut: 0,
+    controlsPC: true,
+    // CC pauses execution
+    execute: (e2, r2) => {
+      const t2 = e2.stack.pop();
+      e2.ccPrompt = y(t2), e2.status = "waiting_cc";
+    }
+  }
+}, j = {
+  [i$1.HALT]: {
+    stackIn: 0,
+    stackOut: 0,
+    controlsPC: true,
+    execute: (e2) => {
+      e2.status = "complete";
+    }
+  },
+  [i$1.JUMP]: {
+    stackIn: 0,
+    stackOut: 0,
+    controlsPC: true,
+    execute: (e2, r2) => {
+      if (r2.arg === void 0)
+        return {
+          type: "RuntimeError",
+          message: "JUMP requires a target address",
+          pc: e2.pc,
+          opcode: r2.op
+        };
+      const t2 = r2.arg;
+      if (t2 < 0)
+        return {
+          type: "RuntimeError",
+          message: `Invalid jump target: ${t2}`,
+          pc: e2.pc,
+          opcode: r2.op
+        };
+      e2.pc = t2;
+    }
+  },
+  [i$1.JUMP_IF_FALSE]: {
+    stackIn: 1,
+    stackOut: 0,
+    controlsPC: true,
+    execute: (e2, r2) => {
+      const t2 = e2.stack.pop();
+      if (r2.arg === void 0)
+        return {
+          type: "RuntimeError",
+          message: "JUMP_IF_FALSE requires a target address",
+          pc: e2.pc,
+          opcode: r2.op
+        };
+      const s2 = r2.arg;
+      if (s2 < 0)
+        return {
+          type: "RuntimeError",
+          message: `Invalid jump target: ${s2}`,
+          pc: e2.pc,
+          opcode: r2.op
+        };
+      b$1(t2) ? e2.pc++ : e2.pc = s2;
+    }
+  }
+}, F = {
+  [i$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());
+    }
+  },
+  [i$1.STORE]: {
+    stackIn: 1,
+    stackOut: 0,
+    execute: (e2, r2) => {
+      const t2 = e2.stack.pop();
+      e2.variables.set(r2.arg, t2);
+    }
+  }
+}, D = {
+  [i$1.ITER_START]: {
+    stackIn: 1,
+    stackOut: 0,
+    execute: (e2, r2) => {
+      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
+        };
+      if (!f(t2))
+        return {
+          type: "TypeError",
+          message: "TypeError: Cannot iterate over non-array value",
+          pc: e2.pc,
+          opcode: r2.op
+        };
+      if (e2.iterators.length >= 10)
+        return {
+          type: "RuntimeError",
+          message: "RuntimeError: Maximum iterator depth exceeded",
+          pc: e2.pc,
+          opcode: r2.op
+        };
+      e2.iterators.push({
+        array: t2,
+        index: 0,
+        length: t2.elements.length
+      });
+    }
+  },
+  [i$1.ITER_NEXT]: {
+    stackIn: 0,
+    stackOut: 2,
+    // Pushes element and hasMore flag
+    execute: (e2, r2) => {
+      if (e2.iterators.length === 0)
+        return {
+          type: "RuntimeError",
+          message: "ITER_NEXT: No active iterator",
+          pc: e2.pc,
+          opcode: r2.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));
+    }
+  },
+  [i$1.ITER_END]: {
+    stackIn: 0,
+    stackOut: 0,
+    execute: (e2, r2) => {
+      if (e2.iterators.length === 0)
+        return {
+          type: "RuntimeError",
+          message: "ITER_END: No active iterator",
+          pc: e2.pc,
+          opcode: r2.op
+        };
+      e2.iterators.pop();
+    }
+  }
+};
+function g2(e2, r2, t2) {
+  const s2 = e2.stack.pop(), o2 = e2.stack.pop(), n2 = t2(o2, s2);
+  e2.stack.push(n2);
 }
-var C = Object.defineProperty;
-var G = (g2, a2, s2) => a2 in g2 ? C(g2, a2, { enumerable: true, configurable: true, writable: true, value: s2 }) : g2[a2] = s2;
-var N2 = (g2, a2, s2) => G(g2, typeof a2 != "symbol" ? a2 + "" : a2, s2);
-class A {
-  execute(a2, s2) {
-    const r2 = {
-      pc: (s2 == null ? void 0 : s2.pc) ?? 0,
-      stack: (s2 == null ? void 0 : s2.stack) ?? [],
-      variables: (s2 == null ? void 0 : s2.variables) ?? /* @__PURE__ */ new Map(),
+const q = {
+  [i$1.EQ]: {
+    stackIn: 2,
+    stackOut: 1,
+    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 o2 = m(t2), n2 = m(s2);
+        return !isNaN(o2) && !isNaN(n2) ? o2 === n2 : y(t2) === y(s2);
+      }
+    })
+  },
+  [i$1.NEQ]: {
+    stackIn: 2,
+    stackOut: 1,
+    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 o2 = m(t2), n2 = m(s2);
+        return !isNaN(o2) && !isNaN(n2) ? o2 !== n2 : y(t2) !== y(s2);
+      }
+    })
+  },
+  [i$1.LT]: {
+    stackIn: 2,
+    stackOut: 1,
+    execute: (e2, r2) => g2(e2, r2, (t2, s2) => {
+      const o2 = m(t2), n2 = m(s2);
+      return o2 < n2;
+    })
+  },
+  [i$1.GT]: {
+    stackIn: 2,
+    stackOut: 1,
+    execute: (e2, r2) => g2(e2, r2, (t2, s2) => {
+      const o2 = m(t2), n2 = m(s2);
+      return o2 > n2;
+    })
+  },
+  [i$1.LTE]: {
+    stackIn: 2,
+    stackOut: 1,
+    execute: (e2, r2) => g2(e2, r2, (t2, s2) => {
+      const o2 = m(t2), n2 = m(s2);
+      return o2 <= n2;
+    })
+  },
+  [i$1.GTE]: {
+    stackIn: 2,
+    stackOut: 1,
+    execute: (e2, r2) => g2(e2, r2, (t2, s2) => {
+      const o2 = m(t2), n2 = m(s2);
+      return o2 >= n2;
+    })
+  },
+  [i$1.EQ_STRICT]: {
+    stackIn: 2,
+    stackOut: 1,
+    execute: (e2, r2) => g2(e2, r2, (t2, s2) => t2 === s2)
+  },
+  [i$1.NEQ_STRICT]: {
+    stackIn: 2,
+    stackOut: 1,
+    execute: (e2, r2) => g2(e2, r2, (t2, s2) => t2 !== s2)
+  }
+}, H = {
+  [i$1.AND]: {
+    stackIn: 2,
+    stackOut: 1,
+    execute: (e2, r2) => {
+      const t2 = e2.stack.pop(), s2 = e2.stack.pop(), o2 = b$1(s2) ? t2 : s2;
+      e2.stack.push(o2);
+    }
+  },
+  [i$1.OR]: {
+    stackIn: 2,
+    stackOut: 1,
+    execute: (e2, r2) => {
+      const t2 = e2.stack.pop(), s2 = e2.stack.pop(), o2 = b$1(s2) ? s2 : t2;
+      e2.stack.push(o2);
+    }
+  },
+  [i$1.NOT]: {
+    stackIn: 1,
+    stackOut: 1,
+    execute: (e2, r2) => {
+      const t2 = e2.stack.pop(), s2 = !b$1(t2);
+      e2.stack.push(s2);
+    }
+  }
+}, Y = {
+  [i$1.ARRAY_NEW]: {
+    stackIn: 0,
+    stackOut: 1,
+    execute: (e2, r2) => {
+      e2.stack.push(d());
+    }
+  },
+  [i$1.ARRAY_PUSH]: {
+    stackIn: 2,
+    stackOut: 1,
+    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: e2.pc,
+          opcode: r2.op
+        };
+      s2.elements.push(t2), e2.stack.push(s2);
+    }
+  },
+  [i$1.ARRAY_GET]: {
+    stackIn: 2,
+    stackOut: 1,
+    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
+      };
+    }
+  },
+  [i$1.ARRAY_SET]: {
+    stackIn: 3,
+    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
+      };
+    }
+  },
+  [i$1.ARRAY_LEN]: {
+    stackIn: 1,
+    stackOut: 1,
+    execute: (e2, r2) => {
+      const t2 = e2.stack.pop();
+      if (!f(t2))
+        return {
+          type: "RuntimeError",
+          message: "ARRAY_LEN requires an array",
+          pc: e2.pc,
+          opcode: r2.op
+        };
+      e2.stack.push(t2.elements.length);
+    }
+  }
+};
+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(y(s2) + y(t2));
+    }
+  },
+  [i$1.STRING_LEN]: {
+    stackIn: 1,
+    stackOut: 1,
+    execute: (e2, r2) => {
+      const t2 = e2.stack.pop();
+      if (!n(t2))
+        return {
+          type: "RuntimeError",
+          message: "STRING_LEN requires a string",
+          pc: e2.pc,
+          opcode: r2.op
+        };
+      e2.stack.push(t2.length);
+    }
+  },
+  [i$1.LENGTH]: {
+    stackIn: 1,
+    stackOut: 1,
+    execute: (e2, r2) => {
+      const t2 = e2.stack.pop();
+      if (n(t2))
+        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: e2.pc,
+          opcode: r2.op
+        };
+    }
+  },
+  [i$1.JSON_PARSE]: {
+    stackIn: 1,
+    stackOut: 1,
+    execute: (e2, r2) => {
+      const t2 = e2.stack.pop();
+      if (!n(t2))
+        return {
+          type: "RuntimeError",
+          message: "JSON_PARSE requires a string",
+          pc: e2.pc,
+          opcode: r2.op
+        };
+      try {
+        const s2 = JSON.parse(t2);
+        e2.stack.push(x(s2));
+      } catch {
+        e2.stack.push(null);
+      }
+    }
+  },
+  [i$1.TYPEOF]: {
+    stackIn: 1,
+    stackOut: 1,
+    execute: (e2, r2) => {
+      const t2 = e2.stack.pop();
+      e2.stack.push(p$1(t2));
+    }
+  }
+}, B = {
+  [i$1.INC]: {
+    stackIn: 1,
+    stackOut: 1,
+    execute: (e2, r2) => {
+      const t2 = e2.stack.pop();
+      if (typeof t2 != "string")
+        return {
+          type: "RuntimeError",
+          message: "INC: Invalid variable name",
+          pc: e2.pc,
+          opcode: r2.op
+        };
+      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 ? m(s2) : o2);
+    }
+  },
+  [i$1.DEC]: {
+    stackIn: 1,
+    stackOut: 1,
+    execute: (e2, r2) => {
+      const t2 = e2.stack.pop();
+      if (typeof t2 != "string")
+        return {
+          type: "RuntimeError",
+          message: "DEC: Invalid variable name",
+          pc: e2.pc,
+          opcode: r2.op
+        };
+      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 ? m(s2) : o2);
+    }
+  }
+}, J = {
+  [i$1.RETURN]: {
+    stackIn: 0,
+    stackOut: 0,
+    controlsPC: true,
+    execute: (e2, r2) => {
+      const t2 = e2.stack.pop() ?? null;
+      e2.returnValue = t2, e2.status = "complete";
+    }
+  },
+  [i$1.BREAK]: {
+    stackIn: 0,
+    stackOut: 0,
+    controlsPC: true,
+    execute: (e2, r2) => {
+      if (r2.arg === void 0)
+        return {
+          type: "RuntimeError",
+          message: "BREAK requires a target address",
+          pc: e2.pc,
+          opcode: r2.op
+        };
+      const t2 = r2.arg;
+      if (t2 < 0)
+        return {
+          type: "RuntimeError",
+          message: `Invalid break target: ${t2}`,
+          pc: e2.pc,
+          opcode: r2.op
+        };
+      e2.pc = t2;
+    }
+  },
+  [i$1.CONTINUE]: {
+    stackIn: 0,
+    stackOut: 0,
+    controlsPC: true,
+    execute: (e2, r2) => {
+      if (r2.arg === void 0)
+        return {
+          type: "RuntimeError",
+          message: "CONTINUE requires a target address",
+          pc: e2.pc,
+          opcode: r2.op
+        };
+      const t2 = r2.arg;
+      if (t2 < 0)
+        return {
+          type: "RuntimeError",
+          message: `Invalid continue target: ${t2}`,
+          pc: e2.pc,
+          opcode: r2.op
+        };
+      e2.pc = t2;
+    }
+  },
+  [i$1.FS_LIST_FILES]: {
+    stackIn: 1,
+    // Minimum 1 argument (path), optionally 2 (path + options)
+    stackOut: 0,
+    controlsPC: true,
+    execute: (e2, r2) => {
+      if (e2.stack.length < 1)
+        return {
+          type: "StackUnderflow",
+          message: "FS_LIST_FILES: Stack underflow",
+          pc: e2.pc,
+          opcode: r2.op
+        };
+      let t2, s2 = {};
+      const o2 = e2.stack[e2.stack.length - 1];
+      if (e2.stack.length >= 2 && typeof o2 == "object" && o2 !== null && !f(o2) && (s2 = e2.stack.pop()), t2 = e2.stack.pop(), !n(t2))
+        return {
+          type: "RuntimeError",
+          message: "FS_LIST_FILES requires a string path",
+          pc: e2.pc,
+          opcode: r2.op
+        };
+      e2.fsOperation = {
+        type: "listFiles",
+        path: t2,
+        options: s2
+      }, e2.status = "waiting_fs";
+    }
+  },
+  // String method handlers
+  [i$1.STRING_SUBSTRING]: {
+    stackIn: 2,
+    // Minimum 2 (string, start), optionally 3 (string, start, end)
+    stackOut: 1,
+    execute: (e2, r2) => {
+      if (e2.stack.length < 2)
+        return {
+          type: "StackUnderflow",
+          message: "STRING_SUBSTRING: Stack underflow",
+          pc: e2.pc,
+          opcode: r2.op
+        };
+      const t2 = e2.stack.length;
+      let s2, o2, n$12;
+      const a2 = e2.stack[t2 - 1], i2 = e2.stack[t2 - 2];
+      if (t2 >= 3 && typeof a2 == "number" && typeof i2 == "number" ? (n$12 = e2.stack.pop(), o2 = e2.stack.pop(), s2 = e2.stack.pop()) : (o2 = e2.stack.pop(), s2 = e2.stack.pop(), n$12 = void 0), !n(s2))
+        return {
+          type: "RuntimeError",
+          message: "STRING_SUBSTRING requires a string",
+          pc: e2.pc,
+          opcode: r2.op
+        };
+      if (typeof o2 != "number")
+        return {
+          type: "RuntimeError",
+          message: "STRING_SUBSTRING requires numeric start index",
+          pc: e2.pc,
+          opcode: r2.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);
+    }
+  },
+  [i$1.STRING_INDEXOF]: {
+    stackIn: 2,
+    stackOut: 1,
+    execute: (e2, r2) => {
+      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
+        };
+      e2.stack.push(s2.indexOf(t2));
+    }
+  },
+  [i$1.STRING_SPLIT]: {
+    stackIn: 2,
+    stackOut: 1,
+    execute: (e2, r2) => {
+      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
+        };
+      let o2;
+      t2 === "" ? o2 = s2.split("") : o2 = s2.split(t2), e2.stack.push(d(o2));
+    }
+  },
+  [i$1.STRING_SLICE]: {
+    stackIn: 2,
+    // Minimum 2 (string, start), optionally 3 (string, start, end)
+    stackOut: 1,
+    execute: (e2, r2) => {
+      if (e2.stack.length < 2)
+        return {
+          type: "StackUnderflow",
+          message: "STRING_SLICE: Stack underflow",
+          pc: e2.pc,
+          opcode: r2.op
+        };
+      const t2 = e2.stack.length;
+      let s2, o2, n$12;
+      const a2 = e2.stack.length >= 1 ? e2.stack[t2 - 1] : void 0, i2 = e2.stack.length >= 2 ? e2.stack[t2 - 2] : void 0;
+      if (t2 >= 3 && typeof a2 == "number" && typeof i2 == "number" ? (n$12 = e2.stack.pop(), o2 = e2.stack.pop(), s2 = e2.stack.pop()) : (o2 = e2.stack.pop(), s2 = e2.stack.pop(), n$12 = void 0), !n(s2))
+        return {
+          type: "RuntimeError",
+          message: "STRING_SLICE requires a string",
+          pc: e2.pc,
+          opcode: r2.op
+        };
+      if (typeof o2 != "number")
+        return {
+          type: "RuntimeError",
+          message: "STRING_SLICE requires numeric start index",
+          pc: e2.pc,
+          opcode: r2.op
+        };
+      const u2 = n$12 !== void 0 ? s2.slice(o2, n$12) : s2.slice(o2);
+      e2.stack.push(u2);
+    }
+  },
+  [i$1.STRING_CHARAT]: {
+    stackIn: 2,
+    stackOut: 1,
+    execute: (e2, r2) => {
+      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
+        };
+      if (typeof t2 != "number")
+        return {
+          type: "RuntimeError",
+          message: "STRING_CHARAT requires numeric index",
+          pc: e2.pc,
+          opcode: r2.op
+        };
+      const o2 = s2.charAt(t2);
+      e2.stack.push(o2);
+    }
+  },
+  [i$1.STRING_TOUPPERCASE]: {
+    stackIn: 1,
+    stackOut: 1,
+    execute: (e2, r2) => {
+      const t2 = e2.stack.pop();
+      if (!n(t2))
+        return {
+          type: "RuntimeError",
+          message: "STRING_TOUPPERCASE requires a string",
+          pc: e2.pc,
+          opcode: r2.op
+        };
+      e2.stack.push(t2.toUpperCase());
+    }
+  },
+  [i$1.STRING_TOLOWERCASE]: {
+    stackIn: 1,
+    stackOut: 1,
+    execute: (e2, r2) => {
+      const t2 = e2.stack.pop();
+      if (!n(t2))
+        return {
+          type: "RuntimeError",
+          message: "STRING_TOLOWERCASE requires a string",
+          pc: e2.pc,
+          opcode: r2.op
+        };
+      e2.stack.push(t2.toLowerCase());
+    }
+  }
+};
+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,
+  ...V,
+  ...M,
+  ...j,
+  ...F,
+  ...D,
+  ...q,
+  ...H,
+  ...Y,
+  ...$,
+  ...B,
+  ...J,
+  ...W
+};
+class N {
+  validateStack(r2, t2, s2) {
+    if (s2.stack.length < r2.stackIn)
+      return {
+        type: "StackUnderflow",
+        message: `${i$1[t2.op]}: Stack underflow`,
+        pc: s2.pc,
+        opcode: t2.op
+      };
+  }
+  execute(r2, t2) {
+    const s2 = {
+      pc: (t2 == null ? void 0 : t2.pc) ?? 0,
+      stack: (t2 == null ? void 0 : t2.stack) ?? [],
+      variables: (t2 == null ? void 0 : t2.variables) ?? /* @__PURE__ */ new Map(),
       status: "running",
-      output: (s2 == null ? void 0 : s2.output) ?? [],
-      iterators: (s2 == null ? void 0 : s2.iterators) ?? [],
-      ...s2
+      output: (t2 == null ? void 0 : t2.output) ?? [],
+      iterators: (t2 == null ? void 0 : t2.iterators) ?? [],
+      ...t2
     };
-    for (; r2.status === "running" && r2.pc < a2.length; ) {
-      const n$1 = a2[r2.pc];
-      switch (n$1.op) {
-        case r$1.HALT:
-          r2.status = "complete";
-          break;
-        case r$1.PUSH:
-          r2.stack.push(n$1.arg), r2.pc++;
-          break;
-        case r$1.PUSH_UNDEFINED:
-          r2.stack.push(s$1()), r2.pc++;
-          break;
-        case r$1.POP:
-          r2.stack.pop(), r2.pc++;
-          break;
-        case r$1.LOAD: {
-          const t2 = n$1.arg;
-          r2.variables.has(t2) ? r2.stack.push(r2.variables.get(t2)) : r2.stack.push(s$1()), r2.pc++;
+    for (; s2.status === "running" && s2.pc < r2.length; ) {
+      const o2 = r2[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;
         }
-        case r$1.STORE:
-          const f$1 = r2.stack.pop();
-          if (f$1 === void 0) {
-            r2.status = "error", r2.error = "STORE: Stack underflow";
-            break;
-          }
-          r2.variables.set(n$1.arg, f$1), r2.pc++;
-          break;
-        case r$1.CONCAT:
-          const u2 = r2.stack.pop(), l2 = r2.stack.pop();
-          if (l2 === void 0 || u2 === void 0) {
-            r2.status = "error", r2.error = "CONCAT: Stack underflow";
-            break;
-          }
-          r2.stack.push(c$1(l2) + c$1(u2)), r2.pc++;
-          break;
-        case r$1.PRINT:
-          const k2 = r2.stack.pop();
-          k2 !== void 0 && r2.output.push(c$1(k2)), r2.pc++;
-          break;
-        case r$1.CC: {
-          const t2 = r2.stack.pop();
-          if (t2 === void 0) {
-            r2.status = "error", r2.error = "CC: Stack underflow";
-            break;
-          }
-          r2.ccPrompt = c$1(t2), r2.status = "waiting_cc";
+        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 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;
         }
-        // Array operations
-        case r$1.ARRAY_NEW:
-          r2.stack.push(p$1()), r2.pc++;
-          break;
-        case r$1.ARRAY_PUSH: {
-          const t2 = r2.stack.pop(), e$1 = r2.stack.pop();
-          if (t2 === void 0 || e$1 === void 0) {
-            r2.status = "error", r2.error = "ARRAY_PUSH: Stack underflow";
-            break;
-          }
-          if (!e(e$1)) {
-            r2.status = "error", r2.error = "ARRAY_PUSH requires an array";
-            break;
-          }
-          e$1.elements.push(t2), r2.stack.push(e$1), r2.pc++;
+        const i2 = n2.execute(s2, o2);
+        if (i2) {
+          s2.status = "error", s2.error = i2.message;
           break;
         }
-        case r$1.ARRAY_GET: {
-          const t$1 = r2.stack.pop(), e$1 = r2.stack.pop();
-          if (t$1 === void 0 || e$1 === void 0) {
-            r2.status = "error", r2.error = "ARRAY_GET: Stack underflow";
-            break;
-          }
-          if (!e(e$1)) {
-            r2.status = "error", r2.error = "ARRAY_GET requires an array";
-            break;
-          }
-          if (!t(t$1)) {
-            r2.status = "error", r2.error = "ARRAY_GET requires numeric index";
-            break;
-          }
-          const o2 = e$1.elements[t$1] ?? null;
-          r2.stack.push(o2), r2.pc++;
-          break;
-        }
-        case r$1.ARRAY_SET: {
-          const t$1 = r2.stack.pop(), e$1 = r2.stack.pop(), o2 = r2.stack.pop();
-          if (t$1 === void 0 || e$1 === void 0 || o2 === void 0) {
-            r2.status = "error", r2.error = "ARRAY_SET: Stack underflow";
-            break;
-          }
-          if (!e(o2)) {
-            r2.status = "error", r2.error = "ARRAY_SET requires an array";
-            break;
-          }
-          if (!t(e$1)) {
-            r2.status = "error", r2.error = "ARRAY_SET requires numeric index";
-            break;
-          }
-          const i2 = Math.floor(e$1);
-          if (i2 < 0) {
-            r2.status = "error", r2.error = "ARRAY_SET: Negative index not allowed";
-            break;
-          }
-          o2.elements[i2] = t$1, r2.pc++;
-          break;
-        }
-        case r$1.ARRAY_LEN: {
-          const t2 = r2.stack.pop();
-          if (t2 === void 0) {
-            r2.status = "error", r2.error = "ARRAY_LEN: Stack underflow";
-            break;
-          }
-          if (!e(t2)) {
-            r2.status = "error", r2.error = "ARRAY_LEN requires an array";
-            break;
-          }
-          r2.stack.push(t2.elements.length), r2.pc++;
-          break;
-        }
-        case r$1.STRING_LEN: {
-          const t2 = r2.stack.pop();
-          if (t2 === void 0) {
-            r2.status = "error", r2.error = "STRING_LEN: Stack underflow";
-            break;
-          }
-          if (!n(t2)) {
-            r2.status = "error", r2.error = "STRING_LEN requires a string";
-            break;
-          }
-          r2.stack.push(t2.length), r2.pc++;
-          break;
-        }
-        case r$1.LENGTH: {
-          const t2 = r2.stack.pop();
-          if (t2 === void 0) {
-            r2.status = "error", r2.error = "LENGTH: Stack underflow";
-            break;
-          }
-          if (n(t2))
-            r2.stack.push(t2.length);
-          else if (e(t2))
-            r2.stack.push(t2.elements.length);
-          else {
-            r2.status = "error", r2.error = "LENGTH requires a string or array";
-            break;
-          }
-          r2.pc++;
-          break;
-        }
-        case r$1.JSON_PARSE: {
-          const t2 = r2.stack.pop();
-          if (t2 === void 0) {
-            r2.status = "error", r2.error = "JSON_PARSE: Stack underflow";
-            break;
-          }
-          if (!n(t2)) {
-            r2.status = "error", r2.error = "JSON_PARSE requires a string";
-            break;
-          }
-          try {
-            const e2 = JSON.parse(t2);
-            Array.isArray(e2) ? r2.stack.push(p$1(e2)) : r2.stack.push(p$1());
-          } catch {
-            r2.stack.push(p$1());
-          }
-          r2.pc++;
-          break;
-        }
-        case r$1.TYPEOF: {
-          const t2 = r2.stack.pop();
-          if (t2 === void 0) {
-            r2.status = "error", r2.error = "TYPEOF: Stack underflow";
-            break;
-          }
-          r2.stack.push(m(t2)), r2.pc++;
-          break;
-        }
-        // Arithmetic operations
-        case r$1.ADD: {
-          const t2 = r2.stack.pop(), e2 = r2.stack.pop();
-          if (e2 === void 0 || t2 === void 0) {
-            r2.status = "error", r2.error = "ADD: Stack underflow";
-            break;
-          }
-          const o2 = d(e2), i2 = d(t2);
-          r2.stack.push(o2 + i2), r2.pc++;
-          break;
-        }
-        case r$1.SUB: {
-          const t2 = r2.stack.pop(), e2 = r2.stack.pop();
-          if (e2 === void 0 || t2 === void 0) {
-            r2.status = "error", r2.error = "SUB: Stack underflow";
-            break;
-          }
-          const o2 = d(e2), i2 = d(t2);
-          r2.stack.push(o2 - i2), r2.pc++;
-          break;
-        }
-        case r$1.MUL: {
-          const t2 = r2.stack.pop(), e2 = r2.stack.pop();
-          if (e2 === void 0 || t2 === void 0) {
-            r2.status = "error", r2.error = "MUL: Stack underflow";
-            break;
-          }
-          const o2 = d(e2), i2 = d(t2);
-          r2.stack.push(o2 * i2), r2.pc++;
-          break;
-        }
-        case r$1.DIV: {
-          const t2 = r2.stack.pop(), e2 = r2.stack.pop();
-          if (e2 === void 0 || t2 === void 0) {
-            r2.status = "error", r2.error = "DIV: Stack underflow";
-            break;
-          }
-          const o2 = d(e2), i2 = d(t2);
-          if (i2 === 0) {
-            r2.status = "error", r2.error = "Division by zero";
-            break;
-          }
-          r2.stack.push(o2 / i2), r2.pc++;
-          break;
-        }
-        case r$1.MOD: {
-          const t2 = r2.stack.pop(), e2 = r2.stack.pop();
-          if (e2 === void 0 || t2 === void 0) {
-            r2.status = "error", r2.error = "MOD: Stack underflow";
-            break;
-          }
-          const o2 = d(e2), i2 = d(t2);
-          r2.stack.push(o2 % i2), r2.pc++;
-          break;
-        }
-        // Unary operations
-        case r$1.UNARY_MINUS: {
-          const t2 = r2.stack.pop();
-          if (t2 === void 0) {
-            r2.status = "error", r2.error = "UNARY_MINUS: Stack underflow";
-            break;
-          }
-          const e2 = d(t2);
-          r2.stack.push(-e2), r2.pc++;
-          break;
-        }
-        case r$1.UNARY_PLUS: {
-          const t2 = r2.stack.pop();
-          if (t2 === void 0) {
-            r2.status = "error", r2.error = "UNARY_PLUS: Stack underflow";
-            break;
-          }
-          const e2 = d(t2);
-          r2.stack.push(e2), r2.pc++;
-          break;
-        }
-        case r$1.INC: {
-          const t2 = r2.stack.pop();
-          if (t2 === void 0 || typeof t2 != "string") {
-            r2.status = "error", r2.error = "INC: Invalid variable name";
-            break;
-          }
-          const e2 = r2.variables.get(t2) ?? 0, o2 = d(e2) + 1;
-          r2.variables.set(t2, o2);
-          const i2 = n$1.arg === true;
-          r2.stack.push(i2 ? d(e2) : o2), r2.pc++;
-          break;
-        }
-        case r$1.DEC: {
-          const t2 = r2.stack.pop();
-          if (t2 === void 0 || typeof t2 != "string") {
-            r2.status = "error", r2.error = "DEC: Invalid variable name";
-            break;
-          }
-          const e2 = r2.variables.get(t2) ?? 0, o2 = d(e2) - 1;
-          r2.variables.set(t2, o2);
-          const i2 = n$1.arg === true;
-          r2.stack.push(i2 ? d(e2) : o2), r2.pc++;
-          break;
-        }
-        // Comparison operations
-        case r$1.EQ: {
-          const t2 = r2.stack.pop(), e2 = r2.stack.pop();
-          if (e2 === void 0 || t2 === void 0) {
-            r2.status = "error", r2.error = "EQ: Stack underflow";
-            break;
-          }
-          if (f(e2) && o(t2) || o(e2) && f(t2))
-            r2.stack.push(true);
-          else if (o(e2) && o(t2))
-            r2.stack.push(true);
-          else {
-            const o2 = d(e2), i2 = d(t2);
-            !isNaN(o2) && !isNaN(i2) ? r2.stack.push(o2 === i2) : r2.stack.push(c$1(e2) === c$1(t2));
-          }
-          r2.pc++;
-          break;
-        }
-        case r$1.NEQ: {
-          const t2 = r2.stack.pop(), e2 = r2.stack.pop();
-          if (e2 === void 0 || t2 === void 0) {
-            r2.status = "error", r2.error = "NEQ: Stack underflow";
-            break;
-          }
-          if (f(e2) && o(t2) || o(e2) && f(t2))
-            r2.stack.push(false);
-          else if (o(e2) && o(t2))
-            r2.stack.push(false);
-          else {
-            const o2 = d(e2), i2 = d(t2);
-            !isNaN(o2) && !isNaN(i2) ? r2.stack.push(o2 !== i2) : r2.stack.push(c$1(e2) !== c$1(t2));
-          }
-          r2.pc++;
-          break;
-        }
-        case r$1.LT: {
-          const t2 = r2.stack.pop(), e2 = r2.stack.pop();
-          if (e2 === void 0 || t2 === void 0) {
-            r2.status = "error", r2.error = "LT: Stack underflow";
-            break;
-          }
-          const o2 = d(e2), i2 = d(t2);
-          r2.stack.push(o2 < i2), r2.pc++;
-          break;
-        }
-        case r$1.GT: {
-          const t2 = r2.stack.pop(), e2 = r2.stack.pop();
-          if (e2 === void 0 || t2 === void 0) {
-            r2.status = "error", r2.error = "GT: Stack underflow";
-            break;
-          }
-          const o2 = d(e2), i2 = d(t2);
-          r2.stack.push(o2 > i2), r2.pc++;
-          break;
-        }
-        case r$1.LTE: {
-          const t2 = r2.stack.pop(), e2 = r2.stack.pop();
-          if (e2 === void 0 || t2 === void 0) {
-            r2.status = "error", r2.error = "LTE: Stack underflow";
-            break;
-          }
-          const o2 = d(e2), i2 = d(t2);
-          r2.stack.push(o2 <= i2), r2.pc++;
-          break;
-        }
-        case r$1.GTE: {
-          const t2 = r2.stack.pop(), e2 = r2.stack.pop();
-          if (e2 === void 0 || t2 === void 0) {
-            r2.status = "error", r2.error = "GTE: Stack underflow";
-            break;
-          }
-          const o2 = d(e2), i2 = d(t2);
-          r2.stack.push(o2 >= i2), r2.pc++;
-          break;
-        }
-        case r$1.EQ_STRICT: {
-          const t2 = r2.stack.pop(), e2 = r2.stack.pop();
-          if (e2 === void 0 || t2 === void 0) {
-            r2.status = "error", r2.error = "EQ_STRICT: Stack underflow";
-            break;
-          }
-          r2.stack.push(e2 === t2), r2.pc++;
-          break;
-        }
-        case r$1.NEQ_STRICT: {
-          const t2 = r2.stack.pop(), e2 = r2.stack.pop();
-          if (e2 === void 0 || t2 === void 0) {
-            r2.status = "error", r2.error = "NEQ_STRICT: Stack underflow";
-            break;
-          }
-          r2.stack.push(e2 !== t2), r2.pc++;
-          break;
-        }
-        // Jump operations
-        case r$1.JUMP: {
-          if (n$1.arg === void 0) {
-            r2.status = "error", r2.error = "JUMP requires a target address";
-            break;
-          }
-          const t2 = n$1.arg;
-          if (t2 < 0 || t2 >= a2.length) {
-            r2.status = "error", r2.error = `Invalid jump target: ${t2}`;
-            break;
-          }
-          r2.pc = t2;
-          break;
-        }
-        case r$1.JUMP_IF_FALSE: {
-          const t2 = r2.stack.pop();
-          if (t2 === void 0) {
-            r2.status = "error", r2.error = "JUMP_IF_FALSE: Stack underflow";
-            break;
-          }
-          if (n$1.arg === void 0) {
-            r2.status = "error", r2.error = "JUMP_IF_FALSE requires a target address";
-            break;
-          }
-          const e2 = n$1.arg;
-          if (e2 < 0 || e2 >= a2.length) {
-            r2.status = "error", r2.error = `Invalid jump target: ${e2}`;
-            break;
-          }
-          y(t2) ? r2.pc++ : r2.pc = e2;
-          break;
-        }
-        case r$1.ITER_START: {
-          if (r2.stack.length === 0) {
-            r2.status = "error", r2.error = "ITER_START: Stack underflow";
-            break;
-          }
-          const t2 = r2.stack.pop();
-          if (t2 == null) {
-            r2.status = "error", r2.error = "TypeError: Cannot iterate over null or undefined";
-            break;
-          }
-          if (!e(t2)) {
-            r2.status = "error", r2.error = "TypeError: Cannot iterate over non-array value";
-            break;
-          }
-          if (r2.iterators.length >= 10) {
-            r2.status = "error", r2.error = "RuntimeError: Maximum iterator depth exceeded";
-            break;
-          }
-          const e$1 = p$1([...t2.elements]);
-          r2.iterators.push({
-            array: e$1,
-            index: 0
-          }), r2.pc++;
-          break;
-        }
-        case r$1.ITER_NEXT: {
-          if (r2.iterators.length === 0) {
-            r2.status = "error", r2.error = "ITER_NEXT: No active iterator";
-            break;
-          }
-          const t2 = r2.iterators[r2.iterators.length - 1];
-          t2.index < t2.array.elements.length ? (r2.stack.push(t2.array.elements[t2.index]), r2.stack.push(true), t2.index++) : (r2.stack.push(null), r2.stack.push(false)), r2.pc++;
-          break;
-        }
-        case r$1.ITER_END: {
-          if (r2.iterators.length === 0) {
-            r2.status = "error", r2.error = "ITER_END: No active iterator";
-            break;
-          }
-          r2.iterators.pop(), r2.pc++;
-          break;
-        }
-        // Logical operators
-        case r$1.AND: {
-          const t2 = r2.stack.pop(), e2 = r2.stack.pop();
-          if (e2 === void 0 || t2 === void 0) {
-            r2.status = "error", r2.error = "AND: Stack underflow";
-            break;
-          }
-          y(e2) ? r2.stack.push(t2) : r2.stack.push(e2), r2.pc++;
-          break;
-        }
-        case r$1.OR: {
-          const t2 = r2.stack.pop(), e2 = r2.stack.pop();
-          if (e2 === void 0 || t2 === void 0) {
-            r2.status = "error", r2.error = "OR: Stack underflow";
-            break;
-          }
-          y(e2) ? r2.stack.push(e2) : r2.stack.push(t2), r2.pc++;
-          break;
-        }
-        case r$1.NOT: {
-          const t2 = r2.stack.pop();
-          if (t2 === void 0) {
-            r2.status = "error", r2.error = "NOT: Stack underflow";
-            break;
-          }
-          r2.stack.push(!y(t2)), r2.pc++;
-          break;
-        }
-        case r$1.RETURN: {
-          const t2 = r2.stack.pop() ?? null;
-          r2.returnValue = t2, r2.status = "complete";
-          break;
-        }
-        // String methods
-        case r$1.STRING_SUBSTRING: {
-          if (r2.stack.length < 2) {
-            r2.status = "error", r2.error = "STRING_SUBSTRING: Stack underflow";
-            break;
-          }
-          const t2 = r2.stack.length;
-          let e2, o2, i2;
-          const w2 = r2.stack[t2 - 1], _ = r2.stack[t2 - 2];
-          if (t2 >= 3 && typeof w2 == "number" && typeof _ == "number" ? (i2 = r2.stack.pop(), o2 = r2.stack.pop(), e2 = r2.stack.pop()) : (o2 = r2.stack.pop(), e2 = r2.stack.pop(), i2 = void 0), !n(e2)) {
-            r2.status = "error", r2.error = "STRING_SUBSTRING requires a string";
-            break;
-          }
-          if (typeof o2 != "number") {
-            r2.status = "error", r2.error = "STRING_SUBSTRING requires numeric start index";
-            break;
-          }
-          const S = e2.length;
-          o2 < 0 && (o2 = Math.max(0, S + o2)), i2 !== void 0 && i2 < 0 && (i2 = Math.max(0, S + i2));
-          const O = i2 !== void 0 ? e2.substring(o2, i2) : e2.substring(o2);
-          r2.stack.push(O), r2.pc++;
-          break;
-        }
-        case r$1.STRING_INDEXOF: {
-          const t2 = r2.stack.pop(), e2 = r2.stack.pop();
-          if (t2 === void 0 || e2 === void 0) {
-            r2.status = "error", r2.error = "STRING_INDEXOF: Stack underflow";
-            break;
-          }
-          if (!n(e2) || !n(t2)) {
-            r2.status = "error", r2.error = "STRING_INDEXOF requires string arguments";
-            break;
-          }
-          r2.stack.push(e2.indexOf(t2)), r2.pc++;
-          break;
-        }
-        case r$1.STRING_SPLIT: {
-          const t2 = r2.stack.pop(), e2 = r2.stack.pop();
-          if (t2 === void 0 || e2 === void 0) {
-            r2.status = "error", r2.error = "STRING_SPLIT: Stack underflow";
-            break;
-          }
-          if (!n(e2) || !n(t2)) {
-            r2.status = "error", r2.error = "STRING_SPLIT requires string arguments";
-            break;
-          }
-          let o2;
-          t2 === "" ? o2 = e2.split("") : o2 = e2.split(t2), r2.stack.push(p$1(o2)), r2.pc++;
-          break;
-        }
-        case r$1.STRING_SLICE: {
-          if (r2.stack.length < 2) {
-            r2.status = "error", r2.error = "STRING_SLICE: Stack underflow";
-            break;
-          }
-          const t2 = r2.stack.length;
-          let e2, o2, i2;
-          const w2 = r2.stack[t2 - 1], _ = r2.stack[t2 - 2];
-          if (t2 >= 3 && typeof w2 == "number" && typeof _ == "number" ? (i2 = r2.stack.pop(), o2 = r2.stack.pop(), e2 = r2.stack.pop()) : (o2 = r2.stack.pop(), e2 = r2.stack.pop(), i2 = void 0), !n(e2)) {
-            r2.status = "error", r2.error = "STRING_SLICE requires a string";
-            break;
-          }
-          if (typeof o2 != "number") {
-            r2.status = "error", r2.error = "STRING_SLICE requires numeric start index";
-            break;
-          }
-          const S = i2 !== void 0 ? e2.slice(o2, i2) : e2.slice(o2);
-          r2.stack.push(S), r2.pc++;
-          break;
-        }
-        case r$1.STRING_CHARAT: {
-          const t2 = r2.stack.pop(), e2 = r2.stack.pop();
-          if (t2 === void 0 || e2 === void 0) {
-            r2.status = "error", r2.error = "STRING_CHARAT: Stack underflow";
-            break;
-          }
-          if (!n(e2)) {
-            r2.status = "error", r2.error = "STRING_CHARAT requires a string";
-            break;
-          }
-          if (typeof t2 != "number") {
-            r2.status = "error", r2.error = "STRING_CHARAT requires numeric index";
-            break;
-          }
-          const o2 = e2.charAt(t2);
-          r2.stack.push(o2), r2.pc++;
-          break;
-        }
-        case r$1.STRING_TOUPPERCASE: {
-          const t2 = r2.stack.pop();
-          if (t2 === void 0) {
-            r2.status = "error", r2.error = "STRING_TOUPPERCASE: Stack underflow";
-            break;
-          }
-          if (!n(t2)) {
-            r2.status = "error", r2.error = "STRING_TOUPPERCASE requires a string";
-            break;
-          }
-          r2.stack.push(t2.toUpperCase()), r2.pc++;
-          break;
-        }
-        case r$1.STRING_TOLOWERCASE: {
-          const t2 = r2.stack.pop();
-          if (t2 === void 0) {
-            r2.status = "error", r2.error = "STRING_TOLOWERCASE: Stack underflow";
-            break;
-          }
-          if (!n(t2)) {
-            r2.status = "error", r2.error = "STRING_TOLOWERCASE requires a string";
-            break;
-          }
-          r2.stack.push(t2.toLowerCase()), r2.pc++;
-          break;
-        }
-        case r$1.BREAK: {
-          if (n$1.arg === void 0) {
-            r2.status = "error", r2.error = "BREAK requires a target address";
-            break;
-          }
-          const t2 = n$1.arg;
-          if (t2 < 0 || t2 >= a2.length) {
-            r2.status = "error", r2.error = `Invalid break target: ${t2}`;
-            break;
-          }
-          r2.pc = t2;
-          break;
-        }
-        case r$1.CONTINUE: {
-          if (n$1.arg === void 0) {
-            r2.status = "error", r2.error = "CONTINUE requires a target address";
-            break;
-          }
-          const t2 = n$1.arg;
-          if (t2 < 0 || t2 >= a2.length) {
-            r2.status = "error", r2.error = `Invalid continue target: ${t2}`;
-            break;
-          }
-          r2.pc = t2;
-          break;
-        }
-        case r$1.FS_LIST_FILES: {
-          if (r2.stack.length < 1) {
-            r2.status = "error", r2.error = "FS_LIST_FILES: Stack underflow";
-            break;
-          }
-          let t2, e$1 = {};
-          const o2 = r2.stack[r2.stack.length - 1];
-          if (r2.stack.length >= 2 && typeof o2 == "object" && o2 !== null && !e(o2) && (e$1 = r2.stack.pop()), t2 = r2.stack.pop(), !n(t2)) {
-            r2.status = "error", r2.error = "FS_LIST_FILES requires a string path";
-            break;
-          }
-          r2.fsOperation = {
-            type: "listFiles",
-            path: t2,
-            options: e$1
-          }, r2.status = "waiting_fs";
-          break;
-        }
-        default:
-          r2.status = "error", r2.error = `Unknown opcode: ${n$1.op} (type: ${typeof n$1.op})`;
+        n2.controlsPC || s2.pc++;
+        continue;
       }
+      s2.status = "error", s2.error = `Unknown opcode: ${i$1[o2.op]}`;
+      break;
     }
-    return r2;
+    return s2;
   }
-  resume(a2, s2, r2) {
-    if (a2.status !== "waiting_cc")
+  resume(r2, t2, s2) {
+    if (r2.status !== "waiting_cc")
       throw new Error("Cannot resume: VM not waiting for CC");
-    const n2 = {
-      ...a2,
-      stack: [...a2.stack, s2],
+    const o2 = {
+      ...r2,
+      stack: [...r2.stack, t2],
       status: "running",
       ccPrompt: void 0,
-      pc: a2.pc + 1
+      pc: r2.pc + 1
     };
-    return this.execute(r2, n2);
+    return this.execute(s2, o2);
   }
-  resumeWithFsResult(a2, s2, r2) {
-    if (a2.status !== "waiting_fs")
+  resumeWithFsResult(r2, t2, s2) {
+    if (r2.status !== "waiting_fs")
       throw new Error("Cannot resume: VM not waiting for FS operation");
-    const n2 = {
-      ...a2,
-      stack: [...a2.stack, s2],
+    const o2 = {
+      ...r2,
+      stack: [...r2.stack, t2],
       status: "running",
       fsOperation: void 0,
-      pc: a2.pc + 1
+      pc: r2.pc + 1
     };
-    return this.execute(r2, n2);
+    return this.execute(s2, o2);
   }
 }
-class P {
+class A2 {
   constructor() {
-    N2(this, "sandboxPaths", []);
-    const a2 = process.env.CVM_SANDBOX_PATHS, s2 = process.env.CVM_SANDBOX_ROOT;
-    a2 ? this.sandboxPaths = a2.split(",").map((r2) => c__namespace.resolve(r2.trim())) : s2 && (this.sandboxPaths = [c__namespace.resolve(s2)]);
-  }
-  isPathAllowed(a2) {
-    const s2 = c__namespace.resolve(a2);
-    return s2.includes("..") || this.sandboxPaths.length === 0 ? false : this.sandboxPaths.some(
-      (r2) => s2.startsWith(r2)
+    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)]);
+  }
+  isPathAllowed(r2) {
+    const t2 = c__namespace.resolve(r2);
+    return t2.includes("..") || this.sandboxPaths.length === 0 ? false : this.sandboxPaths.some(
+      (s2) => t2.startsWith(s2)
     );
   }
-  listFiles(a2, s2 = {}) {
-    const r2 = p$1();
-    if (!this.isPathAllowed(a2))
-      return r2;
+  listFiles(r2, t2 = {}) {
+    const s2 = d();
+    if (!this.isPathAllowed(r2))
+      return s2;
     try {
-      const n2 = c__namespace.resolve(a2);
-      this.listFilesRecursive(n2, n2, r2.elements, s2);
+      const o2 = c__namespace.resolve(r2);
+      this.listFilesRecursive(o2, o2, s2.elements, t2);
     } catch {
     }
-    return r2;
+    return s2;
   }
-  matchesPattern(a2, s2) {
-    let r2 = s2.replace(/\./g, "\\.").replace(/\*\*/g, "__DOUBLESTAR__").replace(/\*/g, "[^/]*").replace(/__DOUBLESTAR__/g, ".*").replace(/\?/g, ".");
-    r2 = "^" + r2 + "$";
+  matchesPattern(r2, t2) {
+    let s2 = t2.replace(/\./g, "\\.").replace(/\*\*/g, "__DOUBLESTAR__").replace(/\*/g, "[^/]*").replace(/__DOUBLESTAR__/g, ".*").replace(/\?/g, ".");
+    s2 = "^" + s2 + "$";
     try {
-      return new RegExp(r2).test(a2);
+      return new RegExp(s2).test(r2);
     } catch {
       return true;
     }
   }
-  listFilesRecursive(a2, s2, r2, n2, f2 = 0) {
+  listFilesRecursive(r2, t2, s2, o2, n2 = 0) {
     try {
-      const u2 = M__namespace.readdirSync(s2, { withFileTypes: true });
-      for (const l2 of u2) {
-        const k2 = c__namespace.join(s2, l2.name), t2 = c__namespace.relative(a2, k2);
-        l2.isSymbolicLink() || n2.filter && !this.matchesPattern(t2, n2.filter) || (r2.push(k2), l2.isDirectory() && n2.recursive && this.listFilesRecursive(a2, k2, r2, n2, f2 + 1));
+      const a2 = G__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));
       }
     } catch {
     }
   }
 }
-new P();
-class $ {
-  constructor(a2, s2) {
-    N2(this, "vms", /* @__PURE__ */ new Map());
-    N2(this, "storage");
-    N2(this, "fileSystem");
-    a2 ? this.storage = a2 : this.storage = g.create(), this.fileSystem = s2 || new P();
+new A2();
+class te {
+  constructor(r2, 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();
   }
   /**
    * Initialize the VMManager (connect to database)
@@ -1352,152 +1743,152 @@ class $ {
   /**
    * Load and compile a program from source code
    */
-  async loadProgram(a2, s2) {
-    const r2 = k(s2);
-    if (!r2.success)
-      throw new Error(`Compilation failed: ${r2.errors.join(", ")}`);
-    const n2 = {
-      id: a2,
-      name: a2,
-      source: s2,
-      bytecode: r2.bytecode,
+  async loadProgram(r2, t2) {
+    const s2 = W$1(t2);
+    if (!s2.success)
+      throw new Error(`Compilation failed: ${s2.errors.join(", ")}`);
+    const o2 = {
+      id: r2,
+      name: r2,
+      source: t2,
+      bytecode: s2.bytecode,
       // VM decides internal format
       created: /* @__PURE__ */ new Date()
     };
-    await this.storage.saveProgram(n2);
+    await this.storage.saveProgram(o2);
   }
   /**
    * Start execution of a loaded program
    */
-  async startExecution(a2, s2) {
-    if (!await this.storage.getProgram(a2))
-      throw new Error(`Program not found: ${a2}`);
-    const n2 = {
-      id: s2,
-      programId: a2,
+  async startExecution(r2, t2) {
+    if (!await this.storage.getProgram(r2))
+      throw new Error(`Program not found: ${r2}`);
+    const o2 = {
+      id: t2,
+      programId: r2,
       state: "READY",
       pc: 0,
       stack: [],
       variables: {},
       created: /* @__PURE__ */ new Date()
     };
-    await this.storage.saveExecution(n2);
-    const f2 = new A();
-    this.vms.set(s2, f2);
+    await this.storage.saveExecution(o2);
+    const n2 = new N();
+    this.vms.set(t2, n2);
   }
   /**
    * Get next action from execution (Claude polls this)
    * This is READ-ONLY - just returns current state
    */
-  async getNext(a2) {
-    const s2 = await this.storage.getExecution(a2);
-    if (!s2)
-      throw new Error(`Execution not found: ${a2}`);
-    if (s2.state === "READY") {
-      const r2 = await this.storage.getProgram(s2.programId);
-      if (!r2)
-        throw new Error(`Program not found: ${s2.programId}`);
-      let n2 = this.vms.get(a2);
-      n2 || (n2 = new A(), this.vms.set(a2, n2));
-      const f2 = {
+  async getNext(r2) {
+    const t2 = await this.storage.getExecution(r2);
+    if (!t2)
+      throw new Error(`Execution not found: ${r2}`);
+    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));
+      const n2 = {
         pc: 0,
         stack: [],
         variables: /* @__PURE__ */ new Map(),
         output: []
-      }, u2 = n2.execute(r2.bytecode, f2);
-      if (u2.output.length > 0 && await this.storage.appendOutput(a2, u2.output), s2.pc = u2.pc, s2.stack = u2.stack, s2.variables = Object.fromEntries(u2.variables), s2.iterators = u2.iterators, u2.status === "complete")
-        return s2.state = "COMPLETED", u2.returnValue !== void 0 && (s2.returnValue = u2.returnValue), await this.storage.saveExecution(s2), this.vms.delete(a2), {
+      }, 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",
           message: "Execution completed",
-          result: u2.returnValue
+          result: a2.returnValue
         };
-      if (u2.status === "waiting_cc")
-        return s2.state = "AWAITING_COGNITIVE_RESULT", s2.ccPrompt = u2.ccPrompt, await this.storage.saveExecution(s2), {
+      if (a2.status === "waiting_cc")
+        return t2.state = "AWAITING_COGNITIVE_RESULT", t2.ccPrompt = a2.ccPrompt, await this.storage.saveExecution(t2), {
           type: "waiting",
-          message: u2.ccPrompt || "Waiting for input"
+          message: a2.ccPrompt || "Waiting for input"
         };
-      if (u2.status === "waiting_fs") {
-        if (u2.fsOperation) {
-          const l2 = this.fileSystem.listFiles(u2.fsOperation.path, u2.fsOperation.options), k2 = n2.resumeWithFsResult(u2, l2, r2.bytecode);
-          return k2.output.length > 0 && await this.storage.appendOutput(a2, k2.output), s2.pc = k2.pc, s2.stack = k2.stack, s2.variables = Object.fromEntries(k2.variables), s2.iterators = k2.iterators, k2.status === "complete" ? (s2.state = "COMPLETED", k2.returnValue !== void 0 && (s2.returnValue = k2.returnValue), await this.storage.saveExecution(s2), this.vms.delete(a2), {
+      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), {
             type: "completed",
             message: "Execution completed",
-            result: k2.returnValue
-          }) : k2.status === "error" ? (s2.state = "ERROR", s2.error = k2.error, await this.storage.saveExecution(s2), this.vms.delete(a2), {
+            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: k2.error
-          }) : k2.status === "waiting_cc" ? (s2.state = "AWAITING_COGNITIVE_RESULT", s2.ccPrompt = k2.ccPrompt, await this.storage.saveExecution(s2), {
+            error: u2.error
+          }) : u2.status === "waiting_cc" ? (t2.state = "AWAITING_COGNITIVE_RESULT", t2.ccPrompt = u2.ccPrompt, await this.storage.saveExecution(t2), {
             type: "waiting",
-            message: k2.ccPrompt || "Waiting for input"
-          }) : (s2.state = "RUNNING", await this.storage.saveExecution(s2), this.getNext(a2));
+            message: u2.ccPrompt || "Waiting for input"
+          }) : (t2.state = "RUNNING", await this.storage.saveExecution(t2), this.getNext(r2));
         }
-      } else if (u2.status === "error")
-        return s2.state = "ERROR", s2.error = u2.error, await this.storage.saveExecution(s2), this.vms.delete(a2), {
+      } else if (a2.status === "error")
+        return t2.state = "ERROR", t2.error = a2.error, await this.storage.saveExecution(t2), this.vms.delete(r2), {
           type: "error",
-          error: u2.error
+          error: a2.error
         };
     }
-    if (s2.state === "COMPLETED")
+    if (t2.state === "COMPLETED")
       return {
         type: "completed",
         message: "Execution completed"
       };
-    if (s2.state === "ERROR")
+    if (t2.state === "ERROR")
       return {
         type: "error",
-        error: s2.error || "Unknown error"
+        error: t2.error || "Unknown error"
       };
-    if (s2.state === "AWAITING_COGNITIVE_RESULT")
+    if (t2.state === "AWAITING_COGNITIVE_RESULT")
       return {
         type: "waiting",
-        message: s2.ccPrompt || "Waiting for input"
+        message: t2.ccPrompt || "Waiting for input"
       };
-    throw new Error(`Unexpected execution state: ${s2.state}`);
+    throw new Error(`Unexpected execution state: ${t2.state}`);
   }
   /**
    * Report result from cognitive operation and continue execution
    */
-  async reportCCResult(a2, s2) {
-    const r2 = await this.storage.getExecution(a2);
-    if (!r2)
-      throw new Error(`Execution not found: ${a2}`);
-    const n2 = await this.storage.getProgram(r2.programId);
-    if (!n2)
-      throw new Error(`Program not found: ${r2.programId}`);
-    let f2 = this.vms.get(a2);
-    f2 || (f2 = new A(), this.vms.set(a2, f2));
-    const u2 = {
-      pc: r2.pc,
-      stack: r2.stack,
-      variables: new Map(Object.entries(r2.variables)),
+  async reportCCResult(r2, t2) {
+    const s2 = await this.storage.getExecution(r2);
+    if (!s2)
+      throw new Error(`Execution not found: ${r2}`);
+    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));
+    const a2 = {
+      pc: s2.pc,
+      stack: s2.stack,
+      variables: new Map(Object.entries(s2.variables)),
       status: "waiting_cc",
       output: [],
       // Start with empty output for resumed execution
       ccPrompt: void 0,
-      iterators: r2.iterators || []
-    }, l2 = f2.resume(u2, s2, n2.bytecode);
-    l2.output.length > 0 && await this.storage.appendOutput(a2, l2.output), r2.pc = l2.pc, r2.stack = l2.stack, r2.variables = Object.fromEntries(l2.variables), r2.iterators = l2.iterators, l2.status === "complete" ? (r2.state = "COMPLETED", l2.returnValue !== void 0 && (r2.returnValue = l2.returnValue), this.vms.delete(a2)) : l2.status === "error" ? (r2.state = "ERROR", r2.error = l2.error, this.vms.delete(a2)) : l2.status === "waiting_cc" ? (r2.state = "AWAITING_COGNITIVE_RESULT", r2.ccPrompt = l2.ccPrompt) : r2.state = "RUNNING", await this.storage.saveExecution(r2);
+      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);
   }
   /**
    * Get current execution status
    */
-  async getExecutionStatus(a2) {
-    const s2 = await this.storage.getExecution(a2);
-    if (!s2)
-      throw new Error(`Execution not found: ${a2}`);
+  async getExecutionStatus(r2) {
+    const t2 = await this.storage.getExecution(r2);
+    if (!t2)
+      throw new Error(`Execution not found: ${r2}`);
     return {
-      id: s2.id,
-      state: s2.state,
-      pc: s2.pc,
-      stack: s2.stack,
-      variables: s2.variables
+      id: t2.id,
+      state: t2.state,
+      pc: t2.pc,
+      stack: t2.stack,
+      variables: t2.variables
     };
   }
   /**
    * Get output for an execution
    */
-  async getExecutionOutput(a2) {
-    return await this.storage.getOutput(a2);
+  async getExecutionOutput(r2) {
+    return await this.storage.getOutput(r2);
   }
 }
 var a = Object.defineProperty;
@@ -1509,7 +1900,7 @@ class w {
     s(this, "transport", null);
     s(this, "vmManager");
     s(this, "version");
-    this.version = r2, this.vmManager = new $(), 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();
@@ -1763,7 +2154,7 @@ async function main() {
     ];
     for (const packageJsonPath of possiblePaths) {
       try {
-        const packageJson = JSON.parse(M.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;