cvm-server 0.6.0 → 0.8.0

package/main.cjs

@@ -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 P$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 P__namespace = /* @__PURE__ */ _interopNamespaceDefault(P$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 f$1 = Object.defineProperty;
+var p$2 = (e2, t2, i2) => t2 in e2 ? f$1(e2, t2, { enumerable: true, configurable: true, writable: true, value: i2 }) : e2[t2] = i2;
+var m$2 = (e2, t2, i2) => p$2(e2, typeof t2 != "symbol" ? t2 + "" : t2, i2);
+var s$2 = /* @__PURE__ */ ((e2) => (e2.PUSH = "PUSH", e2.PUSH_UNDEFINED = "PUSH_UNDEFINED", e2.POP = "POP", e2.LOAD = "LOAD", e2.STORE = "STORE", e2.CONCAT = "CONCAT", e2.ARRAY_NEW = "ARRAY_NEW", e2.ARRAY_PUSH = "ARRAY_PUSH", e2.ARRAY_GET = "ARRAY_GET", e2.ARRAY_SET = "ARRAY_SET", e2.ARRAY_LEN = "ARRAY_LEN", e2.STRING_LEN = "STRING_LEN", e2.STRING_SUBSTRING = "STRING_SUBSTRING", e2.STRING_INDEXOF = "STRING_INDEXOF", e2.STRING_SPLIT = "STRING_SPLIT", e2.STRING_SLICE = "STRING_SLICE", e2.STRING_CHARAT = "STRING_CHARAT", e2.STRING_TOUPPERCASE = "STRING_TOUPPERCASE", e2.STRING_TOLOWERCASE = "STRING_TOLOWERCASE", e2.LENGTH = "LENGTH", e2.JSON_PARSE = "JSON_PARSE", e2.TYPEOF = "TYPEOF", e2.ADD = "ADD", e2.SUB = "SUB", e2.MUL = "MUL", e2.DIV = "DIV", e2.MOD = "MOD", e2.UNARY_MINUS = "UNARY_MINUS", e2.UNARY_PLUS = "UNARY_PLUS", e2.INC = "INC", e2.DEC = "DEC", e2.EQ = "EQ", e2.NEQ = "NEQ", e2.LT = "LT", e2.GT = "GT", e2.LTE = "LTE", e2.GTE = "GTE", e2.EQ_STRICT = "EQ_STRICT", e2.NEQ_STRICT = "NEQ_STRICT", e2.JUMP = "JUMP", e2.JUMP_IF = "JUMP_IF", e2.JUMP_IF_FALSE = "JUMP_IF_FALSE", e2.JUMP_IF_TRUE = "JUMP_IF_TRUE", e2.CALL = "CALL", e2.RETURN = "RETURN", e2.AND = "AND", e2.OR = "OR", e2.NOT = "NOT", e2.BREAK = "BREAK", e2.CONTINUE = "CONTINUE", e2.ITER_START = "ITER_START", e2.ITER_NEXT = "ITER_NEXT", e2.ITER_END = "ITER_END", e2.FS_LIST_FILES = "FS_LIST_FILES", e2.CC = "CC", e2.PRINT = "PRINT", e2.HALT = "HALT", e2))(s$2 || {});
+function A(e2) {
+  const t2 = [], i2 = [];
+  let r2 = false, a2 = false;
+  const l2 = 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 S(o2) {
+    if (n__namespace.isFunctionDeclaration(o2) && o2.name && o2.name.text === "main" && (r2 = true, o2.parameters.length > 0 && t2.push("main() must not have parameters")), n__namespace.isExpressionStatement(o2) && o2.parent === l2) {
+      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, S);
   }
-  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 S(l2), r2 || t2.push("Program must have a main() function"), r2 && !a2 && t2.push("main() must be called at the top level"), t2.length === 0 && i2.push({ op: s$2.HALT }), {
+    bytecode: i2,
+    errors: t2,
+    hasMain: r2
   };
 }
-let N$1 = class N {
+class R {
   constructor() {
-    u$1(this, "bytecode", []);
-    u$1(this, "contextStack", []);
+    m$2(this, "bytecode", []);
+    m$2(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, i2) {
+    const r2 = this.bytecode.length;
+    return this.bytecode.push({ op: t2, arg: i2 }), 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, i2) {
+    t2 >= 0 && t2 < this.bytecode.length && (this.bytecode[t2].arg = i2);
   }
   /**
    * Patch multiple jump instructions with the same target
    */
-  patchJumps(l2, e2) {
-    l2.forEach((o2) => this.patchJump(o2, e2));
+  patchJumps(t2, i2) {
+    t2.forEach((r2) => this.patchJump(r2, i2));
   }
   /**
    * 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 i2 = this.contextStack[t2];
+      if (i2.type === "loop" || i2.type === "foreach")
+        return i2;
+    }
     return null;
   }
   /**
@@ -135,281 +137,333 @@ let N$1 = class N {
   getUnclosedContexts() {
     return [...this.contextStack];
   }
+}
+const h$1 = (e2, t2, { compileExpression: i2, compileStatement: r2 }) => {
+  i2(e2.expression);
+  const a2 = t2.emit(s$2.JUMP_IF_FALSE, -1), l2 = {
+    type: "if",
+    endTargets: []
+  };
+  if (e2.elseStatement ? l2.elseTarget = a2 : l2.endTargets.push(a2), t2.pushContext(l2), r2(e2.thenStatement), e2.elseStatement) {
+    const o2 = t2.emit(s$2.JUMP, -1);
+    l2.endTargets.push(o2);
+    const c2 = t2.currentAddress();
+    t2.patchJump(a2, c2), r2(e2.elseStatement);
+  }
+  const S = t2.popContext();
+  if (S) {
+    const o2 = t2.currentAddress();
+    t2.patchJumps(S.endTargets, o2);
+  }
+}, I = (e2, t2, { compileExpression: i2, compileStatement: r2 }) => {
+  const a2 = t2.currentAddress();
+  i2(e2.expression);
+  const S = {
+    type: "loop",
+    breakTargets: [t2.emit(s$2.JUMP_IF_FALSE, -1)],
+    continueTargets: [],
+    endTargets: [],
+    startAddress: a2
+  };
+  t2.pushContext(S), r2(e2.statement), t2.emit(s$2.JUMP, a2);
+  const o2 = t2.popContext();
+  if (o2) {
+    const c2 = t2.currentAddress();
+    t2.patchJumps(o2.breakTargets || [], c2);
+  }
+}, y$1 = (e2, t2, { compileExpression: i2, compileStatement: r2 }) => {
+  const a2 = e2.initializer, l2 = e2.expression;
+  let S;
+  if (n__namespace.isVariableDeclarationList(a2))
+    S = a2.declarations[0].name.getText();
+  else if (n__namespace.isIdentifier(a2))
+    S = a2.text;
+  else
+    throw new Error("Unsupported for-of variable declaration");
+  i2(l2), t2.emit(s$2.ITER_START);
+  const o2 = t2.currentAddress();
+  t2.emit(s$2.ITER_NEXT);
+  const c2 = t2.emit(s$2.JUMP_IF_FALSE, -1);
+  t2.emit(s$2.STORE, S);
+  const x2 = {
+    type: "foreach",
+    breakTargets: [c2],
+    continueTargets: [],
+    endTargets: [],
+    startAddress: o2,
+    iterVariable: S
+  };
+  t2.pushContext(x2), r2(e2.statement), t2.emit(s$2.JUMP, o2);
+  const u2 = t2.popContext();
+  if (u2) {
+    const E2 = t2.currentAddress();
+    t2.patchJumps(u2.breakTargets || [], E2), t2.emit(s$2.ITER_END);
+  }
+}, N$1 = (e2, t2, { compileStatement: i2 }) => {
+  e2.statements.forEach((r2) => {
+    i2(r2);
+  });
+}, g$1 = (e2, t2, { compileExpression: i2 }) => {
+  const r2 = e2.declarationList.declarations[0];
+  r2.initializer && (i2(r2.initializer), t2.emit(s$2.STORE, r2.name.getText()));
+}, P = (e2, t2, { compileExpression: i2 }) => {
+  const r2 = e2.expression;
+  if (n__namespace.isBinaryExpression(r2)) {
+    const a2 = r2.operatorToken.kind;
+    if (a2 === n__namespace.SyntaxKind.PlusEqualsToken || a2 === n__namespace.SyntaxKind.MinusEqualsToken || a2 === n__namespace.SyntaxKind.AsteriskEqualsToken || a2 === n__namespace.SyntaxKind.SlashEqualsToken || a2 === n__namespace.SyntaxKind.PercentEqualsToken) {
+      if (n__namespace.isIdentifier(r2.left)) {
+        switch (t2.emit(s$2.LOAD, r2.left.text), i2(r2.right), a2) {
+          case n__namespace.SyntaxKind.PlusEqualsToken:
+            n__namespace.isStringLiteral(r2.right) ? t2.emit(s$2.CONCAT) : t2.emit(s$2.ADD);
+            break;
+          case n__namespace.SyntaxKind.MinusEqualsToken:
+            t2.emit(s$2.SUB);
+            break;
+          case n__namespace.SyntaxKind.AsteriskEqualsToken:
+            t2.emit(s$2.MUL);
+            break;
+          case n__namespace.SyntaxKind.SlashEqualsToken:
+            t2.emit(s$2.DIV);
+            break;
+          case n__namespace.SyntaxKind.PercentEqualsToken:
+            t2.emit(s$2.MOD);
+            break;
+        }
+        t2.emit(s$2.STORE, r2.left.text);
+      } else if (n__namespace.isElementAccessExpression(r2.left))
+        throw new Error("Compound assignment to array elements not yet supported");
+      return;
+    } else if (a2 === n__namespace.SyntaxKind.EqualsToken) {
+      if (i2(r2.right), n__namespace.isIdentifier(r2.left))
+        t2.emit(s$2.STORE, r2.left.text);
+      else if (n__namespace.isElementAccessExpression(r2.left)) {
+        const l2 = `__temp_${t2.getBytecode().length}`;
+        t2.emit(s$2.STORE, l2), i2(r2.left.expression), i2(r2.left.argumentExpression), t2.emit(s$2.LOAD, l2), t2.emit(s$2.ARRAY_SET);
+      }
+      return;
+    }
+  }
+  n__namespace.isCallExpression(r2) && n__namespace.isPropertyAccessExpression(r2.expression) && r2.expression.expression.getText() === "console" && r2.expression.name.getText() === "log" ? (r2.arguments.forEach((a2) => {
+    i2(a2);
+  }), t2.emit(s$2.PRINT)) : n__namespace.isCallExpression(r2) && n__namespace.isIdentifier(r2.expression) && r2.expression.text === "CC" ? (r2.arguments.length > 0 && i2(r2.arguments[0]), t2.emit(s$2.CC), t2.emit(s$2.POP)) : n__namespace.isCallExpression(r2) && n__namespace.isPropertyAccessExpression(r2.expression) && r2.expression.name.getText() === "push" ? (i2(r2.expression.expression), r2.arguments.length > 0 && i2(r2.arguments[0]), t2.emit(s$2.ARRAY_PUSH)) : (n__namespace.isPostfixUnaryExpression(r2) || n__namespace.isPrefixUnaryExpression(r2)) && (i2(r2), t2.emit(s$2.POP));
+}, k = (e2, t2, { compileExpression: i2 }) => {
+  e2.expression ? i2(e2.expression) : t2.emit(s$2.PUSH, null), t2.emit(s$2.RETURN);
+}, _ = (e2, t2, i2) => {
+  const r2 = t2.findLoopContext();
+  if (r2) {
+    r2.type === "foreach" && t2.emit(s$2.ITER_END);
+    const a2 = t2.emit(s$2.BREAK, -1);
+    r2.breakTargets = r2.breakTargets || [], r2.breakTargets.push(a2);
+  } else
+    throw new Error("break statement not in loop");
+}, U$1 = (e2, t2, i2) => {
+  const r2 = t2.findLoopContext();
+  if (r2 && r2.startAddress !== void 0) {
+    const a2 = t2.emit(s$2.CONTINUE, r2.startAddress);
+    r2.continueTargets = r2.continueTargets || [], r2.continueTargets.push(a2);
+  } else
+    throw new Error("continue statement not in loop");
+}, L$1 = {
+  [n__namespace.SyntaxKind.IfStatement]: h$1,
+  [n__namespace.SyntaxKind.WhileStatement]: I,
+  [n__namespace.SyntaxKind.ForOfStatement]: y$1,
+  [n__namespace.SyntaxKind.Block]: N$1,
+  [n__namespace.SyntaxKind.VariableStatement]: g$1,
+  [n__namespace.SyntaxKind.ExpressionStatement]: P,
+  [n__namespace.SyntaxKind.ReturnStatement]: k,
+  [n__namespace.SyntaxKind.BreakStatement]: _,
+  [n__namespace.SyntaxKind.ContinueStatement]: U$1
+}, d$1 = (e2, t2, i2) => {
+  t2.emit(s$2.PUSH, e2.text);
+}, K = (e2, t2, i2) => {
+  t2.emit(s$2.PUSH, Number(e2.text));
+}, b$1 = (e2, t2, i2) => {
+  t2.emit(s$2.PUSH, true);
+}, F$1 = (e2, t2, i2) => {
+  t2.emit(s$2.PUSH, false);
+}, D$1 = (e2, t2, i2) => {
+  t2.emit(s$2.PUSH, null);
+}, G$1 = (e2, t2, i2) => {
+  e2.text === "undefined" ? t2.emit(s$2.PUSH_UNDEFINED) : t2.emit(s$2.LOAD, e2.text);
+}, M$1 = (e2, t2, { compileExpression: i2 }) => {
+  t2.emit(s$2.ARRAY_NEW), e2.elements.forEach((r2) => {
+    i2(r2), t2.emit(s$2.ARRAY_PUSH);
+  });
+}, H$1 = (e2, t2, { compileExpression: i2 }) => {
+  i2(e2.expression);
+}, C$1 = (e2, t2, { compileExpression: i2 }) => {
+  e2.name.text === "length" && (i2(e2.expression), t2.emit(s$2.LENGTH));
+}, J = (e2, t2, { compileExpression: i2 }) => {
+  i2(e2.expression), e2.argumentExpression && i2(e2.argumentExpression), t2.emit(s$2.ARRAY_GET);
+}, w$2 = (e2, t2, { compileExpression: i2 }) => {
+  switch (e2.operator) {
+    case n__namespace.SyntaxKind.ExclamationToken:
+      i2(e2.operand), t2.emit(s$2.NOT);
+      break;
+    case n__namespace.SyntaxKind.MinusToken:
+      i2(e2.operand), t2.emit(s$2.UNARY_MINUS);
+      break;
+    case n__namespace.SyntaxKind.PlusToken:
+      i2(e2.operand), t2.emit(s$2.UNARY_PLUS);
+      break;
+    case n__namespace.SyntaxKind.PlusPlusToken:
+      n__namespace.isIdentifier(e2.operand) && (t2.emit(s$2.PUSH, e2.operand.text), t2.emit(s$2.INC, false));
+      break;
+    case n__namespace.SyntaxKind.MinusMinusToken:
+      n__namespace.isIdentifier(e2.operand) && (t2.emit(s$2.PUSH, e2.operand.text), t2.emit(s$2.DEC, false));
+      break;
+  }
+}, B = (e2, t2, { compileExpression: i2 }) => {
+  switch (e2.operator) {
+    case n__namespace.SyntaxKind.PlusPlusToken:
+      n__namespace.isIdentifier(e2.operand) && (t2.emit(s$2.PUSH, e2.operand.text), t2.emit(s$2.INC, true));
+      break;
+    case n__namespace.SyntaxKind.MinusMinusToken:
+      n__namespace.isIdentifier(e2.operand) && (t2.emit(s$2.PUSH, e2.operand.text), t2.emit(s$2.DEC, true));
+      break;
+  }
 };
-function k(n2) {
-  const l2 = I(n2);
-  if (l2.errors.length > 0)
+function T$1(e2, t2) {
+  return !!(n__namespace.isStringLiteral(e2) || n__namespace.isStringLiteral(t2) || n__namespace.isBinaryExpression(e2) && e2.operatorToken.kind === n__namespace.SyntaxKind.PlusToken && T$1(e2.left, e2.right) || n__namespace.isBinaryExpression(t2) && t2.operatorToken.kind === n__namespace.SyntaxKind.PlusToken && T$1(t2.left, t2.right));
+}
+const Y$1 = (e2, t2, { compileExpression: i2 }) => {
+  const r2 = e2.operatorToken.kind;
+  switch (i2(e2.left), i2(e2.right), r2) {
+    case n__namespace.SyntaxKind.PlusToken:
+      T$1(e2.left, e2.right) ? t2.emit(s$2.CONCAT) : t2.emit(s$2.ADD);
+      break;
+    case n__namespace.SyntaxKind.MinusToken:
+      t2.emit(s$2.SUB);
+      break;
+    case n__namespace.SyntaxKind.AsteriskToken:
+      t2.emit(s$2.MUL);
+      break;
+    case n__namespace.SyntaxKind.SlashToken:
+      t2.emit(s$2.DIV);
+      break;
+    case n__namespace.SyntaxKind.PercentToken:
+      t2.emit(s$2.MOD);
+      break;
+    case n__namespace.SyntaxKind.EqualsEqualsToken:
+      t2.emit(s$2.EQ);
+      break;
+    case n__namespace.SyntaxKind.ExclamationEqualsToken:
+      t2.emit(s$2.NEQ);
+      break;
+    case n__namespace.SyntaxKind.LessThanToken:
+      t2.emit(s$2.LT);
+      break;
+    case n__namespace.SyntaxKind.GreaterThanToken:
+      t2.emit(s$2.GT);
+      break;
+    case n__namespace.SyntaxKind.LessThanEqualsToken:
+      t2.emit(s$2.LTE);
+      break;
+    case n__namespace.SyntaxKind.GreaterThanEqualsToken:
+      t2.emit(s$2.GTE);
+      break;
+    case n__namespace.SyntaxKind.EqualsEqualsEqualsToken:
+      t2.emit(s$2.EQ_STRICT);
+      break;
+    case n__namespace.SyntaxKind.ExclamationEqualsEqualsToken:
+      t2.emit(s$2.NEQ_STRICT);
+      break;
+    case n__namespace.SyntaxKind.AmpersandAmpersandToken:
+      t2.emit(s$2.AND);
+      break;
+    case n__namespace.SyntaxKind.BarBarToken:
+      t2.emit(s$2.OR);
+      break;
+  }
+}, q$1 = (e2, t2, { compileExpression: i2 }) => {
+  i2(e2.condition);
+  const r2 = t2.emit(s$2.JUMP_IF_FALSE, -1);
+  i2(e2.whenTrue);
+  const a2 = t2.emit(s$2.JUMP, -1), l2 = t2.currentAddress();
+  t2.patchJump(r2, l2), i2(e2.whenFalse);
+  const S = t2.currentAddress();
+  t2.patchJump(a2, S);
+}, Q = (e2, t2, { compileExpression: i2 }) => {
+  i2(e2.expression), t2.emit(s$2.TYPEOF);
+}, V$1 = (e2, t2, { compileExpression: i2 }) => {
+  if (n__namespace.isPropertyAccessExpression(e2.expression) && n__namespace.isIdentifier(e2.expression.expression) && e2.expression.expression.text === "fs" && e2.expression.name.text === "listFiles")
+    e2.arguments.length > 0 ? i2(e2.arguments[0]) : t2.emit(s$2.PUSH, "."), e2.arguments.length > 1 && i2(e2.arguments[1]), t2.emit(s$2.FS_LIST_FILES);
+  else if (n__namespace.isPropertyAccessExpression(e2.expression) && n__namespace.isIdentifier(e2.expression.expression) && e2.expression.expression.text === "JSON" && e2.expression.name.text === "parse")
+    e2.arguments.length > 0 && i2(e2.arguments[0]), t2.emit(s$2.JSON_PARSE);
+  else if (n__namespace.isIdentifier(e2.expression) && e2.expression.text === "CC")
+    e2.arguments.length > 0 && i2(e2.arguments[0]), t2.emit(s$2.CC);
+  else if (n__namespace.isPropertyAccessExpression(e2.expression)) {
+    const r2 = e2.expression.name.text;
+    if (r2 === "substring")
+      i2(e2.expression.expression), e2.arguments.length > 0 ? i2(e2.arguments[0]) : t2.emit(s$2.PUSH, 0), e2.arguments.length > 1 && i2(e2.arguments[1]), t2.emit(s$2.STRING_SUBSTRING);
+    else if (r2 === "indexOf")
+      i2(e2.expression.expression), e2.arguments.length > 0 ? i2(e2.arguments[0]) : t2.emit(s$2.PUSH, ""), t2.emit(s$2.STRING_INDEXOF);
+    else if (r2 === "split")
+      i2(e2.expression.expression), e2.arguments.length > 0 ? i2(e2.arguments[0]) : t2.emit(s$2.PUSH, ""), t2.emit(s$2.STRING_SPLIT);
+    else if (r2 === "slice")
+      i2(e2.expression.expression), e2.arguments.length > 0 ? i2(e2.arguments[0]) : t2.emit(s$2.PUSH, 0), e2.arguments.length > 1 && i2(e2.arguments[1]), t2.emit(s$2.STRING_SLICE);
+    else if (r2 === "charAt")
+      i2(e2.expression.expression), e2.arguments.length > 0 ? i2(e2.arguments[0]) : t2.emit(s$2.PUSH, 0), t2.emit(s$2.STRING_CHARAT);
+    else if (r2 === "toUpperCase")
+      i2(e2.expression.expression), t2.emit(s$2.STRING_TOUPPERCASE);
+    else if (r2 === "toLowerCase")
+      i2(e2.expression.expression), t2.emit(s$2.STRING_TOLOWERCASE);
+    else
+      throw new Error(`Method call '${r2}' is not supported`);
+  } else
+    throw new Error("Unsupported call expression");
+}, v = {
+  [n__namespace.SyntaxKind.StringLiteral]: d$1,
+  [n__namespace.SyntaxKind.NumericLiteral]: K,
+  [n__namespace.SyntaxKind.TrueKeyword]: b$1,
+  [n__namespace.SyntaxKind.FalseKeyword]: F$1,
+  [n__namespace.SyntaxKind.NullKeyword]: D$1,
+  [n__namespace.SyntaxKind.Identifier]: G$1,
+  [n__namespace.SyntaxKind.ArrayLiteralExpression]: M$1,
+  [n__namespace.SyntaxKind.BinaryExpression]: Y$1,
+  [n__namespace.SyntaxKind.PrefixUnaryExpression]: w$2,
+  [n__namespace.SyntaxKind.PostfixUnaryExpression]: B,
+  [n__namespace.SyntaxKind.CallExpression]: V$1,
+  [n__namespace.SyntaxKind.PropertyAccessExpression]: C$1,
+  [n__namespace.SyntaxKind.ElementAccessExpression]: J,
+  [n__namespace.SyntaxKind.ConditionalExpression]: q$1,
+  [n__namespace.SyntaxKind.TypeOfExpression]: Q,
+  [n__namespace.SyntaxKind.ParenthesizedExpression]: H$1
+};
+function j(e2) {
+  const t2 = A(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 i2 = new R(), r2 = n__namespace.createSourceFile("program.ts", e2, n__namespace.ScriptTarget.Latest, true), a2 = {
+    compileStatement: l2,
+    compileExpression: S,
+    reportError: (o2, c2) => {
+      throw new Error(c2);
+    }
+  };
+  function l2(o2) {
+    const c2 = L$1[o2.kind];
+    c2 && c2(o2, i2, a2);
+  }
+  function S(o2) {
+    const c2 = v[o2.kind];
+    c2 && c2(o2, i2, a2);
+  }
+  return r2.forEachChild((o2) => {
+    var c2;
+    n__namespace.isFunctionDeclaration(o2) && ((c2 = o2.name) == null ? void 0 : c2.text) === "main" && o2.body && o2.body.statements.forEach((x2) => {
+      l2(x2);
     });
-  }), e2.emit(r$1.HALT), {
+  }), i2.emit(s$2.HALT), {
     success: true,
-    bytecode: e2.getBytecode(),
+    bytecode: i2.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";
 }
@@ -434,7 +488,7 @@ function c$1(r2) {
 function y(r2) {
   return i(r2) ? r2 : f(r2) || o(r2) ? false : t(r2) ? r2 !== 0 : n(r2) ? r2 !== "" : e(r2) ? true : !!r2;
 }
-function m(r2) {
+function m$1(r2) {
   return n(r2) ? "string" : t(r2) ? "number" : i(r2) ? "boolean" : f(r2) ? "null" : o(r2) ? "undefined" : e(r2) ? "array" : "unknown";
 }
 function d(r2) {
@@ -466,7 +520,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 P$1.promises.mkdir(this.dataDir, { recursive: true }), await P$1.promises.mkdir(this.programsDir, { recursive: true }), await P$1.promises.mkdir(this.executionsDir, { recursive: true }), await P$1.promises.mkdir(this.outputsDir, { recursive: true }), this.connected = true;
   }
   async disconnect() {
     this.connected = false;
@@ -477,13 +531,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 P$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 P$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 +548,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 P$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 P$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 +567,13 @@ class h {
     const e2 = c__namespace.join(this.outputsDir, `${t2}.output`), o2 = n2.join(`
 `) + `
 `;
-    await M.promises.appendFile(e2, o2, "utf-8");
+    await P$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 P$1.promises.readFile(n2, "utf-8")).split(`
 `).filter((o2) => o2.length > 0);
     } catch (e2) {
       if (e2.code === "ENOENT")
@@ -606,736 +660,924 @@ class g {
     }
   }
 }
-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(),
+var T = Object.defineProperty;
+var w$1 = (e2, r2, t2) => r2 in e2 ? T(e2, r2, { enumerable: true, configurable: true, writable: true, value: t2 }) : e2[r2] = t2;
+var E = (e2, r2, t2) => w$1(e2, typeof r2 != "symbol" ? r2 + "" : r2, t2);
+const C = {
+  [s$2.ADD]: {
+    stackIn: 2,
+    stackOut: 1,
+    execute: (e2) => {
+      const r2 = e2.stack.pop(), t2 = e2.stack.pop(), s2 = d(t2), c2 = d(r2);
+      e2.stack.push(s2 + c2);
+    }
+  },
+  [s$2.SUB]: {
+    stackIn: 2,
+    stackOut: 1,
+    execute: (e2) => {
+      const r2 = e2.stack.pop(), t2 = e2.stack.pop(), s2 = d(t2), c2 = d(r2);
+      e2.stack.push(s2 - c2);
+    }
+  },
+  [s$2.MUL]: {
+    stackIn: 2,
+    stackOut: 1,
+    execute: (e2) => {
+      const r2 = e2.stack.pop(), t2 = e2.stack.pop(), s2 = d(t2), c2 = d(r2);
+      e2.stack.push(s2 * c2);
+    }
+  },
+  [s$2.DIV]: {
+    stackIn: 2,
+    stackOut: 1,
+    execute: (e2, r2) => {
+      const t2 = e2.stack.pop(), s2 = e2.stack.pop(), c2 = d(s2), n2 = d(t2);
+      if (n2 === 0)
+        return {
+          type: "DivisionByZero",
+          message: "Division by zero",
+          pc: e2.pc,
+          opcode: r2.op
+        };
+      e2.stack.push(c2 / n2);
+    }
+  },
+  [s$2.MOD]: {
+    stackIn: 2,
+    stackOut: 1,
+    execute: (e2) => {
+      const r2 = e2.stack.pop(), t2 = e2.stack.pop(), s2 = d(t2), c2 = d(r2);
+      e2.stack.push(s2 % c2);
+    }
+  },
+  [s$2.UNARY_MINUS]: {
+    stackIn: 1,
+    stackOut: 1,
+    execute: (e2) => {
+      const r2 = e2.stack.pop(), t2 = d(r2);
+      e2.stack.push(-t2);
+    }
+  },
+  [s$2.UNARY_PLUS]: {
+    stackIn: 1,
+    stackOut: 1,
+    execute: (e2) => {
+      const r2 = e2.stack.pop(), t2 = d(r2);
+      e2.stack.push(t2);
+    }
+  }
+}, b = {
+  [s$2.PUSH]: {
+    stackIn: 0,
+    stackOut: 1,
+    execute: (e2, r2) => {
+      e2.stack.push(r2.arg);
+    }
+  },
+  [s$2.PUSH_UNDEFINED]: {
+    stackIn: 0,
+    stackOut: 1,
+    execute: (e2) => {
+      e2.stack.push(s$1());
+    }
+  },
+  [s$2.POP]: {
+    stackIn: 1,
+    stackOut: 0,
+    execute: (e2) => {
+      e2.stack.pop();
+    }
+  }
+}, U = {
+  [s$2.PRINT]: {
+    stackIn: 1,
+    stackOut: 0,
+    execute: (e2) => {
+      const r2 = e2.stack.pop();
+      r2 !== void 0 && e2.output.push(c$1(r2));
+    }
+  },
+  [s$2.CC]: {
+    stackIn: 1,
+    stackOut: 0,
+    controlsPC: true,
+    // CC pauses execution
+    execute: (e2, r2) => {
+      const t2 = e2.stack.pop();
+      e2.ccPrompt = c$1(t2), e2.status = "waiting_cc";
+    }
+  }
+}, G = {
+  [s$2.HALT]: {
+    stackIn: 0,
+    stackOut: 0,
+    controlsPC: true,
+    execute: (e2) => {
+      e2.status = "complete";
+    }
+  },
+  [s$2.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;
+    }
+  },
+  [s$2.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
+        };
+      y(t2) ? e2.pc++ : e2.pc = s2;
+    }
+  }
+}, L = {
+  [s$2.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());
+    }
+  },
+  [s$2.STORE]: {
+    stackIn: 1,
+    stackOut: 0,
+    execute: (e2, r2) => {
+      const t2 = e2.stack.pop();
+      e2.variables.set(r2.arg, t2);
+    }
+  }
+}, M = {
+  [s$2.ITER_START]: {
+    stackIn: 1,
+    stackOut: 0,
+    execute: (e$1, r2) => {
+      const t2 = e$1.stack.pop();
+      if (t2 == null)
+        return {
+          type: "TypeError",
+          message: "TypeError: Cannot iterate over null or undefined",
+          pc: e$1.pc,
+          opcode: r2.op
+        };
+      if (!e(t2))
+        return {
+          type: "TypeError",
+          message: "TypeError: Cannot iterate over non-array value",
+          pc: e$1.pc,
+          opcode: r2.op
+        };
+      if (e$1.iterators.length >= 10)
+        return {
+          type: "RuntimeError",
+          message: "RuntimeError: Maximum iterator depth exceeded",
+          pc: e$1.pc,
+          opcode: r2.op
+        };
+      e$1.iterators.push({
+        array: t2,
+        index: 0,
+        length: t2.elements.length
+      });
+    }
+  },
+  [s$2.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));
+    }
+  },
+  [s$2.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 m(e2, r2, t2) {
+  const s2 = e2.stack.pop(), c2 = e2.stack.pop(), n2 = t2(c2, s2);
+  e2.stack.push(n2);
+}
+const V = {
+  [s$2.EQ]: {
+    stackIn: 2,
+    stackOut: 1,
+    execute: (e2, r2) => m(e2, r2, (t2, s2) => {
+      if (f(t2) && o(s2) || o(t2) && f(s2))
+        return true;
+      if (o(t2) && o(s2))
+        return true;
+      {
+        const c2 = d(t2), n2 = d(s2);
+        return !isNaN(c2) && !isNaN(n2) ? c2 === n2 : c$1(t2) === c$1(s2);
+      }
+    })
+  },
+  [s$2.NEQ]: {
+    stackIn: 2,
+    stackOut: 1,
+    execute: (e2, r2) => m(e2, r2, (t2, s2) => {
+      if (f(t2) && o(s2) || o(t2) && f(s2))
+        return false;
+      if (o(t2) && o(s2))
+        return false;
+      {
+        const c2 = d(t2), n2 = d(s2);
+        return !isNaN(c2) && !isNaN(n2) ? c2 !== n2 : c$1(t2) !== c$1(s2);
+      }
+    })
+  },
+  [s$2.LT]: {
+    stackIn: 2,
+    stackOut: 1,
+    execute: (e2, r2) => m(e2, r2, (t2, s2) => {
+      const c2 = d(t2), n2 = d(s2);
+      return c2 < n2;
+    })
+  },
+  [s$2.GT]: {
+    stackIn: 2,
+    stackOut: 1,
+    execute: (e2, r2) => m(e2, r2, (t2, s2) => {
+      const c2 = d(t2), n2 = d(s2);
+      return c2 > n2;
+    })
+  },
+  [s$2.LTE]: {
+    stackIn: 2,
+    stackOut: 1,
+    execute: (e2, r2) => m(e2, r2, (t2, s2) => {
+      const c2 = d(t2), n2 = d(s2);
+      return c2 <= n2;
+    })
+  },
+  [s$2.GTE]: {
+    stackIn: 2,
+    stackOut: 1,
+    execute: (e2, r2) => m(e2, r2, (t2, s2) => {
+      const c2 = d(t2), n2 = d(s2);
+      return c2 >= n2;
+    })
+  },
+  [s$2.EQ_STRICT]: {
+    stackIn: 2,
+    stackOut: 1,
+    execute: (e2, r2) => m(e2, r2, (t2, s2) => t2 === s2)
+  },
+  [s$2.NEQ_STRICT]: {
+    stackIn: 2,
+    stackOut: 1,
+    execute: (e2, r2) => m(e2, r2, (t2, s2) => t2 !== s2)
+  }
+}, F = {
+  [s$2.AND]: {
+    stackIn: 2,
+    stackOut: 1,
+    execute: (e2, r2) => {
+      const t2 = e2.stack.pop(), s2 = e2.stack.pop(), c2 = y(s2) ? t2 : s2;
+      e2.stack.push(c2);
+    }
+  },
+  [s$2.OR]: {
+    stackIn: 2,
+    stackOut: 1,
+    execute: (e2, r2) => {
+      const t2 = e2.stack.pop(), s2 = e2.stack.pop(), c2 = y(s2) ? s2 : t2;
+      e2.stack.push(c2);
+    }
+  },
+  [s$2.NOT]: {
+    stackIn: 1,
+    stackOut: 1,
+    execute: (e2, r2) => {
+      const t2 = e2.stack.pop(), s2 = !y(t2);
+      e2.stack.push(s2);
+    }
+  }
+}, D = {
+  [s$2.ARRAY_NEW]: {
+    stackIn: 0,
+    stackOut: 1,
+    execute: (e2, r2) => {
+      e2.stack.push(p$1());
+    }
+  },
+  [s$2.ARRAY_PUSH]: {
+    stackIn: 2,
+    stackOut: 1,
+    execute: (e$1, r2) => {
+      const t2 = e$1.stack.pop(), s2 = e$1.stack.pop();
+      if (!e(s2))
+        return {
+          type: "RuntimeError",
+          message: "ARRAY_PUSH requires an array",
+          pc: e$1.pc,
+          opcode: r2.op
+        };
+      s2.elements.push(t2), e$1.stack.push(s2);
+    }
+  },
+  [s$2.ARRAY_GET]: {
+    stackIn: 2,
+    stackOut: 1,
+    execute: (e$1, r2) => {
+      const t$1 = e$1.stack.pop(), s2 = e$1.stack.pop();
+      if (!e(s2))
+        return {
+          type: "RuntimeError",
+          message: "ARRAY_GET requires an array",
+          pc: e$1.pc,
+          opcode: r2.op
+        };
+      if (!t(t$1))
+        return {
+          type: "RuntimeError",
+          message: "ARRAY_GET requires numeric index",
+          pc: e$1.pc,
+          opcode: r2.op
+        };
+      const c2 = s2.elements[t$1] ?? null;
+      e$1.stack.push(c2);
+    }
+  },
+  [s$2.ARRAY_SET]: {
+    stackIn: 3,
+    stackOut: 0,
+    execute: (e$1, r2) => {
+      const t$1 = e$1.stack.pop(), s2 = e$1.stack.pop(), c2 = e$1.stack.pop();
+      if (!e(c2))
+        return {
+          type: "RuntimeError",
+          message: "ARRAY_SET requires an array",
+          pc: e$1.pc,
+          opcode: r2.op
+        };
+      if (!t(s2))
+        return {
+          type: "RuntimeError",
+          message: "ARRAY_SET requires numeric index",
+          pc: e$1.pc,
+          opcode: r2.op
+        };
+      const n2 = Math.floor(s2);
+      if (n2 < 0)
+        return {
+          type: "RuntimeError",
+          message: "ARRAY_SET: Negative index not allowed",
+          pc: e$1.pc,
+          opcode: r2.op
+        };
+      c2.elements[n2] = t$1;
+    }
+  },
+  [s$2.ARRAY_LEN]: {
+    stackIn: 1,
+    stackOut: 1,
+    execute: (e$1, r2) => {
+      const t2 = e$1.stack.pop();
+      if (!e(t2))
+        return {
+          type: "RuntimeError",
+          message: "ARRAY_LEN requires an array",
+          pc: e$1.pc,
+          opcode: r2.op
+        };
+      e$1.stack.push(t2.elements.length);
+    }
+  }
+}, q = {
+  [s$2.CONCAT]: {
+    stackIn: 2,
+    stackOut: 1,
+    execute: (e2, r2) => {
+      const t2 = e2.stack.pop(), s2 = e2.stack.pop();
+      e2.stack.push(c$1(s2) + c$1(t2));
+    }
+  },
+  [s$2.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);
+    }
+  },
+  [s$2.LENGTH]: {
+    stackIn: 1,
+    stackOut: 1,
+    execute: (e$1, r2) => {
+      const t2 = e$1.stack.pop();
+      if (n(t2))
+        e$1.stack.push(t2.length);
+      else if (e(t2))
+        e$1.stack.push(t2.elements.length);
+      else
+        return {
+          type: "RuntimeError",
+          message: "LENGTH requires a string or array",
+          pc: e$1.pc,
+          opcode: r2.op
+        };
+    }
+  },
+  [s$2.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);
+        Array.isArray(s2) ? e2.stack.push(p$1(s2)) : e2.stack.push(p$1());
+      } catch {
+        e2.stack.push(p$1());
+      }
+    }
+  },
+  [s$2.TYPEOF]: {
+    stackIn: 1,
+    stackOut: 1,
+    execute: (e2, r2) => {
+      const t2 = e2.stack.pop();
+      e2.stack.push(m$1(t2));
+    }
+  }
+}, H = {
+  [s$2.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, c2 = d(s2) + 1;
+      e2.variables.set(t2, c2);
+      const n2 = r2.arg === true;
+      e2.stack.push(n2 ? d(s2) : c2);
+    }
+  },
+  [s$2.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, c2 = d(s2) - 1;
+      e2.variables.set(t2, c2);
+      const n2 = r2.arg === true;
+      e2.stack.push(n2 ? d(s2) : c2);
+    }
+  }
+}, Y = {
+  [s$2.RETURN]: {
+    stackIn: 0,
+    stackOut: 0,
+    controlsPC: true,
+    execute: (e2, r2) => {
+      const t2 = e2.stack.pop() ?? null;
+      e2.returnValue = t2, e2.status = "complete";
+    }
+  },
+  [s$2.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;
+    }
+  },
+  [s$2.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;
+    }
+  },
+  [s$2.FS_LIST_FILES]: {
+    stackIn: 1,
+    // Minimum 1 argument (path), optionally 2 (path + options)
+    stackOut: 0,
+    controlsPC: true,
+    execute: (e$1, r2) => {
+      if (e$1.stack.length < 1)
+        return {
+          type: "StackUnderflow",
+          message: "FS_LIST_FILES: Stack underflow",
+          pc: e$1.pc,
+          opcode: r2.op
+        };
+      let t2, s2 = {};
+      const c2 = e$1.stack[e$1.stack.length - 1];
+      if (e$1.stack.length >= 2 && typeof c2 == "object" && c2 !== null && !e(c2) && (s2 = e$1.stack.pop()), t2 = e$1.stack.pop(), !n(t2))
+        return {
+          type: "RuntimeError",
+          message: "FS_LIST_FILES requires a string path",
+          pc: e$1.pc,
+          opcode: r2.op
+        };
+      e$1.fsOperation = {
+        type: "listFiles",
+        path: t2,
+        options: s2
+      }, e$1.status = "waiting_fs";
+    }
+  },
+  // String method handlers
+  [s$2.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, c2, n$12;
+      const a2 = e2.stack[t2 - 1], i2 = e2.stack[t2 - 2];
+      if (t2 >= 3 && typeof a2 == "number" && typeof i2 == "number" ? (n$12 = e2.stack.pop(), c2 = e2.stack.pop(), s2 = e2.stack.pop()) : (c2 = e2.stack.pop(), s2 = e2.stack.pop(), n$12 = void 0), !n(s2))
+        return {
+          type: "RuntimeError",
+          message: "STRING_SUBSTRING requires a string",
+          pc: e2.pc,
+          opcode: r2.op
+        };
+      if (typeof c2 != "number")
+        return {
+          type: "RuntimeError",
+          message: "STRING_SUBSTRING requires numeric start index",
+          pc: e2.pc,
+          opcode: r2.op
+        };
+      const p2 = s2.length;
+      c2 < 0 && (c2 = Math.max(0, p2 + c2)), n$12 !== void 0 && n$12 < 0 && (n$12 = Math.max(0, p2 + n$12));
+      const I2 = n$12 !== void 0 ? s2.substring(c2, n$12) : s2.substring(c2);
+      e2.stack.push(I2);
+    }
+  },
+  [s$2.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));
+    }
+  },
+  [s$2.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 c2;
+      t2 === "" ? c2 = s2.split("") : c2 = s2.split(t2), e2.stack.push(p$1(c2));
+    }
+  },
+  [s$2.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, c2, n$12;
+      const a2 = e2.stack.length >= 1 ? e2.stack[t2 - 1] : void 0, i2 = e2.stack.length >= 2 ? e2.stack[t2 - 2] : void 0;
+      if (t2 >= 3 && typeof a2 == "number" && typeof i2 == "number" ? (n$12 = e2.stack.pop(), c2 = e2.stack.pop(), s2 = e2.stack.pop()) : (c2 = e2.stack.pop(), s2 = e2.stack.pop(), n$12 = void 0), !n(s2))
+        return {
+          type: "RuntimeError",
+          message: "STRING_SLICE requires a string",
+          pc: e2.pc,
+          opcode: r2.op
+        };
+      if (typeof c2 != "number")
+        return {
+          type: "RuntimeError",
+          message: "STRING_SLICE requires numeric start index",
+          pc: e2.pc,
+          opcode: r2.op
+        };
+      const p2 = n$12 !== void 0 ? s2.slice(c2, n$12) : s2.slice(c2);
+      e2.stack.push(p2);
+    }
+  },
+  [s$2.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 c2 = s2.charAt(t2);
+      e2.stack.push(c2);
+    }
+  },
+  [s$2.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());
+    }
+  },
+  [s$2.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());
+    }
+  }
+}, $ = {
+  ...C,
+  ...b,
+  ...U,
+  ...G,
+  ...L,
+  ...M,
+  ...V,
+  ...F,
+  ...D,
+  ...q,
+  ...H,
+  ...Y
+};
+class N {
+  validateStack(r2, t2, s2) {
+    if (s2.stack.length < r2.stackIn)
+      return {
+        type: "StackUnderflow",
+        message: `${s$2[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++;
-          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";
-          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++;
-          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++;
+    for (; s2.status === "running" && s2.pc < r2.length; ) {
+      const c2 = r2[s2.pc], n2 = $[c2.op];
+      if (n2) {
+        const a2 = this.validateStack(n2, c2, s2);
+        if (a2) {
+          s2.status = "error", s2.error = a2.message;
           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++;
+        if ((c2.op === s$2.JUMP || c2.op === s$2.JUMP_IF_FALSE || c2.op === s$2.BREAK || c2.op === s$2.CONTINUE) && c2.arg !== void 0 && c2.arg >= r2.length) {
+          s2.status = "error";
+          const p2 = c2.op === s$2.JUMP || c2.op === s$2.JUMP_IF_FALSE ? "jump" : c2.op === s$2.BREAK ? "break" : "continue";
+          s2.error = `Invalid ${p2} target: ${c2.arg}`;
           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;
+        const i2 = n2.execute(s2, c2);
+        if (i2) {
+          s2.status = "error", s2.error = i2.message;
           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: ${s$2[c2.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 c2 = {
+      ...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, c2);
   }
-  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 c2 = {
+      ...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, c2);
   }
 }
-class P {
+class x {
   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)
+    E(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 = p$1();
+    if (!this.isPathAllowed(r2))
+      return s2;
     try {
-      const n2 = c__namespace.resolve(a2);
-      this.listFilesRecursive(n2, n2, r2.elements, s2);
+      const c2 = c__namespace.resolve(r2);
+      this.listFilesRecursive(c2, c2, 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, c2, 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 = P__namespace.readdirSync(t2, { withFileTypes: true });
+      for (const i2 of a2) {
+        const p2 = c__namespace.join(t2, i2.name), I2 = c__namespace.relative(r2, p2);
+        i2.isSymbolicLink() || c2.filter && !this.matchesPattern(I2, c2.filter) || (s2.push(p2), i2.isDirectory() && c2.recursive && this.listFilesRecursive(r2, p2, s2, c2, n2 + 1));
       }
     } 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 x();
+class X {
+  constructor(r2, t2) {
+    E(this, "vms", /* @__PURE__ */ new Map());
+    E(this, "storage");
+    E(this, "fileSystem");
+    r2 ? this.storage = r2 : this.storage = g.create(), this.fileSystem = t2 || new x();
   }
   /**
    * Initialize the VMManager (connect to database)
@@ -1352,153 +1594,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 = j(t2);
+    if (!s2.success)
+      throw new Error(`Compilation failed: ${s2.errors.join(", ")}`);
+    const c2 = {
+      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(c2);
   }
   /**
    * 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 c2 = {
+      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(c2);
+    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 c2 = this.vms.get(r2);
+      c2 || (c2 = new N(), this.vms.set(r2, c2));
+      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), 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 = c2.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), 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), p2 = c2.resumeWithFsResult(a2, i2, s2.bytecode);
+          return p2.output.length > 0 && await this.storage.appendOutput(r2, p2.output), t2.pc = p2.pc, t2.stack = p2.stack, t2.variables = Object.fromEntries(p2.variables), t2.iterators = p2.iterators, p2.status === "complete" ? (t2.state = "COMPLETED", p2.returnValue !== void 0 && (t2.returnValue = p2.returnValue), await this.storage.saveExecution(t2), this.vms.delete(r2), {
             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: p2.returnValue
+          }) : p2.status === "error" ? (t2.state = "ERROR", t2.error = p2.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: p2.error
+          }) : p2.status === "waiting_cc" ? (t2.state = "AWAITING_COGNITIVE_RESULT", t2.ccPrompt = p2.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: p2.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 c2 = await this.storage.getProgram(s2.programId);
+    if (!c2)
+      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: []
-      // TODO: persist iterators in future
-    }, 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), 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, c2.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;
@@ -1510,7 +1751,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 X(), this.server = new mcp_js.McpServer({
       name: "cvm-server",
       version: this.version
     }), this.setupTools();
@@ -1764,7 +2005,7 @@ async function main() {
     ];
     for (const packageJsonPath of possiblePaths) {
       try {
-        const packageJson = JSON.parse(M.readFileSync(packageJsonPath, "utf-8"));
+        const packageJson = JSON.parse(P$1.readFileSync(packageJsonPath, "utf-8"));
         if (packageJson.name === "cvm-server" && packageJson.version) {
           version = packageJson.version;
           break;