cvm-server 0.4.3 → 0.5.0

package/main.cjs

@@ -9,66 +9,66 @@ const mongodb = require("mongodb");
 const dotenv = require("dotenv");
 const url = require("url");
 var _documentCurrentScript = typeof document !== "undefined" ? document.currentScript : null;
-function _interopNamespaceDefault(e) {
+function _interopNamespaceDefault(e2) {
   const n2 = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
-  if (e) {
-    for (const k2 in e) {
+  if (e2) {
+    for (const k2 in e2) {
       if (k2 !== "default") {
-        const d = Object.getOwnPropertyDescriptor(e, k2);
-        Object.defineProperty(n2, k2, d.get ? d : {
+        const d2 = Object.getOwnPropertyDescriptor(e2, k2);
+        Object.defineProperty(n2, k2, d2.get ? d2 : {
           enumerable: true,
-          get: () => e[k2]
+          get: () => e2[k2]
         });
       }
     }
   }
-  n2.default = e;
+  n2.default = e2;
   return Object.freeze(n2);
 }
 const s__namespace = /* @__PURE__ */ _interopNamespaceDefault(s$1);
 const c__namespace = /* @__PURE__ */ _interopNamespaceDefault(c$1);
 const dotenv__namespace = /* @__PURE__ */ _interopNamespaceDefault(dotenv);
-var S = Object.defineProperty;
-var p$1 = (i2, a2, e) => a2 in i2 ? S(i2, a2, { enumerable: true, configurable: true, writable: true, value: e }) : i2[a2] = e;
-var E$1 = (i2, a2, e) => p$1(i2, typeof a2 != "symbol" ? a2 + "" : a2, e);
-var n$1 = /* @__PURE__ */ ((i2) => (i2.PUSH = "PUSH", i2.POP = "POP", i2.LOAD = "LOAD", i2.STORE = "STORE", i2.CONCAT = "CONCAT", i2.ARRAY_NEW = "ARRAY_NEW", i2.ARRAY_PUSH = "ARRAY_PUSH", i2.ARRAY_GET = "ARRAY_GET", i2.ARRAY_SET = "ARRAY_SET", i2.ARRAY_LEN = "ARRAY_LEN", i2.STRING_LEN = "STRING_LEN", i2.LENGTH = "LENGTH", i2.JSON_PARSE = "JSON_PARSE", i2.TYPEOF = "TYPEOF", i2.ADD = "ADD", i2.SUB = "SUB", i2.MUL = "MUL", i2.DIV = "DIV", i2.MOD = "MOD", i2.EQ = "EQ", i2.NEQ = "NEQ", i2.LT = "LT", i2.GT = "GT", i2.LTE = "LTE", i2.GTE = "GTE", i2.EQ_STRICT = "EQ_STRICT", i2.NEQ_STRICT = "NEQ_STRICT", i2.JUMP = "JUMP", i2.JUMP_IF = "JUMP_IF", i2.JUMP_IF_FALSE = "JUMP_IF_FALSE", i2.JUMP_IF_TRUE = "JUMP_IF_TRUE", i2.CALL = "CALL", i2.RETURN = "RETURN", i2.AND = "AND", i2.OR = "OR", i2.NOT = "NOT", i2.BREAK = "BREAK", i2.CONTINUE = "CONTINUE", i2.ITER_START = "ITER_START", i2.ITER_NEXT = "ITER_NEXT", i2.ITER_END = "ITER_END", i2.FS_LIST_FILES = "FS_LIST_FILES", i2.CC = "CC", i2.PRINT = "PRINT", i2.HALT = "HALT", i2))(n$1 || {});
-function A(i2) {
-  const a2 = [], e = [];
-  let x = false, m2 = false;
-  const c2 = s__namespace.createSourceFile(
+var A = Object.defineProperty;
+var k = (n2, l2, e2) => l2 in n2 ? A(n2, l2, { enumerable: true, configurable: true, writable: true, value: e2 }) : n2[l2] = e2;
+var S = (n2, l2, e2) => k(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.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 R(n2) {
+  const l2 = [], e2 = [];
+  let x = false, u2 = false;
+  const a2 = s__namespace.createSourceFile(
     "program.ts",
-    i2,
+    n2,
     s__namespace.ScriptTarget.Latest,
     true
   );
-  function t2(r2) {
-    if (s__namespace.isFunctionDeclaration(r2) && r2.name && r2.name.text === "main" && (x = true, r2.parameters.length > 0 && a2.push("main() must not have parameters")), s__namespace.isExpressionStatement(r2) && r2.parent === c2) {
-      const l2 = r2.expression;
-      s__namespace.isCallExpression(l2) && s__namespace.isIdentifier(l2.expression) && l2.expression.text === "main" && (m2 = true);
+  function t2(i2) {
+    if (s__namespace.isFunctionDeclaration(i2) && i2.name && i2.name.text === "main" && (x = 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" && (u2 = true);
     }
-    if (s__namespace.isCallExpression(r2) && s__namespace.isIdentifier(r2.expression)) {
-      const l2 = r2.expression.text;
-      ["setTimeout", "fetch", "require", "import"].includes(l2) && a2.push(`Unsupported function: ${l2}`);
+    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}`);
     }
-    s__namespace.forEachChild(r2, t2);
+    s__namespace.forEachChild(i2, t2);
   }
-  return t2(c2), x || a2.push("Program must have a main() function"), x && !m2 && a2.push("main() must be called at the top level"), a2.length === 0 && e.push({ op: n$1.HALT }), {
-    bytecode: e,
-    errors: a2,
+  return t2(a2), x || l2.push("Program must have a main() function"), x && !u2 && l2.push("main() must be called at the top level"), l2.length === 0 && e2.push({ op: r$1.HALT }), {
+    bytecode: e2,
+    errors: l2,
     hasMain: x
   };
 }
-let h$1 = class h {
+class I {
   constructor() {
-    E$1(this, "bytecode", []);
-    E$1(this, "contextStack", []);
+    S(this, "bytecode", []);
+    S(this, "contextStack", []);
   }
   /**
    * Emit an instruction and return its index
    */
-  emit(a2, e) {
+  emit(l2, e2) {
     const x = this.bytecode.length;
-    return this.bytecode.push({ op: a2, arg: e }), x;
+    return this.bytecode.push({ op: l2, arg: e2 }), x;
   }
   /**
    * Get the current address (next instruction index)
@@ -79,20 +79,20 @@ let h$1 = class h {
   /**
    * Patch a jump instruction with the target address
    */
-  patchJump(a2, e) {
-    a2 >= 0 && a2 < this.bytecode.length && (this.bytecode[a2].arg = e);
+  patchJump(l2, e2) {
+    l2 >= 0 && l2 < this.bytecode.length && (this.bytecode[l2].arg = e2);
   }
   /**
    * Patch multiple jump instructions with the same target
    */
-  patchJumps(a2, e) {
-    a2.forEach((x) => this.patchJump(x, e));
+  patchJumps(l2, e2) {
+    l2.forEach((x) => this.patchJump(x, e2));
   }
   /**
    * Push a new jump context onto the stack
    */
-  pushContext(a2) {
-    this.contextStack.push(a2);
+  pushContext(l2) {
+    this.contextStack.push(l2);
   }
   /**
    * Pop the current jump context from the stack
@@ -110,9 +110,9 @@ let h$1 = class h {
    * Find the nearest loop context (for break/continue)
    */
   findLoopContext() {
-    for (let a2 = this.contextStack.length - 1; a2 >= 0; a2--)
-      if (this.contextStack[a2].type === "loop")
-        return this.contextStack[a2];
+    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];
     return null;
   }
   /**
@@ -133,172 +133,278 @@ let h$1 = class h {
   getUnclosedContexts() {
     return [...this.contextStack];
   }
-};
-function k(i2) {
-  const a2 = A(i2);
-  if (a2.errors.length > 0)
+}
+function g$1(n2) {
+  const l2 = R(n2);
+  if (l2.errors.length > 0)
     return {
       success: false,
       bytecode: [],
-      errors: a2.errors
+      errors: l2.errors
     };
-  const e = new h$1(), x = s__namespace.createSourceFile("program.ts", i2, s__namespace.ScriptTarget.Latest, true);
-  function m2(t2) {
+  const e2 = new I(), x = s__namespace.createSourceFile("program.ts", n2, s__namespace.ScriptTarget.Latest, true);
+  function u2(t2) {
     if (s__namespace.isIfStatement(t2)) {
-      c2(t2.expression);
-      const r2 = e.emit(n$1.JUMP_IF_FALSE, -1), l2 = {
+      a2(t2.expression);
+      const i2 = e2.emit(r$1.JUMP_IF_FALSE, -1), c2 = {
         type: "if",
         endTargets: []
       };
-      if (t2.elseStatement ? l2.elseTarget = r2 : l2.endTargets.push(r2), e.pushContext(l2), m2(t2.thenStatement), t2.elseStatement) {
-        const o2 = e.emit(n$1.JUMP, -1);
-        l2.endTargets.push(o2);
-        const u2 = e.currentAddress();
-        e.patchJump(r2, u2), m2(t2.elseStatement);
+      if (t2.elseStatement ? c2.elseTarget = i2 : c2.endTargets.push(i2), e2.pushContext(c2), u2(t2.thenStatement), t2.elseStatement) {
+        const m2 = e2.emit(r$1.JUMP, -1);
+        c2.endTargets.push(m2);
+        const T = e2.currentAddress();
+        e2.patchJump(i2, T), u2(t2.elseStatement);
       }
-      const T2 = e.popContext();
-      if (T2) {
-        const o2 = e.currentAddress();
-        e.patchJumps(T2.endTargets, o2);
+      const o2 = e2.popContext();
+      if (o2) {
+        const m2 = e2.currentAddress();
+        e2.patchJumps(o2.endTargets, m2);
       }
     } else if (s__namespace.isWhileStatement(t2)) {
-      const r2 = e.currentAddress();
-      c2(t2.expression);
-      const T2 = {
+      const i2 = e2.currentAddress();
+      a2(t2.expression);
+      const o2 = {
         type: "loop",
-        breakTargets: [e.emit(n$1.JUMP_IF_FALSE, -1)],
+        breakTargets: [e2.emit(r$1.JUMP_IF_FALSE, -1)],
         continueTargets: [],
         endTargets: [],
-        startAddress: r2
+        startAddress: i2
       };
-      e.pushContext(T2), m2(t2.statement), e.emit(n$1.JUMP, r2);
-      const o2 = e.popContext();
-      if (o2) {
-        const u2 = e.currentAddress();
-        e.patchJumps(o2.breakTargets || [], u2);
+      e2.pushContext(o2), u2(t2.statement), e2.emit(r$1.JUMP, i2);
+      const m2 = e2.popContext();
+      if (m2) {
+        const T = e2.currentAddress();
+        e2.patchJumps(m2.breakTargets || [], T);
+      }
+    } else if (s__namespace.isForOfStatement(t2)) {
+      const i2 = t2.initializer, c2 = t2.expression;
+      let o2;
+      if (s__namespace.isVariableDeclarationList(i2))
+        o2 = i2.declarations[0].name.getText();
+      else if (s__namespace.isIdentifier(i2))
+        o2 = i2.text;
+      else
+        throw new Error("Unsupported for-of variable declaration");
+      a2(c2), e2.emit(r$1.ITER_START);
+      const m2 = e2.currentAddress();
+      e2.emit(r$1.ITER_NEXT);
+      const T = e2.emit(r$1.JUMP_IF_FALSE, -1);
+      e2.emit(r$1.STORE, o2);
+      const h2 = {
+        type: "foreach",
+        breakTargets: [T],
+        continueTargets: [],
+        endTargets: [],
+        startAddress: m2,
+        iterVariable: o2
+      };
+      e2.pushContext(h2), u2(t2.statement), e2.emit(r$1.JUMP, m2);
+      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((r2) => {
-        m2(r2);
+      t2.statements.forEach((i2) => {
+        u2(i2);
       });
     else if (s__namespace.isExpressionStatement(t2)) {
-      const r2 = t2.expression;
-      if (s__namespace.isCallExpression(r2) && s__namespace.isPropertyAccessExpression(r2.expression) && r2.expression.expression.getText() === "console" && r2.expression.name.getText() === "log")
-        r2.arguments.forEach((l2) => {
-          c2(l2);
-        }), e.emit(n$1.PRINT);
-      else if (s__namespace.isCallExpression(r2) && s__namespace.isIdentifier(r2.expression) && r2.expression.text === "CC")
-        r2.arguments.length > 0 && c2(r2.arguments[0]), e.emit(n$1.CC), e.emit(n$1.POP);
-      else if (s__namespace.isCallExpression(r2) && s__namespace.isPropertyAccessExpression(r2.expression) && r2.expression.name.getText() === "push")
-        c2(r2.expression.expression), r2.arguments.length > 0 && c2(r2.arguments[0]), e.emit(n$1.ARRAY_PUSH);
-      else if (s__namespace.isBinaryExpression(r2) && r2.operatorToken.kind === s__namespace.SyntaxKind.EqualsToken) {
-        if (c2(r2.right), s__namespace.isIdentifier(r2.left))
-          e.emit(n$1.STORE, r2.left.text);
-        else if (s__namespace.isElementAccessExpression(r2.left)) {
-          const l2 = `__temp_${e.getBytecode().length}`;
-          e.emit(n$1.STORE, l2), c2(r2.left.expression), c2(r2.left.argumentExpression), e.emit(n$1.LOAD, l2), e.emit(n$1.ARRAY_SET);
+      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 o2 = `__temp_${e2.getBytecode().length}`;
+            e2.emit(r$1.STORE, o2), a2(i2.left.expression), a2(i2.left.argumentExpression), e2.emit(r$1.LOAD, o2), 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 r2 = t2.declarationList.declarations[0];
-      r2.initializer && (c2(r2.initializer), e.emit(n$1.STORE, r2.name.getText()));
-    } else s__namespace.isReturnStatement(t2) && (t2.expression ? c2(t2.expression) : e.emit(n$1.PUSH, null), e.emit(n$1.RETURN));
+      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 c2(t2) {
+  function a2(t2) {
     if (s__namespace.isStringLiteral(t2))
-      e.emit(n$1.PUSH, t2.text);
+      e2.emit(r$1.PUSH, t2.text);
     else if (s__namespace.isNumericLiteral(t2))
-      e.emit(n$1.PUSH, Number(t2.text));
+      e2.emit(r$1.PUSH, Number(t2.text));
     else if (t2.kind === s__namespace.SyntaxKind.TrueKeyword)
-      e.emit(n$1.PUSH, true);
+      e2.emit(r$1.PUSH, true);
     else if (t2.kind === s__namespace.SyntaxKind.FalseKeyword)
-      e.emit(n$1.PUSH, false);
+      e2.emit(r$1.PUSH, false);
     else if (t2.kind === s__namespace.SyntaxKind.NullKeyword)
-      e.emit(n$1.PUSH, null);
+      e2.emit(r$1.PUSH, null);
     else if (s__namespace.isArrayLiteralExpression(t2))
-      e.emit(n$1.ARRAY_NEW), t2.elements.forEach((r2) => {
-        c2(r2), e.emit(n$1.ARRAY_PUSH);
+      e2.emit(r$1.ARRAY_NEW), t2.elements.forEach((i2) => {
+        a2(i2), e2.emit(r$1.ARRAY_PUSH);
       });
     else if (s__namespace.isElementAccessExpression(t2))
-      c2(t2.expression), t2.argumentExpression && c2(t2.argumentExpression), e.emit(n$1.ARRAY_GET);
+      a2(t2.expression), t2.argumentExpression && a2(t2.argumentExpression), e2.emit(r$1.ARRAY_GET);
     else if (s__namespace.isPropertyAccessExpression(t2) && t2.name.text === "length")
-      c2(t2.expression), e.emit(n$1.LENGTH);
+      a2(t2.expression), e2.emit(r$1.LENGTH);
     else if (s__namespace.isIdentifier(t2))
-      e.emit(n$1.LOAD, t2.text);
-    else if (s__namespace.isCallExpression(t2))
-      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 && c2(t2.arguments[0]), e.emit(n$1.JSON_PARSE)) : s__namespace.isIdentifier(t2.expression) && t2.expression.text === "CC" && (t2.arguments.length > 0 && c2(t2.arguments[0]), e.emit(n$1.CC));
-    else if (s__namespace.isParenthesizedExpression(t2))
-      c2(t2.expression);
+      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 === "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));
+      }
+    } else if (s__namespace.isParenthesizedExpression(t2))
+      a2(t2.expression);
     else if (s__namespace.isBinaryExpression(t2)) {
-      const r2 = t2.operatorToken.kind;
-      switch (c2(t2.left), c2(t2.right), r2) {
+      const i2 = t2.operatorToken.kind;
+      switch (a2(t2.left), a2(t2.right), i2) {
         case s__namespace.SyntaxKind.PlusToken:
-          f$1(t2.left, t2.right) ? e.emit(n$1.CONCAT) : e.emit(n$1.ADD);
+          E$1(t2.left, t2.right) ? e2.emit(r$1.CONCAT) : e2.emit(r$1.ADD);
           break;
         case s__namespace.SyntaxKind.MinusToken:
-          e.emit(n$1.SUB);
+          e2.emit(r$1.SUB);
           break;
         case s__namespace.SyntaxKind.AsteriskToken:
-          e.emit(n$1.MUL);
+          e2.emit(r$1.MUL);
           break;
         case s__namespace.SyntaxKind.SlashToken:
-          e.emit(n$1.DIV);
+          e2.emit(r$1.DIV);
           break;
         case s__namespace.SyntaxKind.PercentToken:
-          e.emit(n$1.MOD);
+          e2.emit(r$1.MOD);
           break;
         case s__namespace.SyntaxKind.EqualsEqualsToken:
-          e.emit(n$1.EQ);
+          e2.emit(r$1.EQ);
           break;
         case s__namespace.SyntaxKind.ExclamationEqualsToken:
-          e.emit(n$1.NEQ);
+          e2.emit(r$1.NEQ);
           break;
         case s__namespace.SyntaxKind.LessThanToken:
-          e.emit(n$1.LT);
+          e2.emit(r$1.LT);
           break;
         case s__namespace.SyntaxKind.GreaterThanToken:
-          e.emit(n$1.GT);
+          e2.emit(r$1.GT);
           break;
         case s__namespace.SyntaxKind.LessThanEqualsToken:
-          e.emit(n$1.LTE);
+          e2.emit(r$1.LTE);
           break;
         case s__namespace.SyntaxKind.GreaterThanEqualsToken:
-          e.emit(n$1.GTE);
+          e2.emit(r$1.GTE);
           break;
         case s__namespace.SyntaxKind.EqualsEqualsEqualsToken:
-          e.emit(n$1.EQ_STRICT);
+          e2.emit(r$1.EQ_STRICT);
           break;
         case s__namespace.SyntaxKind.ExclamationEqualsEqualsToken:
-          e.emit(n$1.NEQ_STRICT);
+          e2.emit(r$1.NEQ_STRICT);
           break;
         case s__namespace.SyntaxKind.AmpersandAmpersandToken:
-          e.emit(n$1.AND);
+          e2.emit(r$1.AND);
           break;
         case s__namespace.SyntaxKind.BarBarToken:
-          e.emit(n$1.OR);
+          e2.emit(r$1.OR);
           break;
       }
     } else if (s__namespace.isPrefixUnaryExpression(t2))
       switch (t2.operator) {
         case s__namespace.SyntaxKind.ExclamationToken:
-          c2(t2.operand), e.emit(n$1.NOT);
+          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 s__namespace.isTypeOfExpression(t2) && (c2(t2.expression), e.emit(n$1.TYPEOF));
+    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), o2 = e2.currentAddress();
+      e2.patchJump(i2, o2), a2(t2.whenFalse);
+      const m2 = e2.currentAddress();
+      e2.patchJump(c2, m2);
+    }
   }
   return x.forEachChild((t2) => {
-    var r2;
-    s__namespace.isFunctionDeclaration(t2) && ((r2 = t2.name) == null ? void 0 : r2.text) === "main" && t2.body && t2.body.statements.forEach((l2) => {
-      m2(l2);
+    var i2;
+    s__namespace.isFunctionDeclaration(t2) && ((i2 = t2.name) == null ? void 0 : i2.text) === "main" && t2.body && t2.body.statements.forEach((c2) => {
+      u2(c2);
     });
-  }), e.emit(n$1.HALT), {
+  }), e2.emit(r$1.HALT), {
     success: true,
-    bytecode: e.getBytecode(),
+    bytecode: e2.getBytecode(),
     errors: []
   };
 }
-function f$1(i2, a2) {
-  return !!(s__namespace.isStringLiteral(i2) || s__namespace.isStringLiteral(a2) || s__namespace.isBinaryExpression(i2) && i2.operatorToken.kind === s__namespace.SyntaxKind.PlusToken && f$1(i2.left, i2.right) || s__namespace.isBinaryExpression(a2) && a2.operatorToken.kind === s__namespace.SyntaxKind.PlusToken && f$1(a2.left, a2.right));
+function E$1(n2, l2) {
+  return !!(s__namespace.isStringLiteral(n2) || s__namespace.isStringLiteral(l2) || s__namespace.isBinaryExpression(n2) && n2.operatorToken.kind === s__namespace.SyntaxKind.PlusToken && E$1(n2.left, n2.right) || s__namespace.isBinaryExpression(l2) && l2.operatorToken.kind === s__namespace.SyntaxKind.PlusToken && E$1(l2.left, l2.right));
 }
 function n(r2) {
   return typeof r2 == "string";
@@ -312,35 +418,42 @@ function i$1(r2) {
 function f(r2) {
   return r2 === null;
 }
-function o$1(r2) {
+function e(r2) {
   return r2 !== null && typeof r2 == "object" && "type" in r2 && r2.type === "array";
 }
-function u$1(r2) {
-  return n(r2) ? r2 : t(r2) || i$1(r2) ? r2.toString() : f(r2) ? "null" : o$1(r2) ? `[array:${r2.elements.length}]` : String(r2);
+function o$1(r2) {
+  return r2 !== null && typeof r2 == "object" && "type" in r2 && r2.type === "undefined";
 }
 function c(r2) {
-  return i$1(r2) ? r2 : f(r2) ? false : t(r2) ? r2 !== 0 : n(r2) ? r2 !== "" : o$1(r2) ? true : !!r2;
+  return n(r2) ? r2 : t(r2) || i$1(r2) ? r2.toString() : f(r2) ? "null" : o$1(r2) ? "undefined" : e(r2) ? `[array:${r2.elements.length}]` : String(r2);
+}
+function y(r2) {
+  return i$1(r2) ? r2 : f(r2) || o$1(r2) ? false : t(r2) ? r2 !== 0 : n(r2) ? r2 !== "" : e(r2) ? true : !!r2;
 }
 function m(r2) {
-  return n(r2) ? "string" : t(r2) ? "number" : i$1(r2) ? "boolean" : f(r2) ? "null" : o$1(r2) ? "array" : "unknown";
+  return n(r2) ? "string" : t(r2) ? "number" : i$1(r2) ? "boolean" : f(r2) ? "null" : o$1(r2) ? "undefined" : e(r2) ? "array" : "unknown";
 }
-function y(r2) {
+function d(r2) {
   if (t(r2)) return r2;
   if (i$1(r2)) return r2 ? 1 : 0;
   if (f(r2)) return 0;
+  if (o$1(r2)) return NaN;
   if (n(r2)) {
-    const e = r2.trim();
-    return e === "" ? NaN : Number(e);
+    const u2 = r2.trim();
+    return u2 === "" ? 0 : Number(u2);
   }
-  return o$1(r2) ? NaN : Number(r2);
+  return e(r2) ? NaN : Number(r2);
 }
-function s(r2 = []) {
+function p$1(r2 = []) {
   return { type: "array", elements: r2 };
 }
+function s() {
+  return { type: "undefined" };
+}
 var l = Object.defineProperty;
 var u = (s2, t2, n2) => t2 in s2 ? l(s2, t2, { enumerable: true, configurable: true, writable: true, value: n2 }) : s2[t2] = n2;
 var r = (s2, t2, n2) => u(s2, typeof t2 != "symbol" ? t2 + "" : t2, n2);
-class h2 {
+class h {
   constructor(t2) {
     r(this, "connected", false);
     r(this, "programsDir");
@@ -359,44 +472,44 @@ class h2 {
   }
   async saveProgram(t2) {
     if (!this.connected) throw new Error("Not connected");
-    const n2 = c__namespace.join(this.programsDir, `${t2.id}.json`), e = JSON.stringify(t2, null, 2);
-    await fs.promises.writeFile(n2, e, "utf-8");
+    const n2 = c__namespace.join(this.programsDir, `${t2.id}.json`), e2 = JSON.stringify(t2, null, 2);
+    await fs.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 e = await fs.promises.readFile(n2, "utf-8"), o2 = JSON.parse(e);
+      const e2 = await fs.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 (e) {
-      if (e.code === "ENOENT")
+    } catch (e2) {
+      if (e2.code === "ENOENT")
         return null;
-      throw e;
+      throw e2;
     }
   }
   async saveExecution(t2) {
     if (!this.connected) throw new Error("Not connected");
-    const n2 = c__namespace.join(this.executionsDir, `${t2.id}.json`), e = JSON.stringify(t2, null, 2);
-    await fs.promises.writeFile(n2, e, "utf-8");
+    const n2 = c__namespace.join(this.executionsDir, `${t2.id}.json`), e2 = JSON.stringify(t2, null, 2);
+    await fs.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 e = await fs.promises.readFile(n2, "utf-8"), o2 = JSON.parse(e);
+      const e2 = await fs.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 (e) {
-      if (e.code === "ENOENT")
+    } catch (e2) {
+      if (e2.code === "ENOENT")
         return null;
-      throw e;
+      throw e2;
     }
   }
   async appendOutput(t2, n2) {
     if (!this.connected) throw new Error("Not connected");
-    const e = c__namespace.join(this.outputsDir, `${t2}.output`), o2 = n2.join(`
+    const e2 = c__namespace.join(this.outputsDir, `${t2}.output`), o2 = n2.join(`
 `) + `
 `;
-    await fs.promises.appendFile(e, o2, "utf-8");
+    await fs.promises.appendFile(e2, o2, "utf-8");
   }
   async getOutput(t2) {
     if (!this.connected) throw new Error("Not connected");
@@ -404,10 +517,10 @@ class h2 {
     try {
       return (await fs.promises.readFile(n2, "utf-8")).split(`
 `).filter((o2) => o2.length > 0);
-    } catch (e) {
-      if (e.code === "ENOENT")
+    } catch (e2) {
+      if (e2.code === "ENOENT")
         return [];
-      throw e;
+      throw e2;
     }
   }
 }
@@ -423,8 +536,8 @@ class p {
     await this.client.connect();
     const t2 = ((o2 = this.connectionString.split("/").pop()) == null ? void 0 : o2.split("?")[0]) || "cvm";
     this.db = this.client.db(t2), this.connected = true;
-    const e = (await this.db.listCollections().toArray()).map((a2) => a2.name);
-    e.includes("programs") || await this.db.createCollection("programs"), e.includes("executions") || await this.db.createCollection("executions"), e.includes("outputs") || await this.db.createCollection("outputs");
+    const e2 = (await this.db.listCollections().toArray()).map((a2) => a2.name);
+    e2.includes("programs") || await this.db.createCollection("programs"), e2.includes("executions") || await this.db.createCollection("executions"), e2.includes("outputs") || await this.db.createCollection("outputs");
   }
   async disconnect() {
     await this.client.close(), this.connected = false, this.db = null;
@@ -461,15 +574,15 @@ class p {
     return await this.getCollection("executions").findOne({ id: t2 });
   }
   async appendOutput(t2, n2) {
-    const e = this.getCollection("outputs");
-    await e.findOne({ executionId: t2 }) ? await e.updateOne(
+    const e2 = this.getCollection("outputs");
+    await e2.findOne({ executionId: t2 }) ? await e2.updateOne(
       { executionId: t2 },
       { $push: { lines: { $each: n2 } } }
-    ) : await e.insertOne({ executionId: t2, lines: n2 });
+    ) : await e2.insertOne({ executionId: t2, lines: n2 });
   }
   async getOutput(t2) {
-    const e = await this.getCollection("outputs").findOne({ executionId: t2 });
-    return (e == null ? void 0 : e.lines) || [];
+    const e2 = await this.getCollection("outputs").findOne({ executionId: t2 });
+    return (e2 == null ? void 0 : e2.lines) || [];
   }
 }
 class g {
@@ -477,22 +590,22 @@ class g {
     const n2 = (t2 == null ? void 0 : t2.type) || process.env.CVM_STORAGE_TYPE || "file";
     switch (n2) {
       case "file": {
-        const e = (t2 == null ? void 0 : t2.dataDir) || process.env.CVM_DATA_DIR || ".cvm";
-        return new h2(e);
+        const e2 = (t2 == null ? void 0 : t2.dataDir) || process.env.CVM_DATA_DIR || ".cvm";
+        return new h(e2);
       }
       case "mongodb": {
-        const e = (t2 == null ? void 0 : t2.mongoUri) || process.env.MONGODB_URI || "mongodb://localhost:27017/cvm";
-        return new p(e);
+        const e2 = (t2 == null ? void 0 : t2.mongoUri) || process.env.MONGODB_URI || "mongodb://localhost:27017/cvm";
+        return new p(e2);
       }
       default:
         throw new Error(`Unsupported storage type: ${n2}`);
     }
   }
 }
-var R = Object.defineProperty;
-var T = (d, a2, s2) => a2 in d ? R(d, a2, { enumerable: true, configurable: true, writable: true, value: s2 }) : d[a2] = s2;
-var v$1 = (d, a2, s2) => T(d, typeof a2 != "symbol" ? a2 + "" : a2, s2);
-class E {
+var P = Object.defineProperty;
+var O = (h2, a2, s2) => a2 in h2 ? P(h2, a2, { enumerable: true, configurable: true, writable: true, value: s2 }) : h2[a2] = s2;
+var E = (h2, a2, s2) => O(h2, typeof a2 != "symbol" ? a2 + "" : a2, s2);
+class w {
   execute(a2, s$12) {
     const r2 = {
       pc: (s$12 == null ? void 0 : s$12.pc) ?? 0,
@@ -504,79 +617,78 @@ class E {
       ...s$12
     };
     for (; r2.status === "running" && r2.pc < a2.length; ) {
-      const i2 = a2[r2.pc];
-      switch (i2.op) {
-        case n$1.HALT:
+      const n$1 = a2[r2.pc];
+      switch (n$1.op) {
+        case r$1.HALT:
           r2.status = "complete";
           break;
-        case n$1.PUSH:
-          r2.stack.push(i2.arg), r2.pc++;
+        case r$1.PUSH:
+          r2.stack.push(n$1.arg), r2.pc++;
           break;
-        case n$1.POP:
+        case r$1.PUSH_UNDEFINED:
+          r2.stack.push(s()), r2.pc++;
+          break;
+        case r$1.POP:
           r2.stack.pop(), r2.pc++;
           break;
-        case n$1.LOAD: {
-          const t2 = i2.arg;
-          if (!r2.variables.has(t2)) {
-            r2.status = "error", r2.error = `LOAD: Variable '${t2}' is not defined`;
-            break;
-          }
-          r2.stack.push(r2.variables.get(t2)), r2.pc++;
+        case r$1.LOAD: {
+          const t2 = n$1.arg;
+          r2.variables.has(t2) ? r2.stack.push(r2.variables.get(t2)) : r2.stack.push(s()), r2.pc++;
           break;
         }
-        case n$1.STORE:
-          const f2 = r2.stack.pop();
-          if (f2 === void 0) {
+        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(i2.arg, f2), r2.pc++;
+          r2.variables.set(n$1.arg, f$1), r2.pc++;
           break;
-        case n$1.CONCAT:
-          const u2 = r2.stack.pop(), k2 = r2.stack.pop();
-          if (k2 === void 0 || u2 === void 0) {
+        case r$1.CONCAT:
+          const p2 = r2.stack.pop(), k2 = r2.stack.pop();
+          if (k2 === void 0 || p2 === void 0) {
             r2.status = "error", r2.error = "CONCAT: Stack underflow";
             break;
           }
-          r2.stack.push(u$1(k2) + u$1(u2)), r2.pc++;
+          r2.stack.push(c(k2) + c(p2)), r2.pc++;
           break;
-        case n$1.PRINT:
-          const w = r2.stack.pop();
-          w !== void 0 && r2.output.push(u$1(w)), r2.pc++;
+        case r$1.PRINT:
+          const R2 = r2.stack.pop();
+          R2 !== void 0 && r2.output.push(c(R2)), r2.pc++;
           break;
-        case n$1.CC: {
+        case r$1.CC: {
           const t2 = r2.stack.pop();
           if (t2 === void 0) {
             r2.status = "error", r2.error = "CC: Stack underflow";
             break;
           }
-          r2.ccPrompt = u$1(t2), r2.status = "waiting_cc";
+          r2.ccPrompt = c(t2), r2.status = "waiting_cc";
           break;
         }
         // Array operations
-        case n$1.ARRAY_NEW:
-          r2.stack.push(s()), r2.pc++;
+        case r$1.ARRAY_NEW:
+          r2.stack.push(p$1()), r2.pc++;
           break;
-        case n$1.ARRAY_PUSH: {
-          const t2 = r2.stack.pop(), e = r2.stack.pop();
-          if (t2 === void 0 || e === void 0) {
+        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 (!o$1(e)) {
+          if (!e(e$1)) {
             r2.status = "error", r2.error = "ARRAY_PUSH requires an array";
             break;
           }
-          e.elements.push(t2), r2.stack.push(e), r2.pc++;
+          e$1.elements.push(t2), r2.stack.push(e$1), r2.pc++;
           break;
         }
-        case n$1.ARRAY_GET: {
-          const t$1 = r2.stack.pop(), e = r2.stack.pop();
-          if (t$1 === void 0 || e === void 0) {
+        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 (!o$1(e)) {
+          if (!e(e$1)) {
             r2.status = "error", r2.error = "ARRAY_GET requires an array";
             break;
           }
@@ -584,46 +696,46 @@ class E {
             r2.status = "error", r2.error = "ARRAY_GET requires numeric index";
             break;
           }
-          const c2 = e.elements[t$1] ?? null;
+          const c2 = e$1.elements[t$1] ?? null;
           r2.stack.push(c2), r2.pc++;
           break;
         }
-        case n$1.ARRAY_SET: {
-          const t$1 = r2.stack.pop(), e = r2.stack.pop(), c2 = r2.stack.pop();
-          if (t$1 === void 0 || e === void 0 || c2 === void 0) {
+        case r$1.ARRAY_SET: {
+          const t$1 = r2.stack.pop(), e$1 = r2.stack.pop(), c2 = r2.stack.pop();
+          if (t$1 === void 0 || e$1 === void 0 || c2 === void 0) {
             r2.status = "error", r2.error = "ARRAY_SET: Stack underflow";
             break;
           }
-          if (!o$1(c2)) {
+          if (!e(c2)) {
             r2.status = "error", r2.error = "ARRAY_SET requires an array";
             break;
           }
-          if (!t(e)) {
+          if (!t(e$1)) {
             r2.status = "error", r2.error = "ARRAY_SET requires numeric index";
             break;
           }
-          const n2 = Math.floor(e);
-          if (n2 < 0) {
+          const i2 = Math.floor(e$1);
+          if (i2 < 0) {
             r2.status = "error", r2.error = "ARRAY_SET: Negative index not allowed";
             break;
           }
-          c2.elements[n2] = t$1, r2.pc++;
+          c2.elements[i2] = t$1, r2.pc++;
           break;
         }
-        case n$1.ARRAY_LEN: {
+        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 (!o$1(t2)) {
+          if (!e(t2)) {
             r2.status = "error", r2.error = "ARRAY_LEN requires an array";
             break;
           }
           r2.stack.push(t2.elements.length), r2.pc++;
           break;
         }
-        case n$1.STRING_LEN: {
+        case r$1.STRING_LEN: {
           const t2 = r2.stack.pop();
           if (t2 === void 0) {
             r2.status = "error", r2.error = "STRING_LEN: Stack underflow";
@@ -636,7 +748,7 @@ class E {
           r2.stack.push(t2.length), r2.pc++;
           break;
         }
-        case n$1.LENGTH: {
+        case r$1.LENGTH: {
           const t2 = r2.stack.pop();
           if (t2 === void 0) {
             r2.status = "error", r2.error = "LENGTH: Stack underflow";
@@ -644,7 +756,7 @@ class E {
           }
           if (n(t2))
             r2.stack.push(t2.length);
-          else if (o$1(t2))
+          else if (e(t2))
             r2.stack.push(t2.elements.length);
           else {
             r2.status = "error", r2.error = "LENGTH requires a string or array";
@@ -653,7 +765,7 @@ class E {
           r2.pc++;
           break;
         }
-        case n$1.JSON_PARSE: {
+        case r$1.JSON_PARSE: {
           const t2 = r2.stack.pop();
           if (t2 === void 0) {
             r2.status = "error", r2.error = "JSON_PARSE: Stack underflow";
@@ -664,15 +776,15 @@ class E {
             break;
           }
           try {
-            const e = JSON.parse(t2);
-            Array.isArray(e) ? r2.stack.push(s(e)) : r2.stack.push(s());
+            const e2 = JSON.parse(t2);
+            Array.isArray(e2) ? r2.stack.push(p$1(e2)) : r2.stack.push(p$1());
           } catch {
-            r2.stack.push(s());
+            r2.stack.push(p$1());
           }
           r2.pc++;
           break;
         }
-        case n$1.TYPEOF: {
+        case r$1.TYPEOF: {
           const t2 = r2.stack.pop();
           if (t2 === void 0) {
             r2.status = "error", r2.error = "TYPEOF: Stack underflow";
@@ -682,146 +794,205 @@ class E {
           break;
         }
         // Arithmetic operations
-        case n$1.ADD: {
-          const t2 = r2.stack.pop(), e = r2.stack.pop();
-          if (e === void 0 || t2 === void 0) {
+        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 c2 = y(e), n2 = y(t2);
-          r2.stack.push(c2 + n2), r2.pc++;
+          const c2 = d(e2), i2 = d(t2);
+          r2.stack.push(c2 + i2), r2.pc++;
           break;
         }
-        case n$1.SUB: {
-          const t2 = r2.stack.pop(), e = r2.stack.pop();
-          if (e === void 0 || t2 === void 0) {
+        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 c2 = y(e), n2 = y(t2);
-          r2.stack.push(c2 - n2), r2.pc++;
+          const c2 = d(e2), i2 = d(t2);
+          r2.stack.push(c2 - i2), r2.pc++;
           break;
         }
-        case n$1.MUL: {
-          const t2 = r2.stack.pop(), e = r2.stack.pop();
-          if (e === void 0 || t2 === void 0) {
+        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 c2 = y(e), n2 = y(t2);
-          r2.stack.push(c2 * n2), r2.pc++;
+          const c2 = d(e2), i2 = d(t2);
+          r2.stack.push(c2 * i2), r2.pc++;
           break;
         }
-        case n$1.DIV: {
-          const t2 = r2.stack.pop(), e = r2.stack.pop();
-          if (e === void 0 || t2 === void 0) {
+        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 c2 = y(e), n2 = y(t2);
-          if (n2 === 0) {
+          const c2 = d(e2), i2 = d(t2);
+          if (i2 === 0) {
             r2.status = "error", r2.error = "Division by zero";
             break;
           }
-          r2.stack.push(c2 / n2), r2.pc++;
+          r2.stack.push(c2 / i2), r2.pc++;
           break;
         }
-        case n$1.MOD: {
-          const t2 = r2.stack.pop(), e = r2.stack.pop();
-          if (e === void 0 || t2 === void 0) {
+        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 c2 = y(e), n2 = y(t2);
-          r2.stack.push(c2 % n2), r2.pc++;
+          const c2 = d(e2), i2 = d(t2);
+          r2.stack.push(c2 % 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, c2 = d(e2) + 1;
+          r2.variables.set(t2, c2);
+          const i2 = n$1.arg === true;
+          r2.stack.push(i2 ? d(e2) : c2), 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, c2 = d(e2) - 1;
+          r2.variables.set(t2, c2);
+          const i2 = n$1.arg === true;
+          r2.stack.push(i2 ? d(e2) : c2), r2.pc++;
           break;
         }
         // Comparison operations
-        case n$1.EQ: {
-          const t2 = r2.stack.pop(), e = r2.stack.pop();
-          if (e === void 0 || t2 === void 0) {
+        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;
           }
-          const c2 = y(e), n2 = y(t2);
-          !isNaN(c2) && !isNaN(n2) ? r2.stack.push(c2 === n2) : r2.stack.push(u$1(e) === u$1(t2)), r2.pc++;
+          if (f(e2) && o$1(t2) || o$1(e2) && f(t2))
+            r2.stack.push(true);
+          else if (o$1(e2) && o$1(t2))
+            r2.stack.push(true);
+          else {
+            const c$12 = d(e2), i2 = d(t2);
+            !isNaN(c$12) && !isNaN(i2) ? r2.stack.push(c$12 === i2) : r2.stack.push(c(e2) === c(t2));
+          }
+          r2.pc++;
           break;
         }
-        case n$1.NEQ: {
-          const t2 = r2.stack.pop(), e = r2.stack.pop();
-          if (e === void 0 || t2 === void 0) {
+        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;
           }
-          const c2 = y(e), n2 = y(t2);
-          !isNaN(c2) && !isNaN(n2) ? r2.stack.push(c2 !== n2) : r2.stack.push(u$1(e) !== u$1(t2)), r2.pc++;
+          if (f(e2) && o$1(t2) || o$1(e2) && f(t2))
+            r2.stack.push(false);
+          else if (o$1(e2) && o$1(t2))
+            r2.stack.push(false);
+          else {
+            const c$12 = d(e2), i2 = d(t2);
+            !isNaN(c$12) && !isNaN(i2) ? r2.stack.push(c$12 !== i2) : r2.stack.push(c(e2) !== c(t2));
+          }
+          r2.pc++;
           break;
         }
-        case n$1.LT: {
-          const t2 = r2.stack.pop(), e = r2.stack.pop();
-          if (e === void 0 || t2 === void 0) {
+        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 c2 = y(e), n2 = y(t2);
-          r2.stack.push(c2 < n2), r2.pc++;
+          const c2 = d(e2), i2 = d(t2);
+          r2.stack.push(c2 < i2), r2.pc++;
           break;
         }
-        case n$1.GT: {
-          const t2 = r2.stack.pop(), e = r2.stack.pop();
-          if (e === void 0 || t2 === void 0) {
+        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 c2 = y(e), n2 = y(t2);
-          r2.stack.push(c2 > n2), r2.pc++;
+          const c2 = d(e2), i2 = d(t2);
+          r2.stack.push(c2 > i2), r2.pc++;
           break;
         }
-        case n$1.LTE: {
-          const t2 = r2.stack.pop(), e = r2.stack.pop();
-          if (e === void 0 || t2 === void 0) {
+        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 c2 = y(e), n2 = y(t2);
-          r2.stack.push(c2 <= n2), r2.pc++;
+          const c2 = d(e2), i2 = d(t2);
+          r2.stack.push(c2 <= i2), r2.pc++;
           break;
         }
-        case n$1.GTE: {
-          const t2 = r2.stack.pop(), e = r2.stack.pop();
-          if (e === void 0 || t2 === void 0) {
+        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 c2 = y(e), n2 = y(t2);
-          r2.stack.push(c2 >= n2), r2.pc++;
+          const c2 = d(e2), i2 = d(t2);
+          r2.stack.push(c2 >= i2), r2.pc++;
           break;
         }
-        case n$1.EQ_STRICT: {
-          const t2 = r2.stack.pop(), e = r2.stack.pop();
-          if (e === void 0 || t2 === void 0) {
+        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(e === t2), r2.pc++;
+          r2.stack.push(e2 === t2), r2.pc++;
           break;
         }
-        case n$1.NEQ_STRICT: {
-          const t2 = r2.stack.pop(), e = r2.stack.pop();
-          if (e === void 0 || t2 === void 0) {
+        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(e !== t2), r2.pc++;
+          r2.stack.push(e2 !== t2), r2.pc++;
           break;
         }
         // Jump operations
-        case n$1.JUMP: {
-          if (i2.arg === void 0) {
+        case r$1.JUMP: {
+          if (n$1.arg === void 0) {
             r2.status = "error", r2.error = "JUMP requires a target address";
             break;
           }
-          const t2 = i2.arg;
+          const t2 = n$1.arg;
           if (t2 < 0 || t2 >= a2.length) {
             r2.status = "error", r2.error = `Invalid jump target: ${t2}`;
             break;
@@ -829,25 +1000,25 @@ class E {
           r2.pc = t2;
           break;
         }
-        case n$1.JUMP_IF_FALSE: {
+        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 (i2.arg === void 0) {
+          if (n$1.arg === void 0) {
             r2.status = "error", r2.error = "JUMP_IF_FALSE requires a target address";
             break;
           }
-          const e = i2.arg;
-          if (e < 0 || e >= a2.length) {
-            r2.status = "error", r2.error = `Invalid jump target: ${e}`;
+          const e2 = n$1.arg;
+          if (e2 < 0 || e2 >= a2.length) {
+            r2.status = "error", r2.error = `Invalid jump target: ${e2}`;
             break;
           }
-          c(t2) ? r2.pc++ : r2.pc = e;
+          y(t2) ? r2.pc++ : r2.pc = e2;
           break;
         }
-        case n$1.ITER_START: {
+        case r$1.ITER_START: {
           if (r2.stack.length === 0) {
             r2.status = "error", r2.error = "ITER_START: Stack underflow";
             break;
@@ -857,7 +1028,7 @@ class E {
             r2.status = "error", r2.error = "TypeError: Cannot iterate over null or undefined";
             break;
           }
-          if (!o$1(t2)) {
+          if (!e(t2)) {
             r2.status = "error", r2.error = "TypeError: Cannot iterate over non-array value";
             break;
           }
@@ -865,14 +1036,14 @@ class E {
             r2.status = "error", r2.error = "RuntimeError: Maximum iterator depth exceeded";
             break;
           }
-          const e = s([...t2.elements]);
+          const e$1 = p$1([...t2.elements]);
           r2.iterators.push({
-            array: e,
+            array: e$1,
             index: 0
           }), r2.pc++;
           break;
         }
-        case n$1.ITER_NEXT: {
+        case r$1.ITER_NEXT: {
           if (r2.iterators.length === 0) {
             r2.status = "error", r2.error = "ITER_NEXT: No active iterator";
             break;
@@ -881,7 +1052,7 @@ class E {
           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 n$1.ITER_END: {
+        case r$1.ITER_END: {
           if (r2.iterators.length === 0) {
             r2.status = "error", r2.error = "ITER_END: No active iterator";
             break;
@@ -890,40 +1061,116 @@ class E {
           break;
         }
         // Logical operators
-        case n$1.AND: {
-          const t2 = r2.stack.pop(), e = r2.stack.pop();
-          if (e === void 0 || t2 === void 0) {
+        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;
           }
-          c(e) ? r2.stack.push(t2) : r2.stack.push(e), r2.pc++;
+          y(e2) ? r2.stack.push(t2) : r2.stack.push(e2), r2.pc++;
           break;
         }
-        case n$1.OR: {
-          const t2 = r2.stack.pop(), e = r2.stack.pop();
-          if (e === void 0 || t2 === void 0) {
+        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;
           }
-          c(e) ? r2.stack.push(e) : r2.stack.push(t2), r2.pc++;
+          y(e2) ? r2.stack.push(e2) : r2.stack.push(t2), r2.pc++;
           break;
         }
-        case n$1.NOT: {
+        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(!c(t2)), r2.pc++;
+          r2.stack.push(!y(t2)), r2.pc++;
           break;
         }
-        case n$1.RETURN: {
+        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, c2, i2;
+          const _ = r2.stack[t2 - 1], I2 = r2.stack[t2 - 2];
+          if (t2 >= 3 && typeof _ == "number" && typeof I2 == "number" ? (i2 = r2.stack.pop(), c2 = r2.stack.pop(), e2 = r2.stack.pop()) : (c2 = 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 c2 != "number") {
+            r2.status = "error", r2.error = "STRING_SUBSTRING requires numeric start index";
+            break;
+          }
+          const T = e2.length;
+          c2 < 0 && (c2 = Math.max(0, T + c2)), i2 !== void 0 && i2 < 0 && (i2 = Math.max(0, T + i2));
+          const y2 = i2 !== void 0 ? e2.substring(c2, i2) : e2.substring(c2);
+          r2.stack.push(y2), 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 c2;
+          t2 === "" ? c2 = e2.split("") : c2 = e2.split(t2), r2.stack.push(p$1(c2)), 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;
+        }
         default:
-          r2.status = "error", r2.error = `Unknown opcode: ${i2.op} (type: ${typeof i2.op})`;
+          r2.status = "error", r2.error = `Unknown opcode: ${n$1.op} (type: ${typeof n$1.op})`;
       }
     }
     return r2;
@@ -931,20 +1178,20 @@ class E {
   resume(a2, s2, r2) {
     if (a2.status !== "waiting_cc")
       throw new Error("Cannot resume: VM not waiting for CC");
-    const i2 = {
+    const n2 = {
       ...a2,
       stack: [...a2.stack, s2],
       status: "running",
       ccPrompt: void 0,
       pc: a2.pc + 1
     };
-    return this.execute(r2, i2);
+    return this.execute(r2, n2);
   }
 }
-class L {
+class D {
   constructor(a2) {
-    v$1(this, "vms", /* @__PURE__ */ new Map());
-    v$1(this, "storage");
+    E(this, "vms", /* @__PURE__ */ new Map());
+    E(this, "storage");
     a2 ? this.storage = a2 : this.storage = g.create();
   }
   /**
@@ -963,10 +1210,10 @@ class L {
    * Load and compile a program from source code
    */
   async loadProgram(a2, s2) {
-    const r2 = k(s2);
+    const r2 = g$1(s2);
     if (!r2.success)
       throw new Error(`Compilation failed: ${r2.errors.join(", ")}`);
-    const i2 = {
+    const n2 = {
       id: a2,
       name: a2,
       source: s2,
@@ -974,7 +1221,7 @@ class L {
       // VM decides internal format
       created: /* @__PURE__ */ new Date()
     };
-    await this.storage.saveProgram(i2);
+    await this.storage.saveProgram(n2);
   }
   /**
    * Start execution of a loaded program
@@ -982,7 +1229,7 @@ class L {
   async startExecution(a2, s2) {
     if (!await this.storage.getProgram(a2))
       throw new Error(`Program not found: ${a2}`);
-    const i2 = {
+    const n2 = {
       id: s2,
       programId: a2,
       state: "READY",
@@ -991,8 +1238,8 @@ class L {
       variables: {},
       created: /* @__PURE__ */ new Date()
     };
-    await this.storage.saveExecution(i2);
-    const f2 = new E();
+    await this.storage.saveExecution(n2);
+    const f2 = new w();
     this.vms.set(s2, f2);
   }
   /**
@@ -1007,29 +1254,29 @@ class L {
       const r2 = await this.storage.getProgram(s2.programId);
       if (!r2)
         throw new Error(`Program not found: ${s2.programId}`);
-      let i2 = this.vms.get(a2);
-      i2 || (i2 = new E(), this.vms.set(a2, i2));
+      let n2 = this.vms.get(a2);
+      n2 || (n2 = new w(), this.vms.set(a2, n2));
       const f2 = {
         pc: 0,
         stack: [],
         variables: /* @__PURE__ */ new Map(),
         output: []
-      }, u2 = i2.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), {
+      }, p2 = n2.execute(r2.bytecode, f2);
+      if (p2.output.length > 0 && await this.storage.appendOutput(a2, p2.output), s2.pc = p2.pc, s2.stack = p2.stack, s2.variables = Object.fromEntries(p2.variables), p2.status === "complete")
+        return s2.state = "COMPLETED", p2.returnValue !== void 0 && (s2.returnValue = p2.returnValue), await this.storage.saveExecution(s2), this.vms.delete(a2), {
           type: "completed",
           message: "Execution completed",
-          result: u2.returnValue
+          result: p2.returnValue
         };
-      if (u2.status === "waiting_cc")
-        return s2.state = "AWAITING_COGNITIVE_RESULT", s2.ccPrompt = u2.ccPrompt, await this.storage.saveExecution(s2), {
+      if (p2.status === "waiting_cc")
+        return s2.state = "AWAITING_COGNITIVE_RESULT", s2.ccPrompt = p2.ccPrompt, await this.storage.saveExecution(s2), {
           type: "waiting",
-          message: u2.ccPrompt || "Waiting for input"
+          message: p2.ccPrompt || "Waiting for input"
         };
-      if (u2.status === "error")
-        return s2.state = "ERROR", s2.error = u2.error, await this.storage.saveExecution(s2), this.vms.delete(a2), {
+      if (p2.status === "error")
+        return s2.state = "ERROR", s2.error = p2.error, await this.storage.saveExecution(s2), this.vms.delete(a2), {
           type: "error",
-          error: u2.error
+          error: p2.error
         };
     }
     if (s2.state === "COMPLETED")
@@ -1056,12 +1303,12 @@ class L {
     const r2 = await this.storage.getExecution(a2);
     if (!r2)
       throw new Error(`Execution not found: ${a2}`);
-    const i2 = await this.storage.getProgram(r2.programId);
-    if (!i2)
+    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 E(), this.vms.set(a2, f2));
-    const u2 = {
+    f2 || (f2 = new w(), this.vms.set(a2, f2));
+    const p2 = {
       pc: r2.pc,
       stack: r2.stack,
       variables: new Map(Object.entries(r2.variables)),
@@ -1071,7 +1318,7 @@ class L {
       ccPrompt: void 0,
       iterators: []
       // TODO: persist iterators in future
-    }, k2 = f2.resume(u2, s2, i2.bytecode);
+    }, k2 = f2.resume(p2, s2, n2.bytecode);
     k2.output.length > 0 && await this.storage.appendOutput(a2, k2.output), r2.pc = k2.pc, r2.stack = k2.stack, r2.variables = Object.fromEntries(k2.variables), k2.status === "complete" ? (r2.state = "COMPLETED", k2.returnValue !== void 0 && (r2.returnValue = k2.returnValue), this.vms.delete(a2)) : k2.status === "error" ? (r2.state = "ERROR", r2.error = k2.error, this.vms.delete(a2)) : k2.status === "waiting_cc" ? (r2.state = "AWAITING_COGNITIVE_RESULT", r2.ccPrompt = k2.ccPrompt) : r2.state = "RUNNING", await this.storage.saveExecution(r2);
   }
   /**
@@ -1105,7 +1352,7 @@ class v {
     o(this, "transport", null);
     o(this, "vmManager");
     o(this, "version");
-    this.version = r2, this.vmManager = new L(), this.server = new mcp_js.McpServer({
+    this.version = r2, this.vmManager = new D(), this.server = new mcp_js.McpServer({
       name: "cvm-server",
       version: this.version
     }), this.setupTools();
@@ -1128,9 +1375,9 @@ class v {
           return await this.vmManager.loadProgram(r2, t2), {
             content: [{ type: "text", text: `Program loaded successfully: ${r2}` }]
           };
-        } catch (e) {
+        } catch (e2) {
           return {
-            content: [{ type: "text", text: `Error: ${e instanceof Error ? e.message : "Unknown error"}` }],
+            content: [{ type: "text", text: `Error: ${e2 instanceof Error ? e2.message : "Unknown error"}` }],
             isError: true
           };
         }
@@ -1146,9 +1393,9 @@ class v {
           return await this.vmManager.startExecution(r2, t2), {
             content: [{ type: "text", text: `Execution started: ${t2}` }]
           };
-        } catch (e) {
+        } catch (e2) {
           return {
-            content: [{ type: "text", text: `Error: ${e instanceof Error ? e.message : "Unknown error"}` }],
+            content: [{ type: "text", text: `Error: ${e2 instanceof Error ? e2.message : "Unknown error"}` }],
             isError: true
           };
         }
@@ -1190,9 +1437,9 @@ class v {
           return await this.vmManager.reportCCResult(r2, t2), {
             content: [{ type: "text", text: "Execution resumed" }]
           };
-        } catch (e) {
+        } catch (e2) {
           return {
-            content: [{ type: "text", text: `Error: ${e instanceof Error ? e.message : "Unknown error"}` }],
+            content: [{ type: "text", text: `Error: ${e2 instanceof Error ? e2.message : "Unknown error"}` }],
             isError: true
           };
         }
@@ -1332,7 +1579,7 @@ async function main() {
           version = packageJson.version;
           break;
         }
-      } catch (e) {
+      } catch (e2) {
       }
     }
     logger2.info("Starting CVM Server...", {