cvm-server 0.13.0 → 0.14.0

package/main.cjs

@@ -3,7 +3,7 @@ const mcp_js = require("@modelcontextprotocol/sdk/server/mcp.js");
 const stdio_js = require("@modelcontextprotocol/sdk/server/stdio.js");
 const zod = require("zod");
 const s$1 = require("typescript");
-const x$2 = require("fs");
+const N$1 = require("fs");
 const r = require("path");
 const mongodb = require("mongodb");
 const promises = require("fs/promises");
@@ -11,31 +11,31 @@ const dotenv = require("dotenv");
 const url = require("url");
 var _documentCurrentScript = typeof document !== "undefined" ? document.currentScript : null;
 function _interopNamespaceDefault(e2) {
-  const n2 = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
   if (e2) {
     for (const k2 in e2) {
       if (k2 !== "default") {
         const d2 = Object.getOwnPropertyDescriptor(e2, k2);
-        Object.defineProperty(n2, k2, d2.get ? d2 : {
+        Object.defineProperty(n, k2, d2.get ? d2 : {
           enumerable: true,
           get: () => e2[k2]
         });
       }
     }
   }
-  n2.default = e2;
-  return Object.freeze(n2);
+  n.default = e2;
+  return Object.freeze(n);
 }
 const s__namespace = /* @__PURE__ */ _interopNamespaceDefault(s$1);
-const x__namespace = /* @__PURE__ */ _interopNamespaceDefault(x$2);
+const N__namespace = /* @__PURE__ */ _interopNamespaceDefault(N$1);
 const r__namespace = /* @__PURE__ */ _interopNamespaceDefault(r);
 const dotenv__namespace = /* @__PURE__ */ _interopNamespaceDefault(dotenv);
-var E$1 = Object.defineProperty;
-var _ = (e2, t2, i2) => t2 in e2 ? E$1(e2, t2, { enumerable: true, configurable: true, writable: true, value: i2 }) : e2[t2] = i2;
-var x$1 = (e2, t2, i2) => _(e2, typeof t2 != "symbol" ? t2 + "" : t2, i2);
-var n = /* @__PURE__ */ ((e2) => (e2.PUSH = "PUSH", e2.PUSH_UNDEFINED = "PUSH_UNDEFINED", e2.POP = "POP", e2.DUP = "DUP", e2.DUP2 = "DUP2", e2.SWAP = "SWAP", 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.ARRAY_MAP_PROP = "ARRAY_MAP_PROP", e2.ARRAY_FILTER_PROP = "ARRAY_FILTER_PROP", e2.ARRAY_SLICE = "ARRAY_SLICE", e2.ARRAY_JOIN = "ARRAY_JOIN", e2.ARRAY_INDEX_OF = "ARRAY_INDEX_OF", 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.STRING_INCLUDES = "STRING_INCLUDES", e2.STRING_ENDS_WITH = "STRING_ENDS_WITH", e2.STRING_STARTS_WITH = "STRING_STARTS_WITH", e2.STRING_TRIM = "STRING_TRIM", e2.STRING_TRIM_START = "STRING_TRIM_START", e2.STRING_TRIM_END = "STRING_TRIM_END", e2.STRING_REPLACE = "STRING_REPLACE", e2.STRING_REPLACE_ALL = "STRING_REPLACE_ALL", e2.STRING_LAST_INDEX_OF = "STRING_LAST_INDEX_OF", e2.STRING_REPEAT = "STRING_REPEAT", e2.STRING_PAD_START = "STRING_PAD_START", e2.STRING_PAD_END = "STRING_PAD_END", e2.LENGTH = "LENGTH", e2.TO_STRING = "TO_STRING", e2.JSON_PARSE = "JSON_PARSE", e2.TYPEOF = "TYPEOF", e2.ADD = "ADD", e2.SUB = "SUB", e2.MUL = "MUL", e2.DIV = "DIV", e2.MOD = "MOD", e2.UNARY_MINUS = "UNARY_MINUS", e2.UNARY_PLUS = "UNARY_PLUS", e2.INC = "INC", e2.DEC = "DEC", e2.EQ = "EQ", e2.NEQ = "NEQ", e2.LT = "LT", e2.GT = "GT", e2.LTE = "LTE", e2.GTE = "GTE", e2.EQ_STRICT = "EQ_STRICT", e2.NEQ_STRICT = "NEQ_STRICT", e2.JUMP = "JUMP", e2.JUMP_IF = "JUMP_IF", e2.JUMP_IF_FALSE = "JUMP_IF_FALSE", e2.JUMP_IF_TRUE = "JUMP_IF_TRUE", e2.CALL = "CALL", e2.RETURN = "RETURN", e2.AND = "AND", e2.OR = "OR", e2.NOT = "NOT", e2.BREAK = "BREAK", e2.CONTINUE = "CONTINUE", e2.ITER_START = "ITER_START", e2.ITER_NEXT = "ITER_NEXT", e2.ITER_END = "ITER_END", e2.FS_LIST_FILES = "FS_LIST_FILES", e2.FS_READ_FILE = "FS_READ_FILE", e2.FS_WRITE_FILE = "FS_WRITE_FILE", e2.OBJECT_CREATE = "OBJECT_CREATE", e2.PROPERTY_GET = "PROPERTY_GET", e2.PROPERTY_SET = "PROPERTY_SET", e2.JSON_STRINGIFY = "JSON_STRINGIFY", e2.GET = "GET", e2.SET = "SET", e2.CC = "CC", e2.PRINT = "PRINT", e2.HALT = "HALT", e2))(n || {});
-function f$3(e2) {
-  const t2 = [], i2 = [];
+var _$1 = Object.defineProperty;
+var I = (e2, t2, n) => t2 in e2 ? _$1(e2, t2, { enumerable: true, configurable: true, writable: true, value: n }) : e2[t2] = n;
+var o$1 = (e2, t2, n) => I(e2, typeof t2 != "symbol" ? t2 + "" : t2, n);
+var i$2 = /* @__PURE__ */ ((e2) => (e2.PUSH = "PUSH", e2.PUSH_UNDEFINED = "PUSH_UNDEFINED", e2.POP = "POP", e2.DUP = "DUP", e2.DUP2 = "DUP2", e2.SWAP = "SWAP", 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.ARRAY_MAP_PROP = "ARRAY_MAP_PROP", e2.ARRAY_FILTER_PROP = "ARRAY_FILTER_PROP", e2.ARRAY_SLICE = "ARRAY_SLICE", e2.ARRAY_JOIN = "ARRAY_JOIN", e2.ARRAY_INDEX_OF = "ARRAY_INDEX_OF", 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.STRING_INCLUDES = "STRING_INCLUDES", e2.STRING_ENDS_WITH = "STRING_ENDS_WITH", e2.STRING_STARTS_WITH = "STRING_STARTS_WITH", e2.STRING_TRIM = "STRING_TRIM", e2.STRING_TRIM_START = "STRING_TRIM_START", e2.STRING_TRIM_END = "STRING_TRIM_END", e2.STRING_REPLACE = "STRING_REPLACE", e2.STRING_REPLACE_ALL = "STRING_REPLACE_ALL", e2.STRING_LAST_INDEX_OF = "STRING_LAST_INDEX_OF", e2.STRING_REPEAT = "STRING_REPEAT", e2.STRING_PAD_START = "STRING_PAD_START", e2.STRING_PAD_END = "STRING_PAD_END", e2.LOAD_REGEX = "LOAD_REGEX", e2.LENGTH = "LENGTH", e2.TO_STRING = "TO_STRING", e2.JSON_PARSE = "JSON_PARSE", e2.TYPEOF = "TYPEOF", e2.ADD = "ADD", e2.SUB = "SUB", e2.MUL = "MUL", e2.DIV = "DIV", e2.MOD = "MOD", e2.UNARY_MINUS = "UNARY_MINUS", e2.UNARY_PLUS = "UNARY_PLUS", e2.INC = "INC", e2.DEC = "DEC", e2.EQ = "EQ", e2.NEQ = "NEQ", e2.LT = "LT", e2.GT = "GT", e2.LTE = "LTE", e2.GTE = "GTE", e2.EQ_STRICT = "EQ_STRICT", e2.NEQ_STRICT = "NEQ_STRICT", e2.JUMP = "JUMP", e2.JUMP_IF = "JUMP_IF", e2.JUMP_IF_FALSE = "JUMP_IF_FALSE", e2.JUMP_IF_TRUE = "JUMP_IF_TRUE", e2.CALL = "CALL", e2.RETURN = "RETURN", e2.AND = "AND", e2.OR = "OR", e2.NOT = "NOT", e2.BREAK = "BREAK", e2.CONTINUE = "CONTINUE", e2.ITER_START = "ITER_START", e2.ITER_NEXT = "ITER_NEXT", e2.ITER_END = "ITER_END", e2.OBJECT_ITER_START = "OBJECT_ITER_START", e2.OBJECT_ITER_NEXT = "OBJECT_ITER_NEXT", e2.FS_LIST_FILES = "FS_LIST_FILES", e2.FS_READ_FILE = "FS_READ_FILE", e2.FS_WRITE_FILE = "FS_WRITE_FILE", e2.OBJECT_CREATE = "OBJECT_CREATE", e2.PROPERTY_GET = "PROPERTY_GET", e2.PROPERTY_SET = "PROPERTY_SET", e2.OBJECT_KEYS = "OBJECT_KEYS", e2.JSON_STRINGIFY = "JSON_STRINGIFY", e2.GET = "GET", e2.SET = "SET", e2.CC = "CC", e2.PRINT = "PRINT", e2.HALT = "HALT", e2))(i$2 || {});
+function A(e2) {
+  const t2 = [], n = [];
   let r2 = false;
   const a2 = s__namespace.createSourceFile(
     "program.ts",
@@ -43,30 +43,31 @@ function f$3(e2) {
     s__namespace.ScriptTarget.Latest,
     true
   );
-  function m2(T2) {
-    if (s__namespace.isFunctionDeclaration(T2) && T2.name && T2.name.text === "main" && (r2 = true, T2.parameters.length > 0 && t2.push("main() must not have parameters")), s__namespace.isCallExpression(T2) && s__namespace.isIdentifier(T2.expression)) {
-      const l2 = T2.expression.text;
-      ["setTimeout", "fetch", "require", "import"].includes(l2) && t2.push(`Unsupported function: ${l2}`);
+  function m2(T) {
+    if (s__namespace.isFunctionDeclaration(T) && T.name && T.name.text === "main" && (r2 = true, T.parameters.length > 0 && t2.push("main() must not have parameters")), s__namespace.isCallExpression(T) && s__namespace.isIdentifier(T.expression)) {
+      const c2 = T.expression.text;
+      ["setTimeout", "fetch", "require", "import"].includes(c2) && t2.push(`Unsupported function: ${c2}`);
     }
-    s__namespace.forEachChild(T2, m2);
+    s__namespace.forEachChild(T, m2);
   }
-  return m2(a2), r2 || t2.push("Program must have a main() function"), t2.length === 0 && i2.push({ op: n.HALT }), {
-    bytecode: i2,
+  return m2(a2), r2 || t2.push("Program must have a main() function"), t2.length === 0 && n.push({ op: i$2.HALT }), {
+    bytecode: n,
     errors: t2,
     hasMain: r2
   };
 }
-class I {
+class P {
   constructor() {
-    x$1(this, "bytecode", []);
-    x$1(this, "contextStack", []);
+    o$1(this, "bytecode", []);
+    o$1(this, "contextStack", []);
+    o$1(this, "tempVarCounter", 0);
   }
   /**
    * Emit an instruction and return its index
    */
-  emit(t2, i2) {
+  emit(t2, n) {
     const r2 = this.bytecode.length;
-    return this.bytecode.push({ op: t2, arg: i2 }), r2;
+    return this.bytecode.push({ op: t2, arg: n }), r2;
   }
   /**
    * Get the current address (next instruction index)
@@ -77,14 +78,14 @@ class I {
   /**
    * Patch a jump instruction with the target address
    */
-  patchJump(t2, i2) {
-    t2 >= 0 && t2 < this.bytecode.length && (this.bytecode[t2].arg = i2);
+  patchJump(t2, n) {
+    t2 >= 0 && t2 < this.bytecode.length && (this.bytecode[t2].arg = n);
   }
   /**
    * Patch multiple jump instructions with the same target
    */
-  patchJumps(t2, i2) {
-    t2.forEach((r2) => this.patchJump(r2, i2));
+  patchJumps(t2, n) {
+    t2.forEach((r2) => this.patchJump(r2, n));
   }
   /**
    * Push a new jump context onto the stack
@@ -109,9 +110,9 @@ class I {
    */
   findLoopContext() {
     for (let t2 = this.contextStack.length - 1; t2 >= 0; t2--) {
-      const i2 = this.contextStack[t2];
-      if (i2.type === "loop" || i2.type === "foreach")
-        return i2;
+      const n = this.contextStack[t2];
+      if (n.type === "loop" || n.type === "foreach")
+        return n;
     }
     return null;
   }
@@ -133,326 +134,434 @@ class I {
   getUnclosedContexts() {
     return [...this.contextStack];
   }
+  /**
+   * Generate a unique temporary variable name
+   */
+  generateTempVar() {
+    return `__temp${this.tempVarCounter++}`;
+  }
 }
-const A = (e2, t2, { compileExpression: i2, compileStatement: r2 }) => {
-  i2(e2.expression);
-  const a2 = t2.emit(n.JUMP_IF_FALSE, -1), m2 = {
+const g = (e2, t2, { compileExpression: n, compileStatement: r2 }) => {
+  n(e2.expression);
+  const a2 = t2.emit(i$2.JUMP_IF_FALSE, -1), m2 = {
     type: "if",
     endTargets: []
   };
   if (e2.elseStatement ? m2.elseTarget = a2 : m2.endTargets.push(a2), t2.pushContext(m2), r2(e2.thenStatement), e2.elseStatement) {
-    const l2 = t2.emit(n.JUMP, -1);
-    m2.endTargets.push(l2);
+    const c2 = t2.emit(i$2.JUMP, -1);
+    m2.endTargets.push(c2);
     const S = t2.currentAddress();
     t2.patchJump(a2, S), r2(e2.elseStatement);
   }
-  const T2 = t2.popContext();
-  if (T2) {
-    const l2 = t2.currentAddress();
-    t2.patchJumps(T2.endTargets, l2);
+  const T = t2.popContext();
+  if (T) {
+    const c2 = t2.currentAddress();
+    t2.patchJumps(T.endTargets, c2);
   }
-}, o$1 = (e2, t2, { compileExpression: i2, compileStatement: r2 }) => {
+}, N = (e2, t2, { compileExpression: n, compileStatement: r2 }) => {
   const a2 = t2.currentAddress();
-  i2(e2.expression);
-  const T2 = {
+  n(e2.expression);
+  const T = {
     type: "loop",
-    breakTargets: [t2.emit(n.JUMP_IF_FALSE, -1)],
+    breakTargets: [t2.emit(i$2.JUMP_IF_FALSE, -1)],
     continueTargets: [],
     endTargets: [],
     startAddress: a2
   };
-  t2.pushContext(T2), r2(e2.statement), t2.emit(n.JUMP, a2);
-  const l2 = t2.popContext();
-  if (l2) {
+  t2.pushContext(T), r2(e2.statement), t2.emit(i$2.JUMP, a2);
+  const c2 = t2.popContext();
+  if (c2) {
     const S = t2.currentAddress();
-    t2.patchJumps(l2.breakTargets || [], S);
+    t2.patchJumps(c2.breakTargets || [], S);
   }
-}, N = (e2, t2, { compileExpression: i2, compileStatement: r2 }) => {
+}, h$1 = (e2, t2, { compileExpression: n, compileStatement: r2 }) => {
   const a2 = e2.initializer, m2 = e2.expression;
-  let T2;
+  let T;
   if (s__namespace.isVariableDeclarationList(a2))
-    T2 = a2.declarations[0].name.getText();
+    T = a2.declarations[0].name.getText();
   else if (s__namespace.isIdentifier(a2))
-    T2 = a2.text;
+    T = a2.text;
   else
     throw new Error("Unsupported for-of variable declaration");
-  i2(m2), t2.emit(n.ITER_START);
-  const l2 = t2.currentAddress();
-  t2.emit(n.ITER_NEXT);
-  const S = t2.emit(n.JUMP_IF_FALSE, -1);
-  t2.emit(n.STORE, T2);
-  const c2 = {
+  n(m2), t2.emit(i$2.ITER_START);
+  const c2 = t2.currentAddress();
+  t2.emit(i$2.ITER_NEXT);
+  const S = t2.emit(i$2.JUMP_IF_FALSE, -1);
+  t2.emit(i$2.STORE, T);
+  const u2 = {
     type: "foreach",
     breakTargets: [S],
     continueTargets: [],
     endTargets: [],
-    startAddress: l2,
-    iterVariable: T2
+    startAddress: c2,
+    iterVariable: T
   };
-  t2.pushContext(c2), r2(e2.statement), t2.emit(n.JUMP, l2);
-  const R = t2.popContext();
-  if (R) {
-    const u2 = t2.currentAddress();
-    t2.patchJumps(R.breakTargets || [], u2), t2.emit(n.ITER_END);
+  t2.pushContext(u2), r2(e2.statement), t2.emit(i$2.JUMP, c2);
+  const l = t2.popContext();
+  if (l) {
+    const x2 = t2.currentAddress();
+    t2.patchJumps(l.breakTargets || [], x2), t2.emit(i$2.ITER_END);
   }
-}, P$1 = (e2, t2, { compileStatement: i2 }) => {
+}, p$2 = (e2, t2, { compileExpression: n, compileStatement: r2 }) => {
+  const a2 = e2.initializer, m2 = e2.expression;
+  let T;
+  if (s__namespace.isVariableDeclarationList(a2))
+    T = a2.declarations[0].name.getText();
+  else if (s__namespace.isIdentifier(a2))
+    T = a2.text;
+  else
+    throw new Error("Unsupported for-in variable declaration");
+  n(m2), t2.emit(i$2.OBJECT_ITER_START);
+  const c2 = t2.currentAddress();
+  t2.emit(i$2.OBJECT_ITER_NEXT);
+  const S = t2.emit(i$2.JUMP_IF_FALSE, -1);
+  t2.emit(i$2.STORE, T);
+  const u2 = {
+    type: "foreach",
+    breakTargets: [S],
+    continueTargets: [],
+    endTargets: [],
+    startAddress: c2,
+    iterVariable: T
+  };
+  t2.pushContext(u2), r2(e2.statement), t2.emit(i$2.JUMP, c2);
+  const l = t2.popContext();
+  if (l) {
+    const x2 = t2.currentAddress();
+    t2.patchJumps(l.breakTargets || [], x2), t2.emit(i$2.ITER_END);
+  }
+}, U = (e2, t2, { compileExpression: n, compileStatement: r2 }) => {
+  if (e2.initializer)
+    if (s__namespace.isVariableDeclarationList(e2.initializer))
+      for (const S of e2.initializer.declarations)
+        S.initializer && (n(S.initializer), t2.emit(i$2.STORE, S.name.getText()));
+    else
+      n(e2.initializer), t2.emit(i$2.POP);
+  const a2 = t2.currentAddress();
+  let m2;
+  e2.condition && (n(e2.condition), m2 = t2.emit(i$2.JUMP_IF_FALSE, -1));
+  const T = {
+    type: "loop",
+    breakTargets: m2 ? [m2] : [],
+    continueTargets: [],
+    endTargets: [],
+    startAddress: a2
+  };
+  t2.pushContext(T), r2(e2.statement), e2.incrementor && (n(e2.incrementor), t2.emit(i$2.POP)), t2.emit(i$2.JUMP, a2);
+  const c2 = t2.popContext();
+  if (c2) {
+    const S = t2.currentAddress();
+    t2.patchJumps(c2.breakTargets || [], S);
+  }
+}, y$1 = (e2, t2, { compileExpression: n, compileStatement: r2 }) => {
+  const a2 = t2.generateTempVar();
+  n(e2.expression), t2.emit(i$2.STORE, a2);
+  const m2 = [], T = [];
+  let c2 = null;
+  if (e2.caseBlock.clauses.forEach((l, x2) => {
+    if (s__namespace.isCaseClause(l)) {
+      t2.emit(i$2.LOAD, a2), n(l.expression), t2.emit(i$2.EQ_STRICT);
+      const R = t2.emit(i$2.JUMP_IF_TRUE, -1);
+      T.push(R);
+    } else s__namespace.isDefaultClause(l) && (c2 = t2.emit(i$2.JUMP, -1));
+  }), c2 === null) {
+    const l = t2.emit(i$2.JUMP, -1);
+    m2.push(l);
+  }
+  let S = 0;
+  e2.caseBlock.clauses.forEach((l, x2) => {
+    if (s__namespace.isCaseClause(l)) {
+      const R = t2.currentAddress();
+      t2.patchJumps([T[S]], R), S++, l.statements.forEach((E2) => {
+        if (s__namespace.isBreakStatement(E2)) {
+          const f3 = t2.emit(i$2.JUMP, -1);
+          m2.push(f3);
+        } else
+          r2(E2);
+      });
+    } else if (s__namespace.isDefaultClause(l)) {
+      const R = t2.currentAddress();
+      c2 !== null && t2.patchJumps([c2], R), l.statements.forEach((E2) => {
+        if (s__namespace.isBreakStatement(E2)) {
+          const f3 = t2.emit(i$2.JUMP, -1);
+          m2.push(f3);
+        } else
+          r2(E2);
+      });
+    }
+  });
+  const u2 = t2.currentAddress();
+  t2.patchJumps(m2, u2);
+}, L$1 = (e2, t2, { compileStatement: n }) => {
   e2.statements.forEach((r2) => {
-    i2(r2);
+    n(r2);
   });
-}, g = (e2, t2, { compileExpression: i2 }) => {
+}, k = (e2, t2, { compileExpression: n }) => {
   const r2 = e2.declarationList.declarations[0];
-  r2.initializer && (i2(r2.initializer), t2.emit(n.STORE, r2.name.getText()));
-}, h$1 = (e2, t2, { compileExpression: i2 }) => {
+  r2.initializer && (n(r2.initializer), t2.emit(i$2.STORE, r2.name.getText()));
+}, D = (e2, t2, { compileExpression: n }) => {
   const r2 = e2.expression;
   if (s__namespace.isBinaryExpression(r2)) {
     const a2 = r2.operatorToken.kind;
     if (a2 === s__namespace.SyntaxKind.PlusEqualsToken || a2 === s__namespace.SyntaxKind.MinusEqualsToken || a2 === s__namespace.SyntaxKind.AsteriskEqualsToken || a2 === s__namespace.SyntaxKind.SlashEqualsToken || a2 === s__namespace.SyntaxKind.PercentEqualsToken) {
       if (s__namespace.isIdentifier(r2.left)) {
-        switch (t2.emit(n.LOAD, r2.left.text), i2(r2.right), a2) {
+        switch (t2.emit(i$2.LOAD, r2.left.text), n(r2.right), a2) {
           case s__namespace.SyntaxKind.PlusEqualsToken:
-            t2.emit(n.ADD);
+            t2.emit(i$2.ADD);
             break;
           case s__namespace.SyntaxKind.MinusEqualsToken:
-            t2.emit(n.SUB);
+            t2.emit(i$2.SUB);
             break;
           case s__namespace.SyntaxKind.AsteriskEqualsToken:
-            t2.emit(n.MUL);
+            t2.emit(i$2.MUL);
             break;
           case s__namespace.SyntaxKind.SlashEqualsToken:
-            t2.emit(n.DIV);
+            t2.emit(i$2.DIV);
             break;
           case s__namespace.SyntaxKind.PercentEqualsToken:
-            t2.emit(n.MOD);
+            t2.emit(i$2.MOD);
             break;
         }
-        t2.emit(n.STORE, r2.left.text);
+        t2.emit(i$2.STORE, r2.left.text);
       } else if (s__namespace.isElementAccessExpression(r2.left))
         throw new Error("Compound assignment to array elements not yet supported");
       return;
     } else if (a2 === s__namespace.SyntaxKind.EqualsToken) {
-      if (i2(r2.right), s__namespace.isIdentifier(r2.left))
-        t2.emit(n.STORE, r2.left.text);
+      if (n(r2.right), s__namespace.isIdentifier(r2.left))
+        t2.emit(i$2.STORE, r2.left.text);
       else if (s__namespace.isElementAccessExpression(r2.left)) {
         const m2 = `__temp_${t2.getBytecode().length}`;
-        t2.emit(n.STORE, m2), i2(r2.left.expression), i2(r2.left.argumentExpression), t2.emit(n.LOAD, m2), t2.emit(n.ARRAY_SET), t2.emit(n.POP);
+        t2.emit(i$2.STORE, m2), n(r2.left.expression), n(r2.left.argumentExpression), t2.emit(i$2.LOAD, m2), t2.emit(i$2.ARRAY_SET), t2.emit(i$2.POP);
       } else if (s__namespace.isPropertyAccessExpression(r2.left)) {
         const m2 = `__temp_${t2.getBytecode().length}`;
-        t2.emit(n.STORE, m2), i2(r2.left.expression), t2.emit(n.PUSH, r2.left.name.text), t2.emit(n.LOAD, m2), t2.emit(n.PROPERTY_SET), t2.emit(n.POP);
+        t2.emit(i$2.STORE, m2), n(r2.left.expression), t2.emit(i$2.PUSH, r2.left.name.text), t2.emit(i$2.LOAD, m2), t2.emit(i$2.PROPERTY_SET), t2.emit(i$2.POP);
       }
       return;
     }
   }
   s__namespace.isCallExpression(r2) && s__namespace.isPropertyAccessExpression(r2.expression) && r2.expression.expression.getText() === "console" && r2.expression.name.getText() === "log" ? (r2.arguments.forEach((a2) => {
-    i2(a2);
-  }), t2.emit(n.PRINT)) : s__namespace.isCallExpression(r2) && s__namespace.isIdentifier(r2.expression) && r2.expression.text === "CC" ? (r2.arguments.length > 0 && i2(r2.arguments[0]), t2.emit(n.CC), t2.emit(n.POP)) : s__namespace.isCallExpression(r2) && s__namespace.isPropertyAccessExpression(r2.expression) && r2.expression.name.getText() === "push" ? (i2(r2.expression.expression), r2.arguments.length > 0 && i2(r2.arguments[0]), t2.emit(n.ARRAY_PUSH)) : (s__namespace.isPostfixUnaryExpression(r2) || s__namespace.isPrefixUnaryExpression(r2), i2(r2), t2.emit(n.POP));
-}, U = (e2, t2, { compileExpression: i2 }) => {
-  e2.expression ? i2(e2.expression) : t2.emit(n.PUSH, null), t2.emit(n.RETURN);
-}, p$2 = (e2, t2, i2) => {
+    n(a2);
+  }), t2.emit(i$2.PRINT)) : s__namespace.isCallExpression(r2) && s__namespace.isIdentifier(r2.expression) && r2.expression.text === "CC" ? (r2.arguments.length > 0 && n(r2.arguments[0]), t2.emit(i$2.CC), t2.emit(i$2.POP)) : s__namespace.isCallExpression(r2) && s__namespace.isPropertyAccessExpression(r2.expression) && r2.expression.name.getText() === "push" ? (n(r2.expression.expression), r2.arguments.length > 0 && n(r2.arguments[0]), t2.emit(i$2.ARRAY_PUSH)) : (s__namespace.isPostfixUnaryExpression(r2) || s__namespace.isPrefixUnaryExpression(r2), n(r2), t2.emit(i$2.POP));
+}, G = (e2, t2, { compileExpression: n }) => {
+  e2.expression ? n(e2.expression) : t2.emit(i$2.PUSH, null), t2.emit(i$2.RETURN);
+}, F$1 = (e2, t2, n) => {
   const r2 = t2.findLoopContext();
   if (r2) {
-    r2.type === "foreach" && t2.emit(n.ITER_END);
-    const a2 = t2.emit(n.BREAK, -1);
+    r2.type === "foreach" && t2.emit(i$2.ITER_END);
+    const a2 = t2.emit(i$2.BREAK, -1);
     r2.breakTargets = r2.breakTargets || [], r2.breakTargets.push(a2);
   } else
-    i2.reportError(e2, "break statement not in loop");
-}, y$1 = (e2, t2, i2) => {
+    n.reportError(e2, "break statement not in loop");
+}, b$1 = (e2, t2, n) => {
   const r2 = t2.findLoopContext();
   if (r2 && r2.startAddress !== void 0) {
-    const a2 = t2.emit(n.CONTINUE, r2.startAddress);
+    const a2 = t2.emit(i$2.CONTINUE, r2.startAddress);
     r2.continueTargets = r2.continueTargets || [], r2.continueTargets.push(a2);
   } else
-    i2.reportError(e2, "continue statement not in loop");
-}, L = {
-  [s__namespace.SyntaxKind.IfStatement]: A,
-  [s__namespace.SyntaxKind.WhileStatement]: o$1,
-  [s__namespace.SyntaxKind.ForOfStatement]: N,
-  [s__namespace.SyntaxKind.Block]: P$1,
-  [s__namespace.SyntaxKind.VariableStatement]: g,
-  [s__namespace.SyntaxKind.ExpressionStatement]: h$1,
-  [s__namespace.SyntaxKind.ReturnStatement]: U,
-  [s__namespace.SyntaxKind.BreakStatement]: p$2,
-  [s__namespace.SyntaxKind.ContinueStatement]: y$1
-}, k = (e2, t2, i2) => {
-  t2.emit(n.PUSH, e2.text);
-}, G = (e2, t2, i2) => {
-  t2.emit(n.PUSH, Number(e2.text));
-}, D$1 = (e2, t2, i2) => {
-  t2.emit(n.PUSH, true);
-}, F$1 = (e2, t2, i2) => {
-  t2.emit(n.PUSH, false);
-}, K = (e2, t2, i2) => {
-  t2.emit(n.PUSH, null);
-}, H = (e2, t2, i2) => {
-  e2.text === "undefined" ? t2.emit(n.PUSH_UNDEFINED) : t2.emit(n.LOAD, e2.text);
-}, b$2 = (e2, t2, { compileExpression: i2 }) => {
-  t2.emit(n.ARRAY_NEW), e2.elements.forEach((r2) => {
-    i2(r2), t2.emit(n.ARRAY_PUSH);
+    n.reportError(e2, "continue statement not in loop");
+}, K = {
+  [s__namespace.SyntaxKind.IfStatement]: g,
+  [s__namespace.SyntaxKind.WhileStatement]: N,
+  [s__namespace.SyntaxKind.ForOfStatement]: h$1,
+  [s__namespace.SyntaxKind.ForInStatement]: p$2,
+  [s__namespace.SyntaxKind.ForStatement]: U,
+  [s__namespace.SyntaxKind.SwitchStatement]: y$1,
+  [s__namespace.SyntaxKind.Block]: L$1,
+  [s__namespace.SyntaxKind.VariableStatement]: k,
+  [s__namespace.SyntaxKind.ExpressionStatement]: D,
+  [s__namespace.SyntaxKind.ReturnStatement]: G,
+  [s__namespace.SyntaxKind.BreakStatement]: F$1,
+  [s__namespace.SyntaxKind.ContinueStatement]: b$1
+}, J = (e2, t2, n) => {
+  t2.emit(i$2.PUSH, e2.text);
+}, H = (e2, t2, n) => {
+  t2.emit(i$2.PUSH, Number(e2.text));
+}, M$1 = (e2, t2, n) => {
+  t2.emit(i$2.PUSH, true);
+}, Y = (e2, t2, n) => {
+  t2.emit(i$2.PUSH, false);
+}, B$1 = (e2, t2, n) => {
+  t2.emit(i$2.PUSH, null);
+}, C$2 = (e2, t2, n) => {
+  const r2 = e2.text, a2 = r2.lastIndexOf("/"), m2 = r2.substring(1, a2), T = r2.substring(a2 + 1);
+  t2.emit(i$2.LOAD_REGEX, { pattern: m2, flags: T });
+}, d$3 = (e2, t2, n) => {
+  e2.text === "undefined" ? t2.emit(i$2.PUSH_UNDEFINED) : t2.emit(i$2.LOAD, e2.text);
+}, w$1 = (e2, t2, { compileExpression: n }) => {
+  t2.emit(i$2.ARRAY_NEW), e2.elements.forEach((r2) => {
+    n(r2), t2.emit(i$2.ARRAY_PUSH);
   });
-}, M$2 = (e2, t2, { compileExpression: i2 }) => {
-  i2(e2.expression);
-}, Y = (e2, t2, { compileExpression: i2 }) => {
-  e2.name.text === "length" ? (i2(e2.expression), t2.emit(n.LENGTH)) : (i2(e2.expression), t2.emit(n.PUSH, e2.name.text), t2.emit(n.PROPERTY_GET));
-}, J = (e2, t2, { compileExpression: i2, reportError: r2 }) => {
-  i2(e2.expression), e2.argumentExpression ? i2(e2.argumentExpression) : r2(e2, "Element access requires an index expression"), t2.emit(n.ARRAY_GET);
-}, w$1 = (e2, t2, { compileExpression: i2 }) => {
+}, O = (e2, t2, { compileExpression: n }) => {
+  n(e2.expression);
+}, q = (e2, t2, { compileExpression: n }) => {
+  e2.name.text === "length" ? (n(e2.expression), t2.emit(i$2.LENGTH)) : (n(e2.expression), t2.emit(i$2.PUSH, e2.name.text), t2.emit(i$2.PROPERTY_GET));
+}, V$1 = (e2, t2, { compileExpression: n, reportError: r2 }) => {
+  n(e2.expression), e2.argumentExpression ? n(e2.argumentExpression) : r2(e2, "Element access requires an index expression"), t2.emit(i$2.ARRAY_GET);
+}, W$1 = (e2, t2, { compileExpression: n }) => {
   switch (e2.operator) {
     case s__namespace.SyntaxKind.ExclamationToken:
-      i2(e2.operand), t2.emit(n.NOT);
+      n(e2.operand), t2.emit(i$2.NOT);
       break;
     case s__namespace.SyntaxKind.MinusToken:
-      i2(e2.operand), t2.emit(n.UNARY_MINUS);
+      n(e2.operand), t2.emit(i$2.UNARY_MINUS);
       break;
     case s__namespace.SyntaxKind.PlusToken:
-      i2(e2.operand), t2.emit(n.UNARY_PLUS);
+      n(e2.operand), t2.emit(i$2.UNARY_PLUS);
       break;
     case s__namespace.SyntaxKind.PlusPlusToken:
-      s__namespace.isIdentifier(e2.operand) && (t2.emit(n.PUSH, e2.operand.text), t2.emit(n.INC, false));
+      s__namespace.isIdentifier(e2.operand) && (t2.emit(i$2.PUSH, e2.operand.text), t2.emit(i$2.INC, false));
       break;
     case s__namespace.SyntaxKind.MinusMinusToken:
-      s__namespace.isIdentifier(e2.operand) && (t2.emit(n.PUSH, e2.operand.text), t2.emit(n.DEC, false));
+      s__namespace.isIdentifier(e2.operand) && (t2.emit(i$2.PUSH, e2.operand.text), t2.emit(i$2.DEC, false));
       break;
   }
-}, B$1 = (e2, t2, { compileExpression: i2 }) => {
+}, j$2 = (e2, t2, { compileExpression: n }) => {
   switch (e2.operator) {
     case s__namespace.SyntaxKind.PlusPlusToken:
-      s__namespace.isIdentifier(e2.operand) && (t2.emit(n.PUSH, e2.operand.text), t2.emit(n.INC, true));
+      s__namespace.isIdentifier(e2.operand) && (t2.emit(i$2.PUSH, e2.operand.text), t2.emit(i$2.INC, true));
       break;
     case s__namespace.SyntaxKind.MinusMinusToken:
-      s__namespace.isIdentifier(e2.operand) && (t2.emit(n.PUSH, e2.operand.text), t2.emit(n.DEC, true));
+      s__namespace.isIdentifier(e2.operand) && (t2.emit(i$2.PUSH, e2.operand.text), t2.emit(i$2.DEC, true));
       break;
   }
-}, q = (e2, t2, { compileExpression: i2 }) => {
+}, X = (e2, t2, { compileExpression: n }) => {
   const r2 = e2.operatorToken.kind;
-  switch (i2(e2.left), i2(e2.right), r2) {
+  switch (n(e2.left), n(e2.right), r2) {
     case s__namespace.SyntaxKind.PlusToken:
-      t2.emit(n.ADD);
+      t2.emit(i$2.ADD);
       break;
     case s__namespace.SyntaxKind.MinusToken:
-      t2.emit(n.SUB);
+      t2.emit(i$2.SUB);
       break;
     case s__namespace.SyntaxKind.AsteriskToken:
-      t2.emit(n.MUL);
+      t2.emit(i$2.MUL);
       break;
     case s__namespace.SyntaxKind.SlashToken:
-      t2.emit(n.DIV);
+      t2.emit(i$2.DIV);
       break;
     case s__namespace.SyntaxKind.PercentToken:
-      t2.emit(n.MOD);
+      t2.emit(i$2.MOD);
       break;
     case s__namespace.SyntaxKind.EqualsEqualsToken:
-      t2.emit(n.EQ);
+      t2.emit(i$2.EQ);
       break;
     case s__namespace.SyntaxKind.ExclamationEqualsToken:
-      t2.emit(n.NEQ);
+      t2.emit(i$2.NEQ);
       break;
     case s__namespace.SyntaxKind.LessThanToken:
-      t2.emit(n.LT);
+      t2.emit(i$2.LT);
       break;
     case s__namespace.SyntaxKind.GreaterThanToken:
-      t2.emit(n.GT);
+      t2.emit(i$2.GT);
       break;
     case s__namespace.SyntaxKind.LessThanEqualsToken:
-      t2.emit(n.LTE);
+      t2.emit(i$2.LTE);
       break;
     case s__namespace.SyntaxKind.GreaterThanEqualsToken:
-      t2.emit(n.GTE);
+      t2.emit(i$2.GTE);
       break;
     case s__namespace.SyntaxKind.EqualsEqualsEqualsToken:
-      t2.emit(n.EQ_STRICT);
+      t2.emit(i$2.EQ_STRICT);
       break;
     case s__namespace.SyntaxKind.ExclamationEqualsEqualsToken:
-      t2.emit(n.NEQ_STRICT);
+      t2.emit(i$2.NEQ_STRICT);
       break;
     case s__namespace.SyntaxKind.AmpersandAmpersandToken:
-      t2.emit(n.AND);
+      t2.emit(i$2.AND);
       break;
     case s__namespace.SyntaxKind.BarBarToken:
-      t2.emit(n.OR);
+      t2.emit(i$2.OR);
       break;
   }
-}, W$1 = (e2, t2, { compileExpression: i2 }) => {
-  i2(e2.condition);
-  const r2 = t2.emit(n.JUMP_IF_FALSE, -1);
-  i2(e2.whenTrue);
-  const a2 = t2.emit(n.JUMP, -1), m2 = t2.currentAddress();
-  t2.patchJump(r2, m2), i2(e2.whenFalse);
-  const T2 = t2.currentAddress();
-  t2.patchJump(a2, T2);
-}, C$1 = (e2, t2, { compileExpression: i2 }) => {
-  i2(e2.expression), t2.emit(n.TYPEOF);
-}, V = (e2, t2, { compileExpression: i2, reportError: r2 }) => {
+}, v = (e2, t2, { compileExpression: n }) => {
+  n(e2.condition);
+  const r2 = t2.emit(i$2.JUMP_IF_FALSE, -1);
+  n(e2.whenTrue);
+  const a2 = t2.emit(i$2.JUMP, -1), m2 = t2.currentAddress();
+  t2.patchJump(r2, m2), n(e2.whenFalse);
+  const T = t2.currentAddress();
+  t2.patchJump(a2, T);
+}, z = (e2, t2, { compileExpression: n }) => {
+  n(e2.expression), t2.emit(i$2.TYPEOF);
+}, Q$1 = (e2, t2, { compileExpression: n, reportError: r2 }) => {
   if (s__namespace.isPropertyAccessExpression(e2.expression) && s__namespace.isIdentifier(e2.expression.expression) && e2.expression.expression.text === "fs") {
     const a2 = e2.expression.name.text;
     if (a2 === "listFiles")
-      e2.arguments.length > 0 ? i2(e2.arguments[0]) : t2.emit(n.PUSH, "."), e2.arguments.length > 1 && i2(e2.arguments[1]), t2.emit(n.FS_LIST_FILES);
+      e2.arguments.length > 0 ? n(e2.arguments[0]) : t2.emit(i$2.PUSH, "."), e2.arguments.length > 1 && n(e2.arguments[1]), t2.emit(i$2.FS_LIST_FILES);
     else if (a2 === "readFile")
-      e2.arguments.length > 0 ? (i2(e2.arguments[0]), t2.emit(n.FS_READ_FILE)) : r2(e2, "fs.readFile() requires a path argument");
+      e2.arguments.length > 0 ? (n(e2.arguments[0]), t2.emit(i$2.FS_READ_FILE)) : r2(e2, "fs.readFile() requires a path argument");
     else if (a2 === "writeFile") {
       if (e2.arguments.length < 2) {
         r2(e2, "fs.writeFile() requires path and content arguments");
         return;
       }
-      i2(e2.arguments[0]), i2(e2.arguments[1]), t2.emit(n.FS_WRITE_FILE);
+      n(e2.arguments[0]), n(e2.arguments[1]), t2.emit(i$2.FS_WRITE_FILE);
     } else
       r2(e2, `Unsupported fs method: ${a2}`);
   } else if (s__namespace.isPropertyAccessExpression(e2.expression) && s__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(n.JSON_PARSE);
+    e2.arguments.length > 0 && n(e2.arguments[0]), t2.emit(i$2.JSON_PARSE);
   else if (s__namespace.isPropertyAccessExpression(e2.expression) && s__namespace.isIdentifier(e2.expression.expression) && e2.expression.expression.text === "JSON" && e2.expression.name.text === "stringify")
-    e2.arguments.length > 0 ? i2(e2.arguments[0]) : t2.emit(n.PUSH_UNDEFINED), t2.emit(n.JSON_STRINGIFY);
-  else if (s__namespace.isIdentifier(e2.expression) && e2.expression.text === "CC")
-    e2.arguments.length > 0 && i2(e2.arguments[0]), t2.emit(n.CC);
+    e2.arguments.length > 0 ? n(e2.arguments[0]) : t2.emit(i$2.PUSH_UNDEFINED), t2.emit(i$2.JSON_STRINGIFY);
+  else if (s__namespace.isPropertyAccessExpression(e2.expression) && s__namespace.isIdentifier(e2.expression.expression) && e2.expression.expression.text === "Object" && e2.expression.name.text === "keys") {
+    if (e2.arguments.length !== 1) {
+      r2(e2, "Object.keys() requires exactly one argument");
+      return;
+    }
+    n(e2.arguments[0]), t2.emit(i$2.OBJECT_KEYS);
+  } else if (s__namespace.isIdentifier(e2.expression) && e2.expression.text === "CC")
+    e2.arguments.length > 0 && n(e2.arguments[0]), t2.emit(i$2.CC);
   else if (s__namespace.isPropertyAccessExpression(e2.expression)) {
     const a2 = e2.expression.name.text;
     if (a2 === "substring")
-      i2(e2.expression.expression), e2.arguments.length > 0 ? i2(e2.arguments[0]) : t2.emit(n.PUSH, 0), e2.arguments.length > 1 && i2(e2.arguments[1]), t2.emit(n.STRING_SUBSTRING);
+      n(e2.expression.expression), e2.arguments.length > 0 ? n(e2.arguments[0]) : t2.emit(i$2.PUSH, 0), e2.arguments.length > 1 && n(e2.arguments[1]), t2.emit(i$2.STRING_SUBSTRING);
     else if (a2 === "indexOf")
-      i2(e2.expression.expression), e2.arguments.length > 0 ? i2(e2.arguments[0]) : t2.emit(n.PUSH, ""), t2.emit(n.STRING_INDEXOF);
+      n(e2.expression.expression), e2.arguments.length > 0 ? n(e2.arguments[0]) : t2.emit(i$2.PUSH, ""), t2.emit(i$2.STRING_INDEXOF);
     else if (a2 === "split")
-      i2(e2.expression.expression), e2.arguments.length > 0 ? i2(e2.arguments[0]) : t2.emit(n.PUSH, ""), t2.emit(n.STRING_SPLIT);
+      n(e2.expression.expression), e2.arguments.length > 0 ? n(e2.arguments[0]) : t2.emit(i$2.PUSH, ""), t2.emit(i$2.STRING_SPLIT);
     else if (a2 === "slice")
-      i2(e2.expression.expression), e2.arguments.length > 0 ? i2(e2.arguments[0]) : t2.emit(n.PUSH, 0), e2.arguments.length > 1 ? i2(e2.arguments[1]) : t2.emit(n.PUSH_UNDEFINED), t2.emit(n.STRING_SLICE);
+      n(e2.expression.expression), e2.arguments.length > 0 ? n(e2.arguments[0]) : t2.emit(i$2.PUSH, 0), e2.arguments.length > 1 ? n(e2.arguments[1]) : t2.emit(i$2.PUSH_UNDEFINED), t2.emit(i$2.STRING_SLICE);
     else if (a2 === "join")
-      i2(e2.expression.expression), e2.arguments.length > 0 ? i2(e2.arguments[0]) : t2.emit(n.PUSH, ","), t2.emit(n.ARRAY_JOIN);
+      n(e2.expression.expression), e2.arguments.length > 0 ? n(e2.arguments[0]) : t2.emit(i$2.PUSH, ","), t2.emit(i$2.ARRAY_JOIN);
     else if (a2 === "charAt")
-      i2(e2.expression.expression), e2.arguments.length > 0 ? i2(e2.arguments[0]) : t2.emit(n.PUSH, 0), t2.emit(n.STRING_CHARAT);
+      n(e2.expression.expression), e2.arguments.length > 0 ? n(e2.arguments[0]) : t2.emit(i$2.PUSH, 0), t2.emit(i$2.STRING_CHARAT);
     else if (a2 === "toUpperCase")
-      i2(e2.expression.expression), t2.emit(n.STRING_TOUPPERCASE);
+      n(e2.expression.expression), t2.emit(i$2.STRING_TOUPPERCASE);
     else if (a2 === "toLowerCase")
-      i2(e2.expression.expression), t2.emit(n.STRING_TOLOWERCASE);
+      n(e2.expression.expression), t2.emit(i$2.STRING_TOLOWERCASE);
     else if (a2 === "toString")
-      i2(e2.expression.expression), t2.emit(n.TO_STRING);
+      n(e2.expression.expression), t2.emit(i$2.TO_STRING);
     else if (a2 === "includes")
-      i2(e2.expression.expression), e2.arguments.length > 0 ? i2(e2.arguments[0]) : t2.emit(n.PUSH, ""), t2.emit(n.STRING_INCLUDES);
+      n(e2.expression.expression), e2.arguments.length > 0 ? n(e2.arguments[0]) : t2.emit(i$2.PUSH, ""), t2.emit(i$2.STRING_INCLUDES);
     else if (a2 === "endsWith")
-      i2(e2.expression.expression), e2.arguments.length > 0 ? i2(e2.arguments[0]) : t2.emit(n.PUSH, ""), t2.emit(n.STRING_ENDS_WITH);
+      n(e2.expression.expression), e2.arguments.length > 0 ? n(e2.arguments[0]) : t2.emit(i$2.PUSH, ""), t2.emit(i$2.STRING_ENDS_WITH);
     else if (a2 === "startsWith")
-      i2(e2.expression.expression), e2.arguments.length > 0 ? i2(e2.arguments[0]) : t2.emit(n.PUSH, ""), t2.emit(n.STRING_STARTS_WITH);
+      n(e2.expression.expression), e2.arguments.length > 0 ? n(e2.arguments[0]) : t2.emit(i$2.PUSH, ""), t2.emit(i$2.STRING_STARTS_WITH);
     else if (a2 === "trim")
-      i2(e2.expression.expression), t2.emit(n.STRING_TRIM);
+      n(e2.expression.expression), t2.emit(i$2.STRING_TRIM);
     else if (a2 === "trimStart")
-      i2(e2.expression.expression), t2.emit(n.STRING_TRIM_START);
+      n(e2.expression.expression), t2.emit(i$2.STRING_TRIM_START);
     else if (a2 === "trimEnd")
-      i2(e2.expression.expression), t2.emit(n.STRING_TRIM_END);
+      n(e2.expression.expression), t2.emit(i$2.STRING_TRIM_END);
     else if (a2 === "replace")
-      i2(e2.expression.expression), e2.arguments.length > 0 ? i2(e2.arguments[0]) : t2.emit(n.PUSH, ""), e2.arguments.length > 1 ? i2(e2.arguments[1]) : t2.emit(n.PUSH, ""), t2.emit(n.STRING_REPLACE);
+      n(e2.expression.expression), e2.arguments.length > 0 ? n(e2.arguments[0]) : t2.emit(i$2.PUSH, ""), e2.arguments.length > 1 ? n(e2.arguments[1]) : t2.emit(i$2.PUSH, ""), t2.emit(i$2.STRING_REPLACE);
     else if (a2 === "replaceAll")
-      i2(e2.expression.expression), e2.arguments.length > 0 ? i2(e2.arguments[0]) : t2.emit(n.PUSH, ""), e2.arguments.length > 1 ? i2(e2.arguments[1]) : t2.emit(n.PUSH, ""), t2.emit(n.STRING_REPLACE_ALL);
+      n(e2.expression.expression), e2.arguments.length > 0 ? n(e2.arguments[0]) : t2.emit(i$2.PUSH, ""), e2.arguments.length > 1 ? n(e2.arguments[1]) : t2.emit(i$2.PUSH, ""), t2.emit(i$2.STRING_REPLACE_ALL);
     else if (a2 === "lastIndexOf")
-      i2(e2.expression.expression), e2.arguments.length > 0 ? i2(e2.arguments[0]) : t2.emit(n.PUSH, ""), t2.emit(n.STRING_LAST_INDEX_OF);
+      n(e2.expression.expression), e2.arguments.length > 0 ? n(e2.arguments[0]) : t2.emit(i$2.PUSH, ""), t2.emit(i$2.STRING_LAST_INDEX_OF);
     else if (a2 === "repeat")
-      i2(e2.expression.expression), e2.arguments.length > 0 ? i2(e2.arguments[0]) : t2.emit(n.PUSH, 0), t2.emit(n.STRING_REPEAT);
+      n(e2.expression.expression), e2.arguments.length > 0 ? n(e2.arguments[0]) : t2.emit(i$2.PUSH, 0), t2.emit(i$2.STRING_REPEAT);
     else if (a2 === "padStart")
-      i2(e2.expression.expression), e2.arguments.length > 0 ? i2(e2.arguments[0]) : t2.emit(n.PUSH, 0), e2.arguments.length > 1 ? i2(e2.arguments[1]) : t2.emit(n.PUSH, " "), t2.emit(n.STRING_PAD_START);
+      n(e2.expression.expression), e2.arguments.length > 0 ? n(e2.arguments[0]) : t2.emit(i$2.PUSH, 0), e2.arguments.length > 1 ? n(e2.arguments[1]) : t2.emit(i$2.PUSH, " "), t2.emit(i$2.STRING_PAD_START);
     else if (a2 === "padEnd")
-      i2(e2.expression.expression), e2.arguments.length > 0 ? i2(e2.arguments[0]) : t2.emit(n.PUSH, 0), e2.arguments.length > 1 ? i2(e2.arguments[1]) : t2.emit(n.PUSH, " "), t2.emit(n.STRING_PAD_END);
+      n(e2.expression.expression), e2.arguments.length > 0 ? n(e2.arguments[0]) : t2.emit(i$2.PUSH, 0), e2.arguments.length > 1 ? n(e2.arguments[1]) : t2.emit(i$2.PUSH, " "), t2.emit(i$2.STRING_PAD_END);
     else if (a2 === "push")
-      i2(e2.expression.expression), e2.arguments.length > 0 ? i2(e2.arguments[0]) : t2.emit(n.PUSH_UNDEFINED), t2.emit(n.ARRAY_PUSH);
+      n(e2.expression.expression), e2.arguments.length > 0 ? n(e2.arguments[0]) : t2.emit(i$2.PUSH_UNDEFINED), t2.emit(i$2.ARRAY_PUSH);
     else
       throw new Error(`Method call '${a2}' is not supported`);
   } else
     throw new Error("Unsupported call expression");
-}, O = (e2, t2, { compileExpression: i2 }) => {
-  t2.emit(n.OBJECT_CREATE);
+}, $$1 = (e2, t2, { compileExpression: n }) => {
+  t2.emit(i$2.OBJECT_CREATE);
   for (const r2 of e2.properties)
     if (s__namespace.isPropertyAssignment(r2)) {
       let a2;
@@ -462,92 +571,93 @@ const A = (e2, t2, { compileExpression: i2, compileStatement: r2 }) => {
         a2 = r2.name.text;
       else
         throw new Error("Computed property names are not supported");
-      t2.emit(n.PUSH, a2), i2(r2.initializer), t2.emit(n.PROPERTY_SET);
+      t2.emit(i$2.PUSH, a2), n(r2.initializer), t2.emit(i$2.PROPERTY_SET);
     } else if (s__namespace.isShorthandPropertyAssignment(r2)) {
       const a2 = r2.name.text;
-      t2.emit(n.PUSH, a2), t2.emit(n.LOAD, a2), t2.emit(n.PROPERTY_SET);
+      t2.emit(i$2.PUSH, a2), t2.emit(i$2.LOAD, a2), t2.emit(i$2.PROPERTY_SET);
     } else
       throw new Error("Unsupported property type in object literal");
-}, Q$1 = {
-  [s__namespace.SyntaxKind.StringLiteral]: k,
-  [s__namespace.SyntaxKind.NumericLiteral]: G,
-  [s__namespace.SyntaxKind.TrueKeyword]: D$1,
-  [s__namespace.SyntaxKind.FalseKeyword]: F$1,
-  [s__namespace.SyntaxKind.NullKeyword]: K,
-  [s__namespace.SyntaxKind.Identifier]: H,
-  [s__namespace.SyntaxKind.ArrayLiteralExpression]: b$2,
-  [s__namespace.SyntaxKind.BinaryExpression]: q,
-  [s__namespace.SyntaxKind.PrefixUnaryExpression]: w$1,
-  [s__namespace.SyntaxKind.PostfixUnaryExpression]: B$1,
-  [s__namespace.SyntaxKind.CallExpression]: V,
-  [s__namespace.SyntaxKind.PropertyAccessExpression]: Y,
-  [s__namespace.SyntaxKind.ElementAccessExpression]: J,
-  [s__namespace.SyntaxKind.ConditionalExpression]: W$1,
-  [s__namespace.SyntaxKind.TypeOfExpression]: C$1,
-  [s__namespace.SyntaxKind.ParenthesizedExpression]: M$2,
-  [s__namespace.SyntaxKind.ObjectLiteralExpression]: O
+}, Z$1 = {
+  [s__namespace.SyntaxKind.StringLiteral]: J,
+  [s__namespace.SyntaxKind.NumericLiteral]: H,
+  [s__namespace.SyntaxKind.TrueKeyword]: M$1,
+  [s__namespace.SyntaxKind.FalseKeyword]: Y,
+  [s__namespace.SyntaxKind.NullKeyword]: B$1,
+  [s__namespace.SyntaxKind.RegularExpressionLiteral]: C$2,
+  [s__namespace.SyntaxKind.Identifier]: d$3,
+  [s__namespace.SyntaxKind.ArrayLiteralExpression]: w$1,
+  [s__namespace.SyntaxKind.BinaryExpression]: X,
+  [s__namespace.SyntaxKind.PrefixUnaryExpression]: W$1,
+  [s__namespace.SyntaxKind.PostfixUnaryExpression]: j$2,
+  [s__namespace.SyntaxKind.CallExpression]: Q$1,
+  [s__namespace.SyntaxKind.PropertyAccessExpression]: q,
+  [s__namespace.SyntaxKind.ElementAccessExpression]: V$1,
+  [s__namespace.SyntaxKind.ConditionalExpression]: v,
+  [s__namespace.SyntaxKind.TypeOfExpression]: z,
+  [s__namespace.SyntaxKind.ParenthesizedExpression]: O,
+  [s__namespace.SyntaxKind.ObjectLiteralExpression]: $$1
 };
-function X(e2) {
-  const t2 = [], i2 = f$3(e2);
-  if (i2.errors.length > 0)
+function te$1(e2) {
+  const t2 = [], n = A(e2);
+  if (n.errors.length > 0)
     return {
       success: false,
       bytecode: [],
-      errors: i2.errors.map((S) => ({
+      errors: n.errors.map((S) => ({
         message: S,
         line: 0,
         character: 0
       }))
     };
-  const r2 = new I(), a2 = s__namespace.createSourceFile("program.ts", e2, s__namespace.ScriptTarget.Latest, true), m2 = {
-    compileStatement: T2,
-    compileExpression: l2,
-    reportError: (S, c2) => {
-      const { line: R, character: u2 } = a2.getLineAndCharacterOfPosition(S.getStart());
+  const r2 = new P(), a2 = s__namespace.createSourceFile("program.ts", e2, s__namespace.ScriptTarget.Latest, true), m2 = {
+    compileStatement: T,
+    compileExpression: c2,
+    reportError: (S, u2) => {
+      const { line: l, character: x2 } = a2.getLineAndCharacterOfPosition(S.getStart());
       throw t2.push({
-        message: c2,
-        line: R + 1,
+        message: u2,
+        line: l + 1,
         // TypeScript uses 0-based lines
-        character: u2 + 1
+        character: x2 + 1
         // TypeScript uses 0-based columns
-      }), new Error(c2);
+      }), new Error(u2);
     }
   };
-  function T2(S) {
-    const c2 = L[S.kind];
-    if (c2)
-      c2(S, r2, m2);
+  function T(S) {
+    const u2 = K[S.kind];
+    if (u2)
+      u2(S, r2, m2);
     else {
-      const { line: R, character: u2 } = a2.getLineAndCharacterOfPosition(S.getStart());
+      const { line: l, character: x2 } = a2.getLineAndCharacterOfPosition(S.getStart());
       t2.push({
         message: `Unsupported statement: ${s__namespace.SyntaxKind[S.kind]}`,
-        line: R + 1,
-        character: u2 + 1
+        line: l + 1,
+        character: x2 + 1
       });
     }
   }
-  function l2(S) {
-    const c2 = Q$1[S.kind];
-    if (c2)
-      c2(S, r2, m2);
+  function c2(S) {
+    const u2 = Z$1[S.kind];
+    if (u2)
+      u2(S, r2, m2);
     else {
-      const { line: R, character: u2 } = a2.getLineAndCharacterOfPosition(S.getStart());
+      const { line: l, character: x2 } = a2.getLineAndCharacterOfPosition(S.getStart());
       t2.push({
         message: `Unsupported expression: ${s__namespace.SyntaxKind[S.kind]}`,
-        line: R + 1,
-        character: u2 + 1
+        line: l + 1,
+        character: x2 + 1
       });
     }
   }
   return a2.forEachChild((S) => {
-    var c2;
-    s__namespace.isFunctionDeclaration(S) && ((c2 = S.name) == null ? void 0 : c2.text) === "main" && S.body && S.body.statements.forEach((R) => {
+    var u2;
+    s__namespace.isFunctionDeclaration(S) && ((u2 = S.name) == null ? void 0 : u2.text) === "main" && S.body && S.body.statements.forEach((l) => {
       try {
-        T2(R);
+        T(l);
       } catch {
       }
     });
-  }), r2.emit(n.HALT), {
+  }), r2.emit(i$2.HALT), {
     success: t2.length === 0,
     bytecode: r2.getBytecode(),
     errors: t2
@@ -577,7 +687,7 @@ function y(r2) {
 function u$1(r2) {
   return r2 !== null && typeof r2 == "object" && "type" in r2 && r2.type === "array-ref";
 }
-function b$1(r2) {
+function b(r2) {
   return r2 !== null && typeof r2 == "object" && "type" in r2 && r2.type === "object-ref";
 }
 function p$1(r2) {
@@ -586,8 +696,8 @@ function p$1(r2) {
 function j$1(r2) {
   return e(r2) ? r2 : f$2(r2) || c(r2) ? false : i$1(r2) ? r2 !== 0 : t(r2) ? r2 !== "" : o(r2) || y(r2) ? true : !!r2;
 }
-function d$1(r2) {
-  return t(r2) ? "string" : i$1(r2) ? "number" : e(r2) ? "boolean" : f$2(r2) ? "null" : c(r2) ? "undefined" : o(r2) || u$1(r2) ? "array" : y(r2) || b$1(r2) ? "object" : "unknown";
+function d$2(r2) {
+  return t(r2) ? "string" : i$1(r2) ? "number" : e(r2) ? "boolean" : f$2(r2) ? "null" : c(r2) ? "undefined" : o(r2) || u$1(r2) ? "array" : y(r2) || b(r2) ? "object" : "unknown";
 }
 function m(r2) {
   if (i$1(r2)) return r2;
@@ -595,23 +705,23 @@ function m(r2) {
   if (f$2(r2)) return 0;
   if (c(r2)) return NaN;
   if (t(r2)) {
-    const n2 = r2.trim();
-    return n2 === "" ? 0 : Number(n2);
+    const n = r2.trim();
+    return n === "" ? 0 : Number(n);
   }
   return o(r2) ? NaN : Number(r2);
 }
-function s(r2 = [], n2) {
-  return n2 ? { type: "array", elements: r2, properties: n2 } : { type: "array", elements: r2 };
+function s(r2 = [], n) {
+  return n ? { type: "array", elements: r2, properties: n } : { type: "array", elements: r2 };
 }
-function C() {
+function C$1() {
   return { type: "undefined" };
 }
-function M$1(r2 = {}) {
+function M(r2 = {}) {
   return { type: "object", properties: r2 };
 }
-var d = Object.defineProperty;
-var h = (s2, t2, n2) => t2 in s2 ? d(s2, t2, { enumerable: true, configurable: true, writable: true, value: n2 }) : s2[t2] = n2;
-var a = (s2, t2, n2) => h(s2, typeof t2 != "symbol" ? t2 + "" : t2, n2);
+var d$1 = Object.defineProperty;
+var h = (s2, t2, n) => t2 in s2 ? d$1(s2, t2, { enumerable: true, configurable: true, writable: true, value: n }) : s2[t2] = n;
+var a = (s2, t2, n) => h(s2, typeof t2 != "symbol" ? t2 + "" : t2, n);
 class p {
   constructor(t2) {
     a(this, "connected", false);
@@ -624,7 +734,7 @@ class p {
     return r__namespace.join(this.dataDir, "metadata.json");
   }
   async connect() {
-    await x$2.promises.mkdir(this.dataDir, { recursive: true }), await x$2.promises.mkdir(this.programsDir, { recursive: true }), await x$2.promises.mkdir(this.executionsDir, { recursive: true }), await x$2.promises.mkdir(this.outputsDir, { recursive: true }), this.connected = true;
+    await N$1.promises.mkdir(this.dataDir, { recursive: true }), await N$1.promises.mkdir(this.programsDir, { recursive: true }), await N$1.promises.mkdir(this.executionsDir, { recursive: true }), await N$1.promises.mkdir(this.outputsDir, { recursive: true }), this.connected = true;
   }
   async disconnect() {
     this.connected = false;
@@ -634,14 +744,14 @@ class p {
   }
   async saveProgram(t2) {
     if (!this.connected) throw new Error("Not connected");
-    const n2 = r__namespace.join(this.programsDir, `${t2.id}.json`), e2 = JSON.stringify(t2, null, 2);
-    await x$2.promises.writeFile(n2, e2, "utf-8");
+    const n = r__namespace.join(this.programsDir, `${t2.id}.json`), e2 = JSON.stringify(t2, null, 2);
+    await N$1.promises.writeFile(n, e2, "utf-8");
   }
   async getProgram(t2) {
     if (!this.connected) throw new Error("Not connected");
-    const n2 = r__namespace.join(this.programsDir, `${t2}.json`);
+    const n = r__namespace.join(this.programsDir, `${t2}.json`);
     try {
-      const e2 = await x$2.promises.readFile(n2, "utf-8"), o2 = JSON.parse(e2);
+      const e2 = await N$1.promises.readFile(n, "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")
@@ -651,14 +761,14 @@ class p {
   }
   async saveExecution(t2) {
     if (!this.connected) throw new Error("Not connected");
-    const n2 = r__namespace.join(this.executionsDir, `${t2.id}.json`), e2 = JSON.stringify(t2, null, 2);
-    await x$2.promises.writeFile(n2, e2, "utf-8");
+    const n = r__namespace.join(this.executionsDir, `${t2.id}.json`), e2 = JSON.stringify(t2, null, 2);
+    await N$1.promises.writeFile(n, e2, "utf-8");
   }
   async getExecution(t2) {
     if (!this.connected) throw new Error("Not connected");
-    const n2 = r__namespace.join(this.executionsDir, `${t2}.json`);
+    const n = r__namespace.join(this.executionsDir, `${t2}.json`);
     try {
-      const e2 = await x$2.promises.readFile(n2, "utf-8"), o2 = JSON.parse(e2);
+      const e2 = await N$1.promises.readFile(n, "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")
@@ -666,18 +776,18 @@ class p {
       throw e2;
     }
   }
-  async appendOutput(t2, n2) {
+  async appendOutput(t2, n) {
     if (!this.connected) throw new Error("Not connected");
-    const e2 = r__namespace.join(this.outputsDir, `${t2}.output`), o2 = n2.join(`
+    const e2 = r__namespace.join(this.outputsDir, `${t2}.output`), o2 = n.join(`
 `) + `
 `;
-    await x$2.promises.appendFile(e2, o2, "utf-8");
+    await N$1.promises.appendFile(e2, o2, "utf-8");
   }
   async getOutput(t2) {
     if (!this.connected) throw new Error("Not connected");
-    const n2 = r__namespace.join(this.outputsDir, `${t2}.output`);
+    const n = r__namespace.join(this.outputsDir, `${t2}.output`);
     try {
-      return (await x$2.promises.readFile(n2, "utf-8")).split(`
+      return (await N$1.promises.readFile(n, "utf-8")).split(`
 `).filter((o2) => o2.length > 0);
     } catch (e2) {
       if (e2.code === "ENOENT")
@@ -687,18 +797,18 @@ class p {
   }
   async listExecutions() {
     if (!this.connected) throw new Error("Not connected");
-    const t2 = await x$2.promises.readdir(this.executionsDir), n2 = [];
+    const t2 = await N$1.promises.readdir(this.executionsDir), n = [];
     for (const e2 of t2)
       if (e2.endsWith(".json")) {
         const o2 = e2.slice(0, -5), i2 = await this.getExecution(o2);
-        i2 && n2.push(i2);
+        i2 && n.push(i2);
       }
-    return n2;
+    return n;
   }
   async getCurrentExecutionId() {
     if (!this.connected) throw new Error("Not connected");
     try {
-      const t2 = await x$2.promises.readFile(this.metadataFile, "utf-8");
+      const t2 = await N$1.promises.readFile(this.metadataFile, "utf-8");
       return JSON.parse(t2).currentExecutionId || null;
     } catch (t2) {
       if (t2.code === "ENOENT")
@@ -708,20 +818,20 @@ class p {
   }
   async setCurrentExecutionId(t2) {
     if (!this.connected) throw new Error("Not connected");
-    const n2 = { currentExecutionId: t2 };
-    await x$2.promises.writeFile(this.metadataFile, JSON.stringify(n2, null, 2), "utf-8");
+    const n = { currentExecutionId: t2 };
+    await N$1.promises.writeFile(this.metadataFile, JSON.stringify(n, null, 2), "utf-8");
   }
   async deleteExecution(t2) {
     if (!this.connected) throw new Error("Not connected");
-    const n2 = r__namespace.join(this.executionsDir, `${t2}.json`);
+    const n = r__namespace.join(this.executionsDir, `${t2}.json`);
     try {
-      await x$2.promises.unlink(n2);
+      await N$1.promises.unlink(n);
     } catch (i2) {
       if (i2.code !== "ENOENT") throw i2;
     }
     const e2 = r__namespace.join(this.outputsDir, `${t2}.output`);
     try {
-      await x$2.promises.unlink(e2);
+      await N$1.promises.unlink(e2);
     } catch (i2) {
       if (i2.code !== "ENOENT") throw i2;
     }
@@ -729,19 +839,19 @@ class p {
   }
   async listPrograms() {
     if (!this.connected) throw new Error("Not connected");
-    const t2 = await x$2.promises.readdir(this.programsDir), n2 = [];
+    const t2 = await N$1.promises.readdir(this.programsDir), n = [];
     for (const e2 of t2)
       if (e2.endsWith(".json")) {
         const o2 = e2.slice(0, -5), i2 = await this.getProgram(o2);
-        i2 && n2.push(i2);
+        i2 && n.push(i2);
       }
-    return n2;
+    return n;
   }
   async deleteProgram(t2) {
     if (!this.connected) throw new Error("Not connected");
-    const n2 = r__namespace.join(this.programsDir, `${t2}.json`);
+    const n = r__namespace.join(this.programsDir, `${t2}.json`);
     try {
-      await x$2.promises.unlink(n2);
+      await N$1.promises.unlink(n);
     } catch (e2) {
       if (e2.code !== "ENOENT") throw e2;
     }
@@ -770,7 +880,7 @@ let f$1 = class f {
   }
   async getCollections() {
     if (!this.db) throw new Error("Not connected to database");
-    return (await this.db.listCollections().toArray()).map((n2) => n2.name);
+    return (await this.db.listCollections().toArray()).map((n) => n.name);
   }
   getCollection(t2) {
     if (!this.db) throw new Error("Not connected to database");
@@ -796,12 +906,12 @@ let f$1 = class f {
   async getExecution(t2) {
     return await this.getCollection("executions").findOne({ id: t2 });
   }
-  async appendOutput(t2, n2) {
+  async appendOutput(t2, n) {
     const e2 = this.getCollection("outputs");
     await e2.findOne({ executionId: t2 }) ? await e2.updateOne(
       { executionId: t2 },
-      { $push: { lines: { $each: n2 } } }
-    ) : await e2.insertOne({ executionId: t2, lines: n2 });
+      { $push: { lines: { $each: n } } }
+    ) : await e2.insertOne({ executionId: t2, lines: n });
   }
   async getOutput(t2) {
     const e2 = await this.getCollection("outputs").findOne({ executionId: t2 });
@@ -811,8 +921,8 @@ let f$1 = class f {
     return await this.getCollection("executions").find({}).toArray();
   }
   async getCurrentExecutionId() {
-    const n2 = await this.getCollection("metadata").findOne({ _id: "current" });
-    return (n2 == null ? void 0 : n2.currentExecutionId) || null;
+    const n = await this.getCollection("metadata").findOne({ _id: "current" });
+    return (n == null ? void 0 : n.currentExecutionId) || null;
   }
   async setCurrentExecutionId(t2) {
     await this.getCollection("metadata").replaceOne(
@@ -823,7 +933,7 @@ let f$1 = class f {
   }
   async deleteExecution(t2) {
     var o2;
-    let n2 = true;
+    let n = true;
     const e2 = this.client.startSession();
     try {
       await e2.withTransaction(async () => {
@@ -835,13 +945,13 @@ let f$1 = class f {
       });
     } catch (i2) {
       if ((o2 = i2 == null ? void 0 : i2.message) != null && o2.includes("Transaction numbers are only allowed"))
-        n2 = false;
+        n = false;
       else
         throw i2;
     } finally {
       await e2.endSession();
     }
-    n2 || (await this.getCollection("executions").deleteOne({ id: t2 }), await this.getCollection("outputs").deleteMany({ executionId: t2 }), await this.getCurrentExecutionId() === t2 && await this.setCurrentExecutionId(null));
+    n || (await this.getCollection("executions").deleteOne({ id: t2 }), await this.getCollection("outputs").deleteMany({ executionId: t2 }), await this.getCurrentExecutionId() === t2 && await this.setCurrentExecutionId(null));
   }
   async listPrograms() {
     return await this.getCollection("programs").find({}).toArray();
@@ -852,8 +962,8 @@ let f$1 = class f {
 };
 class E {
   static create(t2) {
-    const n2 = (t2 == null ? void 0 : t2.type) || process.env.CVM_STORAGE_TYPE || "file";
-    switch (n2) {
+    const n = (t2 == null ? void 0 : t2.type) || process.env.CVM_STORAGE_TYPE || "file";
+    switch (n) {
       case "file": {
         const e2 = (t2 == null ? void 0 : t2.dataDir) || process.env.CVM_DATA_DIR || ".cvm";
         return new p(e2);
@@ -863,74 +973,74 @@ class E {
         return new f$1(e2);
       }
       default:
-        throw new Error(`Unsupported storage type: ${n2}`);
+        throw new Error(`Unsupported storage type: ${n}`);
     }
   }
 }
-var W = Object.defineProperty;
-var B = (e2, t2, r2) => t2 in e2 ? W(e2, t2, { enumerable: true, configurable: true, writable: true, value: r2 }) : e2[t2] = r2;
-var b = (e2, t2, r2) => B(e2, typeof t2 != "symbol" ? t2 + "" : t2, r2);
+var B = Object.defineProperty;
+var W = (e2, t2, r2) => t2 in e2 ? B(e2, t2, { enumerable: true, configurable: true, writable: true, value: r2 }) : e2[t2] = r2;
+var _ = (e2, t2, r2) => W(e2, typeof t2 != "symbol" ? t2 + "" : t2, r2);
 function Q(e2) {
   return !!(e2 && typeof e2 == "object" && "type" in e2 && "message" in e2);
 }
-function l(e2, t2) {
+function d(e2, t2) {
   return e2.stack.length < 1 ? {
     type: "RuntimeError",
     message: "Stack underflow",
     pc: e2.pc,
-    opcode: t2 || n.POP
+    opcode: t2 || i$2.POP
   } : e2.stack.pop();
 }
 const f2 = Q, Z = {
-  [n.ADD]: {
+  [i$2.ADD]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t$1) => {
-      const r2 = l(e2, t$1.op);
+      const r2 = d(e2, t$1.op);
       if (f2(r2)) return r2;
-      const o2 = l(e2, t$1.op);
-      if (f2(o2)) return o2;
-      if (t(o2) || t(r2))
-        e2.stack.push(p$1(o2) + p$1(r2));
+      const s2 = d(e2, t$1.op);
+      if (f2(s2)) return s2;
+      if (t(s2) || t(r2))
+        e2.stack.push(p$1(s2) + p$1(r2));
       else {
-        const s2 = m(o2), c2 = m(r2);
-        e2.stack.push(s2 + c2);
+        const o2 = m(s2), c2 = m(r2);
+        e2.stack.push(o2 + c2);
       }
     }
   },
-  [n.SUB]: {
+  [i$2.SUB]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t2) => {
-      const r2 = l(e2, t2.op);
+      const r2 = d(e2, t2.op);
       if (f2(r2)) return r2;
-      const o2 = l(e2, t2.op);
-      if (f2(o2)) return o2;
-      const s2 = m(o2), c2 = m(r2);
-      e2.stack.push(s2 - c2);
+      const s2 = d(e2, t2.op);
+      if (f2(s2)) return s2;
+      const o2 = m(s2), c2 = m(r2);
+      e2.stack.push(o2 - c2);
     }
   },
-  [n.MUL]: {
+  [i$2.MUL]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t2) => {
-      const r2 = l(e2, t2.op);
+      const r2 = d(e2, t2.op);
       if (f2(r2)) return r2;
-      const o2 = l(e2, t2.op);
-      if (f2(o2)) return o2;
-      const s2 = m(o2), c2 = m(r2);
-      e2.stack.push(s2 * c2);
+      const s2 = d(e2, t2.op);
+      if (f2(s2)) return s2;
+      const o2 = m(s2), c2 = m(r2);
+      e2.stack.push(o2 * c2);
     }
   },
-  [n.DIV]: {
+  [i$2.DIV]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t2) => {
-      const r2 = l(e2, t2.op);
+      const r2 = d(e2, t2.op);
       if (f2(r2)) return r2;
-      const o2 = l(e2, t2.op);
-      if (f2(o2)) return o2;
-      const s2 = m(o2), c2 = m(r2);
+      const s2 = d(e2, t2.op);
+      if (f2(s2)) return s2;
+      const o2 = m(s2), c2 = m(r2);
       if (c2 === 0)
         return {
           type: "DivisionByZero",
@@ -938,64 +1048,64 @@ const f2 = Q, Z = {
           pc: e2.pc,
           opcode: t2.op
         };
-      e2.stack.push(s2 / c2);
+      e2.stack.push(o2 / c2);
     }
   },
-  [n.MOD]: {
+  [i$2.MOD]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t2) => {
-      const r2 = l(e2, t2.op);
+      const r2 = d(e2, t2.op);
       if (f2(r2)) return r2;
-      const o2 = l(e2, t2.op);
-      if (f2(o2)) return o2;
-      const s2 = m(o2), c2 = m(r2);
-      e2.stack.push(s2 % c2);
+      const s2 = d(e2, t2.op);
+      if (f2(s2)) return s2;
+      const o2 = m(s2), c2 = m(r2);
+      e2.stack.push(o2 % c2);
     }
   },
-  [n.UNARY_MINUS]: {
+  [i$2.UNARY_MINUS]: {
     stackIn: 1,
     stackOut: 1,
     execute: (e2, t2) => {
-      const r2 = l(e2, t2.op);
+      const r2 = d(e2, t2.op);
       if (f2(r2)) return r2;
-      const o2 = m(r2);
-      e2.stack.push(-o2);
+      const s2 = m(r2);
+      e2.stack.push(-s2);
     }
   },
-  [n.UNARY_PLUS]: {
+  [i$2.UNARY_PLUS]: {
     stackIn: 1,
     stackOut: 1,
     execute: (e2, t2) => {
-      const r2 = l(e2, t2.op);
+      const r2 = d(e2, t2.op);
       if (f2(r2)) return r2;
-      const o2 = m(r2);
-      e2.stack.push(o2);
+      const s2 = m(r2);
+      e2.stack.push(s2);
     }
   }
 }, ee = {
-  [n.PUSH]: {
+  [i$2.PUSH]: {
     stackIn: 0,
     stackOut: 1,
     execute: (e2, t2) => {
       e2.stack.push(t2.arg);
     }
   },
-  [n.PUSH_UNDEFINED]: {
+  [i$2.PUSH_UNDEFINED]: {
     stackIn: 0,
     stackOut: 1,
     execute: (e2) => {
-      e2.stack.push(C());
+      e2.stack.push(C$1());
     }
   },
-  [n.POP]: {
+  [i$2.POP]: {
     stackIn: 1,
     stackOut: 0,
     execute: (e2) => {
       e2.stack.pop();
     }
   },
-  [n.DUP]: {
+  [i$2.DUP]: {
     stackIn: 1,
     stackOut: 2,
     execute: (e2, t2) => {
@@ -1003,24 +1113,24 @@ const f2 = Q, Z = {
       e2.stack.push(r2), e2.stack.push(r2);
     }
   },
-  [n.SWAP]: {
+  [i$2.SWAP]: {
     stackIn: 2,
     stackOut: 2,
     execute: (e2, t2) => {
-      const r2 = e2.stack.pop(), o2 = e2.stack.pop();
-      e2.stack.push(r2), e2.stack.push(o2);
+      const r2 = e2.stack.pop(), s2 = e2.stack.pop();
+      e2.stack.push(r2), e2.stack.push(s2);
     }
   },
-  [n.DUP2]: {
+  [i$2.DUP2]: {
     stackIn: 2,
     stackOut: 4,
     execute: (e2, t2) => {
-      const r2 = e2.stack.pop(), o2 = e2.stack.pop();
-      e2.stack.push(o2), e2.stack.push(r2), e2.stack.push(o2), e2.stack.push(r2);
+      const r2 = e2.stack.pop(), s2 = e2.stack.pop();
+      e2.stack.push(s2), e2.stack.push(r2), e2.stack.push(s2), e2.stack.push(r2);
     }
   }
 }, re = {
-  [n.PRINT]: {
+  [i$2.PRINT]: {
     stackIn: 1,
     stackOut: 0,
     execute: (e2) => {
@@ -1028,7 +1138,7 @@ const f2 = Q, Z = {
       t2 !== void 0 && e2.output.push(p$1(t2));
     }
   },
-  [n.CC]: {
+  [i$2.CC]: {
     stackIn: 1,
     stackOut: 0,
     controlsPC: true,
@@ -1039,7 +1149,7 @@ const f2 = Q, Z = {
     }
   }
 }, te = {
-  [n.HALT]: {
+  [i$2.HALT]: {
     stackIn: 0,
     stackOut: 0,
     controlsPC: true,
@@ -1047,7 +1157,7 @@ const f2 = Q, Z = {
       e2.status = "complete";
     }
   },
-  [n.JUMP]: {
+  [i$2.JUMP]: {
     stackIn: 0,
     stackOut: 0,
     controlsPC: true,
@@ -1070,7 +1180,7 @@ const f2 = Q, Z = {
       e2.pc = r2;
     }
   },
-  [n.JUMP_IF_FALSE]: {
+  [i$2.JUMP_IF_FALSE]: {
     stackIn: 1,
     stackOut: 0,
     controlsPC: true,
@@ -1083,18 +1193,18 @@ const f2 = Q, Z = {
           pc: e2.pc,
           opcode: t2.op
         };
-      const o2 = t2.arg;
-      if (o2 < 0)
+      const s2 = t2.arg;
+      if (s2 < 0)
         return {
           type: "RuntimeError",
-          message: `Invalid jump target: ${o2}`,
+          message: `Invalid jump target: ${s2}`,
           pc: e2.pc,
           opcode: t2.op
         };
-      j$1(r2) ? e2.pc++ : e2.pc = o2;
+      j$1(r2) ? e2.pc++ : e2.pc = s2;
     }
   },
-  [n.JUMP_IF]: {
+  [i$2.JUMP_IF]: {
     stackIn: 1,
     stackOut: 0,
     controlsPC: true,
@@ -1107,18 +1217,18 @@ const f2 = Q, Z = {
           pc: e2.pc,
           opcode: t2.op
         };
-      const o2 = t2.arg;
-      if (o2 < 0)
+      const s2 = t2.arg;
+      if (s2 < 0)
         return {
           type: "RuntimeError",
-          message: `Invalid jump target: ${o2}`,
+          message: `Invalid jump target: ${s2}`,
           pc: e2.pc,
           opcode: t2.op
         };
-      j$1(r2) ? e2.pc = o2 : e2.pc++;
+      j$1(r2) ? e2.pc = s2 : e2.pc++;
     }
   },
-  [n.JUMP_IF_TRUE]: {
+  [i$2.JUMP_IF_TRUE]: {
     stackIn: 1,
     stackOut: 0,
     controlsPC: true,
@@ -1131,18 +1241,18 @@ const f2 = Q, Z = {
           pc: e2.pc,
           opcode: t2.op
         };
-      const o2 = t2.arg;
-      if (o2 < 0)
+      const s2 = t2.arg;
+      if (s2 < 0)
         return {
           type: "RuntimeError",
-          message: `Invalid jump target: ${o2}`,
+          message: `Invalid jump target: ${s2}`,
           pc: e2.pc,
           opcode: t2.op
         };
-      j$1(r2) ? e2.pc = o2 : e2.pc++;
+      j$1(r2) ? e2.pc = s2 : e2.pc++;
     }
   },
-  [n.CALL]: {
+  [i$2.CALL]: {
     stackIn: 1,
     stackOut: 0,
     controlsPC: false,
@@ -1150,19 +1260,19 @@ const f2 = Q, Z = {
       type: "RuntimeError",
       message: "Functions not implemented",
       pc: e2.pc,
-      opcode: n.CALL
+      opcode: i$2.CALL
     })
   }
-}, oe = {
-  [n.LOAD]: {
+}, se = {
+  [i$2.LOAD]: {
     stackIn: 0,
     stackOut: 1,
     execute: (e2, t2) => {
       const r2 = t2.arg;
-      e2.variables.has(r2) ? e2.stack.push(e2.variables.get(r2)) : e2.stack.push(C());
+      e2.variables.has(r2) ? e2.stack.push(e2.variables.get(r2)) : e2.stack.push(C$1());
     }
   },
-  [n.STORE]: {
+  [i$2.STORE]: {
     stackIn: 1,
     stackOut: 0,
     execute: (e2, t2) => {
@@ -1170,8 +1280,8 @@ const f2 = Q, Z = {
       e2.variables.set(t2.arg, r2);
     }
   }
-}, se = {
-  [n.ITER_START]: {
+}, oe = {
+  [i$2.ITER_START]: {
     stackIn: 1,
     stackOut: 0,
     execute: (e2, t2) => {
@@ -1183,19 +1293,19 @@ const f2 = Q, Z = {
           pc: e2.pc,
           opcode: t2.op
         };
-      let o$12;
+      let s2;
       if (u$1(r2)) {
-        const s2 = e2.heap.get(r2.id);
-        if (!s2 || s2.type !== "array")
+        const o2 = e2.heap.get(r2.id);
+        if (!o2 || o2.type !== "array")
           return {
             type: "RuntimeError",
             message: "Invalid array reference",
             pc: e2.pc,
             opcode: t2.op
           };
-        o$12 = s2.data;
+        s2 = o2.data;
       } else if (o(r2))
-        o$12 = r2;
+        s2 = r2;
       else
         return {
           type: "TypeError",
@@ -1211,13 +1321,13 @@ const f2 = Q, Z = {
           opcode: t2.op
         };
       e2.iterators.push({
-        array: o$12,
+        array: s2,
         index: 0,
-        length: o$12.elements.length
+        length: s2.elements.length
       });
     }
   },
-  [n.ITER_NEXT]: {
+  [i$2.ITER_NEXT]: {
     stackIn: 0,
     stackOut: 2,
     // Pushes element and hasMore flag
@@ -1230,10 +1340,10 @@ const f2 = Q, Z = {
           opcode: t2.op
         };
       const r2 = e2.iterators[e2.iterators.length - 1];
-      r2.index < r2.length ? (r2.index < r2.array.elements.length ? e2.stack.push(r2.array.elements[r2.index]) : e2.stack.push(C()), e2.stack.push(true), r2.index++) : (e2.stack.push(null), e2.stack.push(false));
+      r2.index < r2.length ? (r2.array && r2.index < r2.array.elements.length ? e2.stack.push(r2.array.elements[r2.index]) : e2.stack.push(C$1()), e2.stack.push(true), r2.index++) : (e2.stack.push(null), e2.stack.push(false));
     }
   },
-  [n.ITER_END]: {
+  [i$2.ITER_END]: {
     stackIn: 0,
     stackOut: 0,
     execute: (e2, t2) => {
@@ -1248,122 +1358,122 @@ const f2 = Q, Z = {
     }
   }
 };
-function T(e2, t2, r2) {
-  const o2 = l(e2, t2.op);
-  if (f2(o2)) return o2;
-  const s2 = l(e2, t2.op);
+function x$1(e2, t2, r2) {
+  const s2 = d(e2, t2.op);
   if (f2(s2)) return s2;
-  const c2 = r2(s2, o2);
+  const o2 = d(e2, t2.op);
+  if (f2(o2)) return o2;
+  const c2 = r2(o2, s2);
   e2.stack.push(c2);
 }
 const ce = {
-  [n.EQ]: {
+  [i$2.EQ]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e2, t2) => T(e2, t2, (r2, o2) => {
-      if (f$2(r2) && c(o2) || c(r2) && f$2(o2))
+    execute: (e2, t2) => x$1(e2, t2, (r2, s2) => {
+      if (f$2(r2) && c(s2) || c(r2) && f$2(s2))
         return true;
-      if (c(r2) && c(o2))
+      if (c(r2) && c(s2))
         return true;
-      if (u$1(r2) || b$1(r2))
-        return u$1(r2) && u$1(o2) || b$1(r2) && b$1(o2) ? r2.id === o2.id : false;
+      if (u$1(r2) || b(r2))
+        return u$1(r2) && u$1(s2) || b(r2) && b(s2) ? r2.id === s2.id : false;
       {
-        const s2 = m(r2), c2 = m(o2);
-        return !isNaN(s2) && !isNaN(c2) ? s2 === c2 : p$1(r2) === p$1(o2);
+        const o2 = m(r2), c2 = m(s2);
+        return !isNaN(o2) && !isNaN(c2) ? o2 === c2 : p$1(r2) === p$1(s2);
       }
     })
   },
-  [n.NEQ]: {
+  [i$2.NEQ]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e2, t2) => T(e2, t2, (r2, o2) => {
-      if (f$2(r2) && c(o2) || c(r2) && f$2(o2))
+    execute: (e2, t2) => x$1(e2, t2, (r2, s2) => {
+      if (f$2(r2) && c(s2) || c(r2) && f$2(s2))
         return false;
-      if (c(r2) && c(o2))
+      if (c(r2) && c(s2))
         return false;
-      if (u$1(r2) || b$1(r2))
-        return u$1(r2) && u$1(o2) || b$1(r2) && b$1(o2) ? r2.id !== o2.id : true;
+      if (u$1(r2) || b(r2))
+        return u$1(r2) && u$1(s2) || b(r2) && b(s2) ? r2.id !== s2.id : true;
       {
-        const s2 = m(r2), c2 = m(o2);
-        return !isNaN(s2) && !isNaN(c2) ? s2 !== c2 : p$1(r2) !== p$1(o2);
+        const o2 = m(r2), c2 = m(s2);
+        return !isNaN(o2) && !isNaN(c2) ? o2 !== c2 : p$1(r2) !== p$1(s2);
       }
     })
   },
-  [n.LT]: {
+  [i$2.LT]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e2, t2) => T(e2, t2, (r2, o2) => {
-      const s2 = m(r2), c2 = m(o2);
-      return s2 < c2;
+    execute: (e2, t2) => x$1(e2, t2, (r2, s2) => {
+      const o2 = m(r2), c2 = m(s2);
+      return o2 < c2;
     })
   },
-  [n.GT]: {
+  [i$2.GT]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e2, t2) => T(e2, t2, (r2, o2) => {
-      const s2 = m(r2), c2 = m(o2);
-      return s2 > c2;
+    execute: (e2, t2) => x$1(e2, t2, (r2, s2) => {
+      const o2 = m(r2), c2 = m(s2);
+      return o2 > c2;
     })
   },
-  [n.LTE]: {
+  [i$2.LTE]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e2, t2) => T(e2, t2, (r2, o2) => {
-      const s2 = m(r2), c2 = m(o2);
-      return s2 <= c2;
+    execute: (e2, t2) => x$1(e2, t2, (r2, s2) => {
+      const o2 = m(r2), c2 = m(s2);
+      return o2 <= c2;
     })
   },
-  [n.GTE]: {
+  [i$2.GTE]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e2, t2) => T(e2, t2, (r2, o2) => {
-      const s2 = m(r2), c2 = m(o2);
-      return s2 >= c2;
+    execute: (e2, t2) => x$1(e2, t2, (r2, s2) => {
+      const o2 = m(r2), c2 = m(s2);
+      return o2 >= c2;
     })
   },
-  [n.EQ_STRICT]: {
+  [i$2.EQ_STRICT]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e2, t2) => T(e2, t2, (r2, o2) => u$1(r2) && u$1(o2) || b$1(r2) && b$1(o2) ? r2.id === o2.id : r2 === o2)
+    execute: (e2, t2) => x$1(e2, t2, (r2, s2) => u$1(r2) && u$1(s2) || b(r2) && b(s2) ? r2.id === s2.id : r2 === s2)
   },
-  [n.NEQ_STRICT]: {
+  [i$2.NEQ_STRICT]: {
     stackIn: 2,
     stackOut: 1,
-    execute: (e2, t2) => T(e2, t2, (r2, o2) => u$1(r2) && u$1(o2) || b$1(r2) && b$1(o2) ? r2.id !== o2.id : r2 !== o2)
+    execute: (e2, t2) => x$1(e2, t2, (r2, s2) => u$1(r2) && u$1(s2) || b(r2) && b(s2) ? r2.id !== s2.id : r2 !== s2)
   }
 }, ne = {
-  [n.AND]: {
+  [i$2.AND]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t2) => {
-      const r2 = l(e2, t2.op);
+      const r2 = d(e2, t2.op);
       if (f2(r2)) return r2;
-      const o2 = l(e2, t2.op);
-      if (f2(o2)) return o2;
-      const s2 = j$1(o2) ? r2 : o2;
-      e2.stack.push(s2);
+      const s2 = d(e2, t2.op);
+      if (f2(s2)) return s2;
+      const o2 = j$1(s2) ? r2 : s2;
+      e2.stack.push(o2);
     }
   },
-  [n.OR]: {
+  [i$2.OR]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t2) => {
-      const r2 = l(e2, t2.op);
+      const r2 = d(e2, t2.op);
       if (f2(r2)) return r2;
-      const o2 = l(e2, t2.op);
-      if (f2(o2)) return o2;
-      const s2 = j$1(o2) ? o2 : r2;
-      e2.stack.push(s2);
+      const s2 = d(e2, t2.op);
+      if (f2(s2)) return s2;
+      const o2 = j$1(s2) ? s2 : r2;
+      e2.stack.push(o2);
     }
   },
-  [n.NOT]: {
+  [i$2.NOT]: {
     stackIn: 1,
     stackOut: 1,
     execute: (e2, t2) => {
-      const r2 = l(e2, t2.op);
+      const r2 = d(e2, t2.op);
       if (f2(r2)) return r2;
-      const o2 = !j$1(r2);
-      e2.stack.push(o2);
+      const s2 = !j$1(r2);
+      e2.stack.push(s2);
     }
   }
 }, pe = {
@@ -1371,26 +1481,26 @@ const ce = {
    * ARRAY_NEW: Creates a new empty array on the heap
    * Stack: [] -> [array-ref]
    */
-  [n.ARRAY_NEW]: {
+  [i$2.ARRAY_NEW]: {
     stackIn: 0,
     stackOut: 1,
     execute: (e2, t2) => {
-      const r2 = s(), o2 = e2.heap.allocate("array", r2);
-      e2.stack.push(o2);
+      const r2 = s(), s$12 = e2.heap.allocate("array", r2);
+      e2.stack.push(s$12);
     }
   },
   /**
    * ARRAY_PUSH: Pushes a value to the end of an array
    * Stack: [array-ref, value] -> [array-ref]
    */
-  [n.ARRAY_PUSH]: {
+  [i$2.ARRAY_PUSH]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t2) => {
-      const r2 = e2.stack.pop(), o$12 = e2.stack.pop();
-      let s2;
-      if (u$1(o$12)) {
-        const c2 = e2.heap.get(o$12.id);
+      const r2 = e2.stack.pop(), s2 = e2.stack.pop();
+      let o$12;
+      if (u$1(s2)) {
+        const c2 = e2.heap.get(s2.id);
         if (!c2 || c2.type !== "array")
           return {
             type: "RuntimeError",
@@ -1398,9 +1508,9 @@ const ce = {
             pc: e2.pc,
             opcode: t2.op
           };
-        s2 = c2.data;
-      } else if (o(o$12))
-        s2 = o$12;
+        o$12 = c2.data;
+      } else if (o(s2))
+        o$12 = s2;
       else
         return {
           type: "RuntimeError",
@@ -1408,49 +1518,49 @@ const ce = {
           pc: e2.pc,
           opcode: t2.op
         };
-      s2.elements.push(r2), e2.stack.push(o$12);
+      o$12.elements.push(r2), e2.stack.push(s2);
     }
   },
-  [n.ARRAY_GET]: {
+  [i$2.ARRAY_GET]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t$1) => {
       var a2;
-      const r2 = e2.stack.pop(), o$12 = e2.stack.pop();
-      let s2;
-      if (u$1(o$12)) {
-        const u2 = e2.heap.get(o$12.id);
-        if (!u2 || u2.type !== "array")
+      const r2 = e2.stack.pop(), s2 = e2.stack.pop();
+      let o$12;
+      if (u$1(s2)) {
+        const i2 = e2.heap.get(s2.id);
+        if (!i2 || i2.type !== "array")
           return {
             type: "RuntimeError",
             message: "Invalid array reference",
             pc: e2.pc,
             opcode: t$1.op
           };
-        s2 = u2.data;
-      } else if (b$1(o$12)) {
-        const u2 = e2.heap.get(o$12.id);
-        if (!u2 || u2.type !== "object")
+        o$12 = i2.data;
+      } else if (b(s2)) {
+        const i2 = e2.heap.get(s2.id);
+        if (!i2 || i2.type !== "object")
           return {
             type: "RuntimeError",
             message: "Invalid object reference",
             pc: e2.pc,
             opcode: t$1.op
           };
-        const i2 = u2.data, y2 = p$1(r2), E2 = i2.properties[y2] ?? C();
+        const u2 = i2.data, y2 = p$1(r2), E2 = u2.properties[y2] ?? C$1();
         e2.stack.push(E2);
         return;
-      } else if (o(o$12))
-        s2 = o$12;
-      else if (t(o$12)) {
-        let u2;
+      } else if (o(s2))
+        o$12 = s2;
+      else if (t(s2)) {
+        let i2;
         if (i$1(r2))
-          u2 = r2;
+          i2 = r2;
         else if (t(r2)) {
-          const i2 = parseInt(r2, 10);
-          !isNaN(i2) && i2.toString() === r2 && (u2 = i2);
+          const u2 = parseInt(r2, 10);
+          !isNaN(u2) && u2.toString() === r2 && (i2 = u2);
         }
-        u2 !== void 0 && u2 >= 0 && u2 < o$12.length ? e2.stack.push(o$12[u2]) : e2.stack.push(C());
+        i2 !== void 0 && i2 >= 0 && i2 < s2.length ? e2.stack.push(s2[i2]) : e2.stack.push(C$1());
         return;
       } else
         return {
@@ -1463,12 +1573,12 @@ const ce = {
       if (i$1(r2))
         c2 = r2;
       else if (t(r2)) {
-        const u2 = parseInt(r2, 10);
-        if (!isNaN(u2) && u2.toString() === r2 && u2 >= 0)
-          c2 = u2;
+        const i2 = parseInt(r2, 10);
+        if (!isNaN(i2) && i2.toString() === r2 && i2 >= 0)
+          c2 = i2;
         else {
-          const i2 = ((a2 = s2.properties) == null ? void 0 : a2[r2]) ?? C();
-          e2.stack.push(i2);
+          const u2 = ((a2 = o$12.properties) == null ? void 0 : a2[r2]) ?? C$1();
+          e2.stack.push(u2);
           return;
         }
       } else
@@ -1478,40 +1588,40 @@ const ce = {
           pc: e2.pc,
           opcode: t$1.op
         };
-      const p2 = s2.elements[c2] ?? C();
+      const p2 = o$12.elements[c2] ?? C$1();
       e2.stack.push(p2);
     }
   },
-  [n.ARRAY_SET]: {
+  [i$2.ARRAY_SET]: {
     stackIn: 3,
     stackOut: 1,
     execute: (e2, t$1) => {
-      const r2 = e2.stack.pop(), o$12 = e2.stack.pop(), s2 = e2.stack.pop();
+      const r2 = e2.stack.pop(), s2 = e2.stack.pop(), o$12 = e2.stack.pop();
       let c2;
-      if (u$1(s2)) {
-        const u2 = e2.heap.get(s2.id);
-        if (!u2 || u2.type !== "array")
+      if (u$1(o$12)) {
+        const i2 = e2.heap.get(o$12.id);
+        if (!i2 || i2.type !== "array")
           return {
             type: "RuntimeError",
             message: "Invalid array reference",
             pc: e2.pc,
             opcode: t$1.op
           };
-        c2 = u2.data;
-      } else if (b$1(s2)) {
-        const u2 = e2.heap.get(s2.id);
-        if (!u2 || u2.type !== "object")
+        c2 = i2.data;
+      } else if (b(o$12)) {
+        const i2 = e2.heap.get(o$12.id);
+        if (!i2 || i2.type !== "object")
           return {
             type: "RuntimeError",
             message: "Invalid object reference",
             pc: e2.pc,
             opcode: t$1.op
           };
-        const i2 = u2.data, y2 = p$1(o$12);
-        i2.properties[y2] = r2, e2.stack.push(s2);
+        const u2 = i2.data, y2 = p$1(s2);
+        u2.properties[y2] = r2, e2.stack.push(o$12);
         return;
-      } else if (o(s2))
-        c2 = s2;
+      } else if (o(o$12))
+        c2 = o$12;
       else
         return {
           type: "RuntimeError",
@@ -1520,14 +1630,14 @@ const ce = {
           opcode: t$1.op
         };
       let p2;
-      if (i$1(o$12))
-        p2 = o$12;
-      else if (t(o$12)) {
-        const u2 = parseInt(o$12, 10);
-        if (!isNaN(u2) && u2.toString() === o$12 && u2 >= 0)
-          p2 = u2;
+      if (i$1(s2))
+        p2 = s2;
+      else if (t(s2)) {
+        const i2 = parseInt(s2, 10);
+        if (!isNaN(i2) && i2.toString() === s2 && i2 >= 0)
+          p2 = i2;
         else {
-          c2.properties || (c2.properties = {}), c2.properties[o$12] = r2, e2.stack.push(s2);
+          c2.properties || (c2.properties = {}), c2.properties[s2] = r2, e2.stack.push(o$12);
           return;
         }
       } else
@@ -1545,27 +1655,27 @@ const ce = {
           pc: e2.pc,
           opcode: t$1.op
         };
-      c2.elements[a2] = r2, e2.stack.push(s2);
+      c2.elements[a2] = r2, e2.stack.push(o$12);
     }
   },
-  [n.ARRAY_LEN]: {
+  [i$2.ARRAY_LEN]: {
     stackIn: 1,
     stackOut: 1,
     execute: (e2, t2) => {
       const r2 = e2.stack.pop();
-      let o$12;
+      let s2;
       if (u$1(r2)) {
-        const s2 = e2.heap.get(r2.id);
-        if (!s2 || s2.type !== "array")
+        const o2 = e2.heap.get(r2.id);
+        if (!o2 || o2.type !== "array")
           return {
             type: "RuntimeError",
             message: "Invalid array reference",
             pc: e2.pc,
             opcode: t2.op
           };
-        o$12 = s2.data;
+        s2 = o2.data;
       } else if (o(r2))
-        o$12 = r2;
+        s2 = r2;
       else
         return {
           type: "RuntimeError",
@@ -1573,35 +1683,35 @@ const ce = {
           pc: e2.pc,
           opcode: t2.op
         };
-      e2.stack.push(o$12.elements.length);
+      e2.stack.push(s2.elements.length);
     }
   },
-  [n.ARRAY_MAP_PROP]: {
+  [i$2.ARRAY_MAP_PROP]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t2) => {
-      const r2 = e2.stack.pop(), o2 = e2.stack.pop();
-      if (!u$1(o2))
+      const r2 = e2.stack.pop(), s$12 = e2.stack.pop();
+      if (!u$1(s$12))
         return {
           type: "RuntimeError",
           message: "map() requires an array",
           pc: e2.pc,
           opcode: t2.op
         };
-      const s$12 = e2.heap.get(o2.id);
-      if (!s$12 || s$12.type !== "array")
+      const o2 = e2.heap.get(s$12.id);
+      if (!o2 || o2.type !== "array")
         return {
           type: "RuntimeError",
           message: "Invalid array reference",
           pc: e2.pc,
           opcode: t2.op
         };
-      const c2 = s$12.data, p2 = s();
-      for (const u2 of c2.elements)
-        if (b$1(u2)) {
-          const i2 = e2.heap.get(u2.id);
-          if (i2 && i2.type === "object") {
-            const y2 = i2.data, E2 = p$1(r2);
+      const c2 = o2.data, p2 = s();
+      for (const i2 of c2.elements)
+        if (b(i2)) {
+          const u2 = e2.heap.get(i2.id);
+          if (u2 && u2.type === "object") {
+            const y2 = u2.data, E2 = p$1(r2);
             p2.elements.push(y2.properties[E2] || null);
           } else
             p2.elements.push(null);
@@ -1611,104 +1721,104 @@ const ce = {
       e2.stack.push(a2);
     }
   },
-  [n.ARRAY_FILTER_PROP]: {
+  [i$2.ARRAY_FILTER_PROP]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t2) => {
-      const r2 = e2.stack.pop(), o2 = e2.stack.pop();
-      if (!u$1(o2))
+      const r2 = e2.stack.pop(), s$12 = e2.stack.pop();
+      if (!u$1(s$12))
         return {
           type: "RuntimeError",
           message: "filter() requires an array",
           pc: e2.pc,
           opcode: t2.op
         };
-      const s$12 = e2.heap.get(o2.id);
-      if (!s$12 || s$12.type !== "array")
+      const o2 = e2.heap.get(s$12.id);
+      if (!o2 || o2.type !== "array")
         return {
           type: "RuntimeError",
           message: "Invalid array reference",
           pc: e2.pc,
           opcode: t2.op
         };
-      const c2 = s$12.data, p2 = s();
-      for (const u2 of c2.elements)
-        if (b$1(u2)) {
-          const i2 = e2.heap.get(u2.id);
-          if (i2 && i2.type === "object") {
-            const y2 = i2.data, E2 = p$1(r2);
-            E2 in y2.properties && y2.properties[E2] && p2.elements.push(u2);
+      const c2 = o2.data, p2 = s();
+      for (const i2 of c2.elements)
+        if (b(i2)) {
+          const u2 = e2.heap.get(i2.id);
+          if (u2 && u2.type === "object") {
+            const y2 = u2.data, E2 = p$1(r2);
+            E2 in y2.properties && y2.properties[E2] && p2.elements.push(i2);
           }
         }
       const a2 = e2.heap.allocate("array", p2);
       e2.stack.push(a2);
     }
   },
-  [n.ARRAY_SLICE]: {
+  [i$2.ARRAY_SLICE]: {
     stackIn: 3,
     // array, start, end
     stackOut: 1,
     execute: (e2, t2) => {
-      const r2 = e2.stack.pop(), o2 = e2.stack.pop(), s$12 = e2.stack.pop();
-      if (!((L2) => {
-        if (!u$1(L2))
+      const r2 = e2.stack.pop(), s$12 = e2.stack.pop(), o2 = e2.stack.pop();
+      if (!((M2) => {
+        if (!u$1(M2))
           return false;
-        const U2 = e2.heap.get(L2.id);
+        const U2 = e2.heap.get(M2.id);
         return U2 !== void 0 && U2.type === "array";
-      })(s$12))
+      })(o2))
         return {
           type: "RuntimeError",
           message: "ARRAY_SLICE requires an array",
           pc: e2.pc,
           opcode: t2.op
         };
-      const a2 = e2.heap.get(s$12.id).data, u2 = i$1(o2) ? o2 : 0, i2 = r2 === void 0 ? a2.elements.length : i$1(r2) ? r2 : a2.elements.length, y2 = u2 < 0 ? Math.max(0, a2.elements.length + u2) : u2, E2 = i2 < 0 ? Math.max(0, a2.elements.length + i2) : i2, Y2 = a2.elements.slice(y2, E2), J2 = s(Y2), z = e2.heap.allocate("array", J2);
-      e2.stack.push(z);
+      const a2 = e2.heap.get(o2.id).data, i2 = i$1(s$12) ? s$12 : 0, u2 = r2 === void 0 ? a2.elements.length : i$1(r2) ? r2 : a2.elements.length, y2 = i2 < 0 ? Math.max(0, a2.elements.length + i2) : i2, E2 = u2 < 0 ? Math.max(0, a2.elements.length + u2) : u2, J2 = a2.elements.slice(y2, E2), Y2 = s(J2), z2 = e2.heap.allocate("array", Y2);
+      e2.stack.push(z2);
     }
   },
-  [n.ARRAY_JOIN]: {
+  [i$2.ARRAY_JOIN]: {
     stackIn: 2,
     // array, separator
     stackOut: 1,
     // string
     execute: (e2, t$1) => {
-      const r2 = e2.stack.pop(), o2 = e2.stack.pop();
+      const r2 = e2.stack.pop(), s2 = e2.stack.pop();
       if (!((y2) => {
         if (!u$1(y2))
           return false;
         const E2 = e2.heap.get(y2.id);
         return E2 !== void 0 && E2.type === "array";
-      })(o2))
+      })(s2))
         return {
           type: "RuntimeError",
           message: "ARRAY_JOIN requires an array",
           pc: e2.pc,
           opcode: t$1.op
         };
-      const p2 = e2.heap.get(o2.id).data, a2 = t(r2) ? r2 : String(r2), i2 = p2.elements.map((y2) => y2 === null ? "null" : y2 === void 0 || c(y2) ? "undefined" : String(y2)).join(a2);
-      e2.stack.push(i2);
+      const p2 = e2.heap.get(s2.id).data, a2 = t(r2) ? r2 : String(r2), u2 = p2.elements.map((y2) => y2 === null ? "null" : y2 === void 0 || c(y2) ? "undefined" : String(y2)).join(a2);
+      e2.stack.push(u2);
     }
   },
-  [n.ARRAY_INDEX_OF]: {
+  [i$2.ARRAY_INDEX_OF]: {
     stackIn: 2,
     // array, searchElement
     stackOut: 1,
     // number (index or -1)
     execute: (e2, t2) => {
-      const r2 = e2.stack.pop(), o2 = e2.stack.pop();
+      const r2 = e2.stack.pop(), s2 = e2.stack.pop();
       if (!((a2) => {
         if (!u$1(a2))
           return false;
-        const u2 = e2.heap.get(a2.id);
-        return u2 !== void 0 && u2.type === "array";
-      })(o2))
+        const i2 = e2.heap.get(a2.id);
+        return i2 !== void 0 && i2.type === "array";
+      })(s2))
         return {
           type: "RuntimeError",
           message: "ARRAY_INDEX_OF requires an array",
           pc: e2.pc,
           opcode: t2.op
         };
-      const p2 = e2.heap.get(o2.id).data;
+      const p2 = e2.heap.get(s2.id).data;
       for (let a2 = 0; a2 < p2.elements.length; a2++)
         if (p2.elements[a2] === r2) {
           e2.stack.push(a2);
@@ -1718,43 +1828,43 @@ const ce = {
     }
   }
 };
-function M(e2, t2) {
+function L(e2, t2) {
   if (e2 === null) return null;
   if (e2 !== void 0) {
     if (typeof e2 == "string" || typeof e2 == "number" || typeof e2 == "boolean" || e2 && typeof e2 == "object" && e2.type === "array" && Array.isArray(e2.elements))
       return e2;
     if (Array.isArray(e2)) {
       const r2 = s();
-      return r2.elements = e2.map((o2) => M(o2, t2)), t2.allocate("array", r2);
+      return r2.elements = e2.map((s2) => L(s2, t2)), t2.allocate("array", r2);
     }
     if (e2 && typeof e2 == "object" && e2.type === "object" && e2.properties)
       return e2;
     if (typeof e2 == "object") {
-      const r2 = M$1();
-      for (const [o2, s2] of Object.entries(e2))
-        r2.properties[o2] = M(s2, t2);
+      const r2 = M();
+      for (const [s2, o2] of Object.entries(e2))
+        r2.properties[s2] = L(o2, t2);
       return t2.allocate("object", r2);
     }
     return null;
   }
 }
 const ae = {
-  [n.CONCAT]: {
+  [i$2.CONCAT]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t2) => {
-      const r2 = l(e2, t2.op);
+      const r2 = d(e2, t2.op);
       if (f2(r2)) return r2;
-      const o2 = l(e2, t2.op);
-      if (f2(o2)) return o2;
-      e2.stack.push(p$1(o2) + p$1(r2));
+      const s2 = d(e2, t2.op);
+      if (f2(s2)) return s2;
+      e2.stack.push(p$1(s2) + p$1(r2));
     }
   },
-  [n.STRING_LEN]: {
+  [i$2.STRING_LEN]: {
     stackIn: 1,
     stackOut: 1,
     execute: (e2, t$1) => {
-      const r2 = l(e2, t$1.op);
+      const r2 = d(e2, t$1.op);
       if (f2(r2)) return r2;
       if (!t(r2))
         return {
@@ -1766,27 +1876,27 @@ const ae = {
       e2.stack.push(r2.length);
     }
   },
-  [n.LENGTH]: {
+  [i$2.LENGTH]: {
     stackIn: 1,
     stackOut: 1,
     execute: (e2, t$1) => {
-      const r2 = l(e2, t$1.op);
+      const r2 = d(e2, t$1.op);
       if (f2(r2)) return r2;
       if (t(r2))
         e2.stack.push(r2.length);
       else if (o(r2))
         e2.stack.push(r2.elements.length);
       else if (u$1(r2)) {
-        const o2 = e2.heap.get(r2.id);
-        if (!o2 || o2.type !== "array")
+        const s2 = e2.heap.get(r2.id);
+        if (!s2 || s2.type !== "array")
           return {
             type: "RuntimeError",
             message: "Invalid array reference",
             pc: e2.pc,
             opcode: t$1.op
           };
-        const s2 = o2.data;
-        e2.stack.push(s2.elements.length);
+        const o2 = s2.data;
+        e2.stack.push(o2.elements.length);
       } else
         return {
           type: "RuntimeError",
@@ -1796,11 +1906,11 @@ const ae = {
         };
     }
   },
-  [n.JSON_PARSE]: {
+  [i$2.JSON_PARSE]: {
     stackIn: 1,
     stackOut: 1,
     execute: (e2, t$1) => {
-      const r2 = l(e2, t$1.op);
+      const r2 = d(e2, t$1.op);
       if (f2(r2)) return r2;
       if (!t(r2))
         return {
@@ -1810,24 +1920,24 @@ const ae = {
           opcode: t$1.op
         };
       try {
-        const o2 = JSON.parse(r2);
-        e2.stack.push(M(o2, e2.heap));
+        const s2 = JSON.parse(r2);
+        e2.stack.push(L(s2, e2.heap));
       } catch {
         e2.stack.push(null);
       }
     }
   },
-  [n.TYPEOF]: {
+  [i$2.TYPEOF]: {
     stackIn: 1,
     stackOut: 1,
     execute: (e2, t2) => {
-      const r2 = l(e2, t2.op);
+      const r2 = d(e2, t2.op);
       if (f2(r2)) return r2;
-      e2.stack.push(d$1(r2));
+      e2.stack.push(d$2(r2));
     }
   }
-}, ue = {
-  [n.INC]: {
+}, ie = {
+  [i$2.INC]: {
     stackIn: 1,
     stackOut: 1,
     execute: (e2, t2) => {
@@ -1839,13 +1949,13 @@ const ae = {
           pc: e2.pc,
           opcode: t2.op
         };
-      const o2 = e2.variables.get(r2) ?? 0, s2 = m(o2) + 1;
-      e2.variables.set(r2, s2);
+      const s2 = e2.variables.get(r2) ?? 0, o2 = m(s2) + 1;
+      e2.variables.set(r2, o2);
       const c2 = t2.arg === true;
-      e2.stack.push(c2 ? m(o2) : s2);
+      e2.stack.push(c2 ? m(s2) : o2);
     }
   },
-  [n.DEC]: {
+  [i$2.DEC]: {
     stackIn: 1,
     stackOut: 1,
     execute: (e2, t2) => {
@@ -1857,14 +1967,14 @@ const ae = {
           pc: e2.pc,
           opcode: t2.op
         };
-      const o2 = e2.variables.get(r2) ?? 0, s2 = m(o2) - 1;
-      e2.variables.set(r2, s2);
+      const s2 = e2.variables.get(r2) ?? 0, o2 = m(s2) - 1;
+      e2.variables.set(r2, o2);
       const c2 = t2.arg === true;
-      e2.stack.push(c2 ? m(o2) : s2);
+      e2.stack.push(c2 ? m(s2) : o2);
     }
   }
-}, ie = {
-  [n.RETURN]: {
+}, ue = {
+  [i$2.RETURN]: {
     stackIn: 0,
     stackOut: 0,
     controlsPC: true,
@@ -1873,7 +1983,7 @@ const ae = {
       e2.returnValue = r2, e2.status = "complete";
     }
   },
-  [n.BREAK]: {
+  [i$2.BREAK]: {
     stackIn: 0,
     stackOut: 0,
     controlsPC: true,
@@ -1896,7 +2006,7 @@ const ae = {
       e2.pc = r2;
     }
   },
-  [n.CONTINUE]: {
+  [i$2.CONTINUE]: {
     stackIn: 0,
     stackOut: 0,
     controlsPC: true,
@@ -1919,7 +2029,7 @@ const ae = {
       e2.pc = r2;
     }
   },
-  [n.FS_LIST_FILES]: {
+  [i$2.FS_LIST_FILES]: {
     stackIn: 1,
     // Minimum 1 argument (path), optionally 2 (path + options)
     stackOut: 1,
@@ -1931,9 +2041,9 @@ const ae = {
           pc: e2.pc,
           opcode: t$1.op
         };
-      let r2, o$12 = {};
-      const s2 = e2.stack[e2.stack.length - 1];
-      if (e2.stack.length >= 2 && typeof s2 == "object" && s2 !== null && !o(s2) && (o$12 = e2.stack.pop()), r2 = e2.stack.pop(), !t(r2))
+      let r2, s2 = {};
+      const o$12 = e2.stack[e2.stack.length - 1];
+      if (e2.stack.length >= 2 && typeof o$12 == "object" && o$12 !== null && !o(o$12) && (s2 = e2.stack.pop()), r2 = e2.stack.pop(), !t(r2))
         return {
           type: "RuntimeError",
           message: "FS_LIST_FILES requires a string path",
@@ -1947,7 +2057,7 @@ const ae = {
           pc: e2.pc,
           opcode: t$1.op
         };
-      const c2 = e2.fileSystem.listFiles(r2, o$12);
+      const c2 = e2.fileSystem.listFiles(r2, s2);
       if (o(c2)) {
         const p2 = e2.heap.allocate("array", c2);
         e2.stack.push(p2);
@@ -1955,7 +2065,7 @@ const ae = {
         e2.stack.push(c2);
     }
   },
-  [n.FS_READ_FILE]: {
+  [i$2.FS_READ_FILE]: {
     stackIn: 1,
     // path
     stackOut: 1,
@@ -1976,18 +2086,18 @@ const ae = {
           pc: e2.pc,
           opcode: t$1.op
         };
-      const o2 = e2.fileSystem.readFile(r2);
-      e2.stack.push(o2);
+      const s2 = e2.fileSystem.readFile(r2);
+      e2.stack.push(s2);
     }
   },
-  [n.FS_WRITE_FILE]: {
+  [i$2.FS_WRITE_FILE]: {
     stackIn: 2,
     // path, content
     stackOut: 1,
     // Returns boolean
     execute: (e2, t$1) => {
-      const r2 = e2.stack.pop(), o2 = e2.stack.pop();
-      if (!o2 || !t(o2))
+      const r2 = e2.stack.pop(), s2 = e2.stack.pop();
+      if (!s2 || !t(s2))
         return {
           type: "RuntimeError",
           message: "FS_WRITE_FILE requires a string path",
@@ -2008,12 +2118,12 @@ const ae = {
           pc: e2.pc,
           opcode: t$1.op
         };
-      const s2 = p$1(r2), c2 = e2.fileSystem.writeFile(o2, s2);
+      const o2 = p$1(r2), c2 = e2.fileSystem.writeFile(s2, o2);
       e2.stack.push(c2);
     }
   },
   // String method handlers
-  [n.STRING_SUBSTRING]: {
+  [i$2.STRING_SUBSTRING]: {
     stackIn: 2,
     // Minimum 2 (string, start), optionally 3 (string, start, end)
     stackOut: 1,
@@ -2026,62 +2136,62 @@ const ae = {
           opcode: t$1.op
         };
       const r2 = e2.stack.length;
-      let o2, s2, c2;
+      let s2, o2, c2;
       const p2 = e2.stack[r2 - 1], a2 = e2.stack[r2 - 2];
-      if (r2 >= 3 && typeof p2 == "number" && typeof a2 == "number" ? (c2 = e2.stack.pop(), s2 = e2.stack.pop(), o2 = e2.stack.pop()) : (s2 = e2.stack.pop(), o2 = e2.stack.pop(), c2 = void 0), !t(o2))
+      if (r2 >= 3 && typeof p2 == "number" && typeof a2 == "number" ? (c2 = e2.stack.pop(), o2 = e2.stack.pop(), s2 = e2.stack.pop()) : (o2 = e2.stack.pop(), s2 = e2.stack.pop(), c2 = void 0), !t(s2))
         return {
           type: "RuntimeError",
           message: "STRING_SUBSTRING requires a string",
           pc: e2.pc,
           opcode: t$1.op
         };
-      if (typeof s2 != "number")
+      if (typeof o2 != "number")
         return {
           type: "RuntimeError",
           message: "STRING_SUBSTRING requires numeric start index",
           pc: e2.pc,
           opcode: t$1.op
         };
-      const u2 = o2.length;
-      s2 < 0 && (s2 = Math.max(0, u2 + s2)), c2 !== void 0 && c2 < 0 && (c2 = Math.max(0, u2 + c2));
-      const i2 = c2 !== void 0 ? o2.substring(s2, c2) : o2.substring(s2);
-      e2.stack.push(i2);
+      const i2 = s2.length;
+      o2 < 0 && (o2 = Math.max(0, i2 + o2)), c2 !== void 0 && c2 < 0 && (c2 = Math.max(0, i2 + c2));
+      const u2 = c2 !== void 0 ? s2.substring(o2, c2) : s2.substring(o2);
+      e2.stack.push(u2);
     }
   },
-  [n.STRING_INDEXOF]: {
+  [i$2.STRING_INDEXOF]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t$1) => {
-      const r2 = e2.stack.pop(), o2 = e2.stack.pop();
-      if (!t(o2) || !t(r2))
+      const r2 = e2.stack.pop(), s2 = e2.stack.pop();
+      if (!t(s2) || !t(r2))
         return {
           type: "RuntimeError",
           message: "STRING_INDEXOF requires string arguments",
           pc: e2.pc,
           opcode: t$1.op
         };
-      e2.stack.push(o2.indexOf(r2));
+      e2.stack.push(s2.indexOf(r2));
     }
   },
-  [n.STRING_SPLIT]: {
+  [i$2.STRING_SPLIT]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t$1) => {
-      const r2 = e2.stack.pop(), o2 = e2.stack.pop();
-      if (!t(o2) || !t(r2))
+      const r2 = e2.stack.pop(), s$12 = e2.stack.pop();
+      if (!t(s$12) || !t(r2))
         return {
           type: "RuntimeError",
           message: "STRING_SPLIT requires string arguments",
           pc: e2.pc,
           opcode: t$1.op
         };
-      let s$12;
-      r2 === "" ? s$12 = o2.split("") : s$12 = o2.split(r2);
-      const c2 = s(s$12), p2 = e2.heap.allocate("array", c2);
+      let o2;
+      r2 === "" ? o2 = s$12.split("") : o2 = s$12.split(r2);
+      const c2 = s(o2), p2 = e2.heap.allocate("array", c2);
       e2.stack.push(p2);
     }
   },
-  [n.STRING_SLICE]: {
+  [i$2.STRING_SLICE]: {
     stackIn: 2,
     // Minimum 2 (string, start), optionally 3 (string, start, end)
     stackOut: 1,
@@ -2094,32 +2204,32 @@ const ae = {
           opcode: t$1.op
         };
       const r2 = e2.stack.length;
-      let o2, s2, c2;
+      let s2, o2, c2;
       const p2 = e2.stack.length >= 1 ? e2.stack[r2 - 1] : void 0, a2 = e2.stack.length >= 2 ? e2.stack[r2 - 2] : void 0;
-      if (r2 >= 3 && typeof p2 == "number" && typeof a2 == "number" ? (c2 = e2.stack.pop(), s2 = e2.stack.pop(), o2 = e2.stack.pop()) : (s2 = e2.stack.pop(), o2 = e2.stack.pop(), c2 = void 0), !t(o2))
+      if (r2 >= 3 && typeof p2 == "number" && typeof a2 == "number" ? (c2 = e2.stack.pop(), o2 = e2.stack.pop(), s2 = e2.stack.pop()) : (o2 = e2.stack.pop(), s2 = e2.stack.pop(), c2 = void 0), !t(s2))
         return {
           type: "RuntimeError",
           message: "STRING_SLICE requires a string",
           pc: e2.pc,
           opcode: t$1.op
         };
-      if (typeof s2 != "number")
+      if (typeof o2 != "number")
         return {
           type: "RuntimeError",
           message: "STRING_SLICE requires numeric start index",
           pc: e2.pc,
           opcode: t$1.op
         };
-      const u2 = c2 !== void 0 ? o2.slice(s2, c2) : o2.slice(s2);
-      e2.stack.push(u2);
+      const i2 = c2 !== void 0 ? s2.slice(o2, c2) : s2.slice(o2);
+      e2.stack.push(i2);
     }
   },
-  [n.STRING_CHARAT]: {
+  [i$2.STRING_CHARAT]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t$1) => {
-      const r2 = e2.stack.pop(), o2 = e2.stack.pop();
-      if (!t(o2))
+      const r2 = e2.stack.pop(), s2 = e2.stack.pop();
+      if (!t(s2))
         return {
           type: "RuntimeError",
           message: "STRING_CHARAT requires a string",
@@ -2133,11 +2243,11 @@ const ae = {
           pc: e2.pc,
           opcode: t$1.op
         };
-      const s2 = o2.charAt(r2);
-      e2.stack.push(s2);
+      const o2 = s2.charAt(r2);
+      e2.stack.push(o2);
     }
   },
-  [n.STRING_TOUPPERCASE]: {
+  [i$2.STRING_TOUPPERCASE]: {
     stackIn: 1,
     stackOut: 1,
     execute: (e2, t$1) => {
@@ -2152,7 +2262,7 @@ const ae = {
       e2.stack.push(r2.toUpperCase());
     }
   },
-  [n.STRING_TOLOWERCASE]: {
+  [i$2.STRING_TOLOWERCASE]: {
     stackIn: 1,
     stackOut: 1,
     execute: (e2, t$1) => {
@@ -2167,7 +2277,7 @@ const ae = {
       e2.stack.push(r2.toLowerCase());
     }
   },
-  [n.TO_STRING]: {
+  [i$2.TO_STRING]: {
     stackIn: 1,
     stackOut: 1,
     execute: (e2, t2) => {
@@ -2179,61 +2289,61 @@ const ae = {
           pc: e2.pc,
           opcode: t2.op
         };
-      const o2 = p$1(r2);
-      e2.stack.push(o2);
+      const s2 = p$1(r2);
+      e2.stack.push(s2);
     }
   },
-  [n.STRING_INCLUDES]: {
+  [i$2.STRING_INCLUDES]: {
     stackIn: 2,
     // string, searchString
     stackOut: 1,
     // boolean
     execute: (e2, t$1) => {
-      const r2 = e2.stack.pop(), o2 = e2.stack.pop();
-      if (!t(o2))
+      const r2 = e2.stack.pop(), s2 = e2.stack.pop();
+      if (!t(s2))
         return {
           type: "RuntimeError",
           message: "STRING_INCLUDES requires a string",
           pc: e2.pc,
           opcode: t$1.op
         };
-      const s2 = String(r2);
-      e2.stack.push(o2.includes(s2));
+      const o2 = String(r2);
+      e2.stack.push(s2.includes(o2));
     }
   },
-  [n.STRING_ENDS_WITH]: {
+  [i$2.STRING_ENDS_WITH]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t$1) => {
-      const r2 = e2.stack.pop(), o2 = e2.stack.pop();
-      if (!t(o2))
+      const r2 = e2.stack.pop(), s2 = e2.stack.pop();
+      if (!t(s2))
         return {
           type: "RuntimeError",
           message: "STRING_ENDS_WITH requires a string",
           pc: e2.pc,
           opcode: t$1.op
         };
-      const s2 = String(r2);
-      e2.stack.push(o2.endsWith(s2));
+      const o2 = String(r2);
+      e2.stack.push(s2.endsWith(o2));
     }
   },
-  [n.STRING_STARTS_WITH]: {
+  [i$2.STRING_STARTS_WITH]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t$1) => {
-      const r2 = e2.stack.pop(), o2 = e2.stack.pop();
-      if (!t(o2))
+      const r2 = e2.stack.pop(), s2 = e2.stack.pop();
+      if (!t(s2))
         return {
           type: "RuntimeError",
           message: "STRING_STARTS_WITH requires a string",
           pc: e2.pc,
           opcode: t$1.op
         };
-      const s2 = String(r2);
-      e2.stack.push(o2.startsWith(s2));
+      const o2 = String(r2);
+      e2.stack.push(s2.startsWith(o2));
     }
   },
-  [n.STRING_TRIM]: {
+  [i$2.STRING_TRIM]: {
     stackIn: 1,
     stackOut: 1,
     execute: (e2, t$1) => {
@@ -2248,7 +2358,7 @@ const ae = {
       e2.stack.push(r2.trim());
     }
   },
-  [n.STRING_TRIM_START]: {
+  [i$2.STRING_TRIM_START]: {
     stackIn: 1,
     stackOut: 1,
     execute: (e2, t$1) => {
@@ -2263,7 +2373,7 @@ const ae = {
       e2.stack.push(r2.trimStart());
     }
   },
-  [n.STRING_TRIM_END]: {
+  [i$2.STRING_TRIM_END]: {
     stackIn: 1,
     stackOut: 1,
     execute: (e2, t$1) => {
@@ -2278,61 +2388,61 @@ const ae = {
       e2.stack.push(r2.trimEnd());
     }
   },
-  [n.STRING_REPLACE]: {
+  [i$2.STRING_REPLACE]: {
     stackIn: 3,
     // string, search, replacement
     stackOut: 1,
     execute: (e2, t$1) => {
-      const r2 = e2.stack.pop(), o2 = e2.stack.pop(), s2 = e2.stack.pop();
-      if (!t(s2))
+      const r2 = e2.stack.pop(), s2 = e2.stack.pop(), o2 = e2.stack.pop();
+      if (!t(o2))
         return {
           type: "RuntimeError",
           message: "STRING_REPLACE requires a string",
           pc: e2.pc,
           opcode: t$1.op
         };
-      const c2 = String(o2), p2 = String(r2), a2 = s2.indexOf(c2), u2 = a2 === -1 ? s2 : s2.substring(0, a2) + p2 + s2.substring(a2 + c2.length);
-      e2.stack.push(u2);
+      const c2 = String(s2), p2 = String(r2), a2 = o2.indexOf(c2), i2 = a2 === -1 ? o2 : o2.substring(0, a2) + p2 + o2.substring(a2 + c2.length);
+      e2.stack.push(i2);
     }
   },
-  [n.STRING_REPLACE_ALL]: {
+  [i$2.STRING_REPLACE_ALL]: {
     stackIn: 3,
     stackOut: 1,
     execute: (e2, t$1) => {
-      const r2 = e2.stack.pop(), o2 = e2.stack.pop(), s2 = e2.stack.pop();
-      if (!t(s2))
+      const r2 = e2.stack.pop(), s2 = e2.stack.pop(), o2 = e2.stack.pop();
+      if (!t(o2))
         return {
           type: "RuntimeError",
           message: "STRING_REPLACE_ALL requires a string",
           pc: e2.pc,
           opcode: t$1.op
         };
-      const c2 = String(o2), p2 = String(r2), a2 = s2.split(c2).join(p2);
+      const c2 = String(s2), p2 = String(r2), a2 = o2.split(c2).join(p2);
       e2.stack.push(a2);
     }
   },
-  [n.STRING_LAST_INDEX_OF]: {
+  [i$2.STRING_LAST_INDEX_OF]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t$1) => {
-      const r2 = e2.stack.pop(), o2 = e2.stack.pop();
-      if (!t(o2))
+      const r2 = e2.stack.pop(), s2 = e2.stack.pop();
+      if (!t(s2))
         return {
           type: "RuntimeError",
           message: "STRING_LAST_INDEX_OF requires a string",
           pc: e2.pc,
           opcode: t$1.op
         };
-      const s2 = String(r2);
-      e2.stack.push(o2.lastIndexOf(s2));
+      const o2 = String(r2);
+      e2.stack.push(s2.lastIndexOf(o2));
     }
   },
-  [n.STRING_REPEAT]: {
+  [i$2.STRING_REPEAT]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t$1) => {
-      const r2 = e2.stack.pop(), o2 = e2.stack.pop();
-      if (!t(o2))
+      const r2 = e2.stack.pop(), s2 = e2.stack.pop();
+      if (!t(s2))
         return {
           type: "RuntimeError",
           message: "STRING_REPEAT requires a string",
@@ -2346,23 +2456,23 @@ const ae = {
           pc: e2.pc,
           opcode: t$1.op
         };
-      e2.stack.push(o2.repeat(Math.floor(r2)));
+      e2.stack.push(s2.repeat(Math.floor(r2)));
     }
   },
-  [n.STRING_PAD_START]: {
+  [i$2.STRING_PAD_START]: {
     stackIn: 3,
     // string, targetLength, padString
     stackOut: 1,
     execute: (e2, t$1) => {
-      const r2 = e2.stack.pop(), o2 = e2.stack.pop(), s2 = e2.stack.pop();
-      if (!t(s2))
+      const r2 = e2.stack.pop(), s2 = e2.stack.pop(), o2 = e2.stack.pop();
+      if (!t(o2))
         return {
           type: "RuntimeError",
           message: "STRING_PAD_START requires a string",
           pc: e2.pc,
           opcode: t$1.op
         };
-      if (!i$1(o2))
+      if (!i$1(s2))
         return {
           type: "RuntimeError",
           message: "STRING_PAD_START requires number for length",
@@ -2370,22 +2480,22 @@ const ae = {
           opcode: t$1.op
         };
       const c2 = t(r2) ? r2 : String(r2);
-      e2.stack.push(s2.padStart(o2, c2 || " "));
+      e2.stack.push(o2.padStart(s2, c2 || " "));
     }
   },
-  [n.STRING_PAD_END]: {
+  [i$2.STRING_PAD_END]: {
     stackIn: 3,
     stackOut: 1,
     execute: (e2, t$1) => {
-      const r2 = e2.stack.pop(), o2 = e2.stack.pop(), s2 = e2.stack.pop();
-      if (!t(s2))
+      const r2 = e2.stack.pop(), s2 = e2.stack.pop(), o2 = e2.stack.pop();
+      if (!t(o2))
         return {
           type: "RuntimeError",
           message: "STRING_PAD_END requires a string",
           pc: e2.pc,
           opcode: t$1.op
         };
-      if (!i$1(o2))
+      if (!i$1(s2))
         return {
           type: "RuntimeError",
           message: "STRING_PAD_END requires number for length",
@@ -2393,58 +2503,58 @@ const ae = {
           opcode: t$1.op
         };
       const c2 = t(r2) ? r2 : String(r2);
-      e2.stack.push(s2.padEnd(o2, c2 || " "));
+      e2.stack.push(o2.padEnd(s2, c2 || " "));
     }
   }
 };
-function P(e2, t2) {
+function j(e2, t2) {
   if (u$1(e2)) {
     const r2 = t2.get(e2.id);
-    return r2 && r2.type === "array" ? r2.data.elements.map((s2) => P(s2, t2)) : null;
+    return r2 && r2.type === "array" ? r2.data.elements.map((o2) => j(o2, t2)) : null;
   }
-  if (b$1(e2)) {
+  if (b(e2)) {
     const r2 = t2.get(e2.id);
     if (r2 && r2.type === "object") {
-      const o2 = r2.data, s2 = {};
-      for (const [c2, p2] of Object.entries(o2.properties))
-        s2[c2] = P(p2, t2);
-      return s2;
+      const s2 = r2.data, o2 = {};
+      for (const [c2, p2] of Object.entries(s2.properties))
+        o2[c2] = j(p2, t2);
+      return o2;
     }
     return null;
   }
   if (o(e2))
-    return e2.elements.map((r2) => P(r2, t2));
+    return e2.elements.map((r2) => j(r2, t2));
   if (y(e2)) {
     const r2 = {};
-    for (const [o2, s2] of Object.entries(e2.properties))
-      r2[o2] = P(s2, t2);
+    for (const [s2, o2] of Object.entries(e2.properties))
+      r2[s2] = j(o2, t2);
     return r2;
   }
   if (!c(e2))
     return e2;
 }
-const de = {
-  [n.OBJECT_CREATE]: {
+const le = {
+  [i$2.OBJECT_CREATE]: {
     stackIn: 0,
     stackOut: 1,
     execute: (e2) => {
-      const t2 = M$1(), r2 = e2.heap.allocate("object", t2);
+      const t2 = M(), r2 = e2.heap.allocate("object", t2);
       e2.stack.push(r2);
     }
   },
-  [n.PROPERTY_SET]: {
+  [i$2.PROPERTY_SET]: {
     stackIn: 3,
     stackOut: 1,
     execute: (e2, t2) => {
-      const r2 = l(e2, t2.op);
+      const r2 = d(e2, t2.op);
       if (f2(r2)) return r2;
-      const o2 = l(e2, t2.op);
-      if (f2(o2)) return o2;
-      const s2 = l(e2, t2.op);
+      const s2 = d(e2, t2.op);
       if (f2(s2)) return s2;
+      const o2 = d(e2, t2.op);
+      if (f2(o2)) return o2;
       let c2;
-      if (b$1(s2)) {
-        const a2 = e2.heap.get(s2.id);
+      if (b(o2)) {
+        const a2 = e2.heap.get(o2.id);
         if (!a2 || a2.type !== "object")
           return {
             type: "RuntimeError",
@@ -2453,37 +2563,37 @@ const de = {
             opcode: t2.op
           };
         c2 = a2.data;
-      } else if (y(s2))
-        c2 = s2;
+      } else if (y(o2))
+        c2 = o2;
       else
         return {
           type: "RuntimeError",
-          message: `Cannot set property '${o2}' on ${d$1(s2)}`,
+          message: `Cannot set property '${s2}' on ${d$2(o2)}`,
           pc: e2.pc,
           opcode: t2.op
         };
-      const p2 = p$1(o2);
-      c2.properties[p2] = r2, e2.stack.push(s2);
+      const p2 = p$1(s2);
+      c2.properties[p2] = r2, e2.stack.push(o2);
     }
   },
-  [n.PROPERTY_GET]: {
+  [i$2.PROPERTY_GET]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t2) => {
-      const r2 = l(e2, t2.op);
+      const r2 = d(e2, t2.op);
       if (f2(r2)) return r2;
-      const o2 = l(e2, t2.op);
-      if (f2(o2)) return o2;
-      if (f$2(o2) || c(o2))
+      const s2 = d(e2, t2.op);
+      if (f2(s2)) return s2;
+      if (f$2(s2) || c(s2))
         return {
           type: "RuntimeError",
-          message: `Cannot read property '${r2}' of ${d$1(o2)}`,
+          message: `Cannot read property '${r2}' of ${d$2(s2)}`,
           pc: e2.pc,
           opcode: t2.op
         };
-      let s2 = null;
-      if (b$1(o2)) {
-        const p2 = e2.heap.get(o2.id);
+      let o2 = null;
+      if (b(s2)) {
+        const p2 = e2.heap.get(s2.id);
         if (!p2 || p2.type !== "object")
           return {
             type: "RuntimeError",
@@ -2491,36 +2601,110 @@ const de = {
             pc: e2.pc,
             opcode: t2.op
           };
-        s2 = p2.data;
-      } else if (y(o2))
-        s2 = o2;
+        o2 = p2.data;
+      } else if (y(s2))
+        o2 = s2;
       else {
-        e2.stack.push(C());
+        e2.stack.push(C$1());
         return;
       }
-      const c$1 = s2.properties[p$1(r2)];
-      e2.stack.push(c$1 ?? C());
+      const c$1 = o2.properties[p$1(r2)];
+      e2.stack.push(c$1 ?? C$1());
     }
   },
-  [n.JSON_STRINGIFY]: {
+  [i$2.JSON_STRINGIFY]: {
     stackIn: 1,
     stackOut: 1,
     execute: (e2, t2) => {
-      const r2 = l(e2, t2.op);
+      const r2 = d(e2, t2.op);
+      if (f2(r2)) return r2;
+      const s2 = j(r2, e2.heap);
+      e2.stack.push(JSON.stringify(s2));
+    }
+  },
+  [i$2.OBJECT_KEYS]: {
+    stackIn: 1,
+    stackOut: 1,
+    execute: (e2, t2) => {
+      const r2 = d(e2, t2.op);
+      if (f2(r2)) return r2;
+      if (b(r2)) {
+        const s2 = e2.heap.get(r2.id);
+        if (s2 && s2.type === "object") {
+          const o2 = s2.data, c2 = Object.keys(o2.properties), p2 = e2.heap.allocate("array", { type: "array", elements: c2 });
+          e2.stack.push(p2);
+        } else
+          e2.stack.push(null);
+      } else if (y(r2)) {
+        const s2 = Object.keys(r2.properties), o2 = e2.heap.allocate("array", { type: "array", elements: s2 });
+        e2.stack.push(o2);
+      } else
+        e2.stack.push(null);
+    }
+  }
+}, de = {
+  [i$2.OBJECT_ITER_START]: {
+    stackIn: 1,
+    stackOut: 0,
+    execute: (e2, t2) => {
+      const r2 = d(e2, t2.op);
       if (f2(r2)) return r2;
-      const o2 = P(r2, e2.heap);
-      e2.stack.push(JSON.stringify(o2));
+      if (b(r2)) {
+        const s2 = e2.heap.get(r2.id);
+        if (s2 && s2.type === "object") {
+          const o2 = s2.data, c2 = Object.keys(o2.properties);
+          e2.iterators.push({
+            array: null,
+            keys: c2,
+            index: 0,
+            length: c2.length
+          });
+        } else
+          e2.iterators.push({
+            array: null,
+            keys: [],
+            index: 0,
+            length: 0
+          });
+      } else if (y(r2)) {
+        const s2 = Object.keys(r2.properties);
+        e2.iterators.push({
+          array: null,
+          keys: s2,
+          index: 0,
+          length: s2.length
+        });
+      } else
+        e2.iterators.push({
+          array: null,
+          keys: [],
+          index: 0,
+          length: 0
+        });
+    }
+  },
+  [i$2.OBJECT_ITER_NEXT]: {
+    stackIn: 0,
+    stackOut: 2,
+    // Push key and hasNext
+    execute: (e2, t2) => {
+      const r2 = e2.iterators[e2.iterators.length - 1];
+      if (r2 && r2.index < r2.length && r2.keys) {
+        const s2 = r2.keys[r2.index];
+        e2.stack.push(s2), e2.stack.push(true), r2.index++;
+      } else
+        e2.stack.push(null), e2.stack.push(false);
     }
   }
-}, le = {
-  [n.GET]: {
+}, fe = {
+  [i$2.GET]: {
     stackIn: 2,
     stackOut: 1,
     execute: (e2, t$1) => {
-      var s2;
-      const r2 = e2.stack.pop(), o2 = e2.stack.pop();
-      if (u$1(o2)) {
-        const c2 = e2.heap.get(o2.id);
+      var o2;
+      const r2 = e2.stack.pop(), s2 = e2.stack.pop();
+      if (u$1(s2)) {
+        const c2 = e2.heap.get(s2.id);
         if (!c2 || c2.type !== "array")
           return {
             type: "RuntimeError",
@@ -2533,11 +2717,11 @@ const de = {
         if (i$1(r2))
           a2 = r2;
         else if (t(r2)) {
-          const i2 = parseInt(r2, 10);
-          if (!isNaN(i2) && i2.toString() === r2 && i2 >= 0)
-            a2 = i2;
+          const u2 = parseInt(r2, 10);
+          if (!isNaN(u2) && u2.toString() === r2 && u2 >= 0)
+            a2 = u2;
           else {
-            const y2 = ((s2 = p2.properties) == null ? void 0 : s2[r2]) ?? C();
+            const y2 = ((o2 = p2.properties) == null ? void 0 : o2[r2]) ?? C$1();
             e2.stack.push(y2);
             return;
           }
@@ -2548,11 +2732,11 @@ const de = {
             pc: e2.pc,
             opcode: t$1.op
           };
-        const u2 = p2.elements[a2] ?? C();
-        e2.stack.push(u2);
+        const i2 = p2.elements[a2] ?? C$1();
+        e2.stack.push(i2);
         return;
-      } else if (b$1(o2)) {
-        const c2 = e2.heap.get(o2.id);
+      } else if (b(s2)) {
+        const c2 = e2.heap.get(s2.id);
         if (!c2 || c2.type !== "object")
           return {
             type: "RuntimeError",
@@ -2560,10 +2744,10 @@ const de = {
             pc: e2.pc,
             opcode: t$1.op
           };
-        const p2 = c2.data, a2 = p$1(r2), u2 = p2.properties[a2] ?? C();
-        e2.stack.push(u2);
+        const p2 = c2.data, a2 = p$1(r2), i2 = p2.properties[a2] ?? C$1();
+        e2.stack.push(i2);
         return;
-      } else if (t(o2)) {
+      } else if (t(s2)) {
         let c2;
         if (i$1(r2))
           c2 = r2;
@@ -2571,7 +2755,7 @@ const de = {
           const p2 = parseInt(r2, 10);
           !isNaN(p2) && p2.toString() === r2 && (c2 = p2);
         }
-        c2 !== void 0 && c2 >= 0 && c2 < o2.length ? e2.stack.push(o2[c2]) : e2.stack.push(C());
+        c2 !== void 0 && c2 >= 0 && c2 < s2.length ? e2.stack.push(s2[c2]) : e2.stack.push(C$1());
         return;
       } else
         return {
@@ -2582,13 +2766,13 @@ const de = {
         };
     }
   },
-  [n.SET]: {
+  [i$2.SET]: {
     stackIn: 3,
     stackOut: 1,
     execute: (e2, t$1) => {
-      const r2 = e2.stack.pop(), o2 = e2.stack.pop(), s2 = e2.stack.pop();
-      if (u$1(s2)) {
-        const c2 = e2.heap.get(s2.id);
+      const r2 = e2.stack.pop(), s2 = e2.stack.pop(), o2 = e2.stack.pop();
+      if (u$1(o2)) {
+        const c2 = e2.heap.get(o2.id);
         if (!c2 || c2.type !== "array")
           return {
             type: "RuntimeError",
@@ -2598,14 +2782,14 @@ const de = {
           };
         const p2 = c2.data;
         let a2;
-        if (i$1(o2))
-          a2 = o2;
-        else if (t(o2)) {
-          const i2 = parseInt(o2, 10);
-          if (!isNaN(i2) && i2.toString() === o2 && i2 >= 0)
-            a2 = i2;
+        if (i$1(s2))
+          a2 = s2;
+        else if (t(s2)) {
+          const u2 = parseInt(s2, 10);
+          if (!isNaN(u2) && u2.toString() === s2 && u2 >= 0)
+            a2 = u2;
           else {
-            p2.properties || (p2.properties = {}), p2.properties[o2] = r2, e2.stack.push(s2);
+            p2.properties || (p2.properties = {}), p2.properties[s2] = r2, e2.stack.push(o2);
             return;
           }
         } else
@@ -2615,18 +2799,18 @@ const de = {
             pc: e2.pc,
             opcode: t$1.op
           };
-        const u2 = Math.floor(a2);
-        if (u2 < 0)
+        const i2 = Math.floor(a2);
+        if (i2 < 0)
           return {
             type: "RuntimeError",
             message: "SET: Negative index not allowed",
             pc: e2.pc,
             opcode: t$1.op
           };
-        p2.elements[u2] = r2, e2.stack.push(s2);
+        p2.elements[i2] = r2, e2.stack.push(o2);
         return;
-      } else if (b$1(s2)) {
-        const c2 = e2.heap.get(s2.id);
+      } else if (b(o2)) {
+        const c2 = e2.heap.get(o2.id);
         if (!c2 || c2.type !== "object")
           return {
             type: "RuntimeError",
@@ -2634,8 +2818,8 @@ const de = {
             pc: e2.pc,
             opcode: t$1.op
           };
-        const p2 = c2.data, a2 = p$1(o2);
-        p2.properties[a2] = r2, e2.stack.push(s2);
+        const p2 = c2.data, a2 = p$1(s2);
+        p2.properties[a2] = r2, e2.stack.push(o2);
         return;
       } else
         return {
@@ -2646,40 +2830,80 @@ const de = {
         };
     }
   }
+}, ke = {
+  stackIn: 0,
+  // Consumes no stack items
+  stackOut: 1,
+  // Produces one stack item (heap reference)
+  execute: (e2, t2) => {
+    const r2 = t2.arg;
+    if (!r2 || typeof r2.pattern != "string" || typeof r2.flags != "string")
+      return {
+        type: "TypeError",
+        message: "LOAD_REGEX instruction requires pattern and flags properties",
+        pc: e2.pc,
+        opcode: t2.op
+      };
+    try {
+      const s2 = new RegExp(r2.pattern, r2.flags), o2 = {
+        type: "object",
+        properties: {
+          source: s2.source,
+          flags: s2.flags,
+          global: s2.global,
+          ignoreCase: s2.ignoreCase,
+          multiline: s2.multiline
+        }
+      }, c2 = e2.heap.allocate("object", o2);
+      e2.stack.push(c2);
+      return;
+    } catch (s2) {
+      return {
+        type: "SyntaxError",
+        message: `Invalid regular expression: ${s2.message}`,
+        pc: e2.pc,
+        opcode: t2.op
+      };
+    }
+  }
+}, me = {
+  [i$2.LOAD_REGEX]: ke
 }, F = {
   ...Z,
   ...ee,
   ...re,
   ...te,
-  ...oe,
   ...se,
+  ...oe,
   ...ce,
   ...ne,
   ...pe,
   ...ae,
-  ...ue,
   ...ie,
+  ...ue,
+  ...le,
   ...de,
-  ...le
+  ...fe,
+  ...me
 };
-function j() {
+function w() {
   const e2 = /* @__PURE__ */ new Map();
   let t2 = 1;
   return {
     objects: e2,
     nextId: t2,
-    allocate(r2, o2) {
-      const s2 = t2++, c2 = { id: s2, type: r2, data: o2 };
-      return e2.set(s2, c2), r2 === "array" ? { type: "array-ref", id: s2 } : { type: "object-ref", id: s2 };
+    allocate(r2, s2) {
+      const o2 = t2++, c2 = { id: o2, type: r2, data: s2 };
+      return e2.set(o2, c2), r2 === "array" ? { type: "array-ref", id: o2 } : { type: "object-ref", id: o2 };
     },
     get(r2) {
-      const o2 = e2.get(r2);
-      if (o2)
-        return o2;
+      const s2 = e2.get(r2);
+      if (s2)
+        return s2;
     }
   };
 }
-class w {
+class C {
   createInitialState() {
     return {
       pc: 0,
@@ -2688,74 +2912,74 @@ class w {
       status: "running",
       output: [],
       iterators: [],
-      heap: j()
+      heap: w()
     };
   }
   executeInstruction(t2, r2) {
-    const o2 = F[r2.op];
-    if (!o2)
+    const s2 = F[r2.op];
+    if (!s2)
       throw new Error(`Unknown opcode: ${r2.op}`);
-    const s2 = this.validateStack(o2, r2, t2);
-    if (s2) {
-      t2.status = "error", t2.error = s2.message;
+    const o2 = this.validateStack(s2, r2, t2);
+    if (o2) {
+      t2.status = "error", t2.error = o2.message;
       return;
     }
-    o2.execute(t2, r2), t2.pc++;
+    s2.execute(t2, r2), t2.pc++;
   }
-  validateStack(t2, r2, o2) {
-    if (o2.stack.length < t2.stackIn)
+  validateStack(t2, r2, s2) {
+    if (s2.stack.length < t2.stackIn)
       return {
         type: "StackUnderflow",
-        message: `${n[r2.op]}: Stack underflow`,
-        pc: o2.pc,
+        message: `${i$2[r2.op]}: Stack underflow`,
+        pc: s2.pc,
         opcode: r2.op
       };
   }
-  execute(t2, r2, o2) {
-    const s2 = {
+  execute(t2, r2, s2) {
+    const o2 = {
       pc: (r2 == null ? void 0 : r2.pc) ?? 0,
       stack: (r2 == null ? void 0 : r2.stack) ?? [],
       variables: (r2 == null ? void 0 : r2.variables) ?? /* @__PURE__ */ new Map(),
       status: "running",
       output: (r2 == null ? void 0 : r2.output) ?? [],
       iterators: (r2 == null ? void 0 : r2.iterators) ?? [],
-      fileSystem: o2,
-      heap: (r2 == null ? void 0 : r2.heap) ?? j(),
+      fileSystem: s2,
+      heap: (r2 == null ? void 0 : r2.heap) ?? w(),
       ...r2
     };
-    for (; s2.status === "running" && s2.pc < t2.length; ) {
-      const c2 = t2[s2.pc], p2 = F[c2.op];
+    for (; o2.status === "running" && o2.pc < t2.length; ) {
+      const c2 = t2[o2.pc], p2 = F[c2.op];
       if (p2) {
-        const a2 = this.validateStack(p2, c2, s2);
+        const a2 = this.validateStack(p2, c2, o2);
         if (a2) {
-          s2.status = "error", s2.error = a2.message;
+          o2.status = "error", o2.error = a2.message;
           break;
         }
-        if ((c2.op === n.JUMP || c2.op === n.JUMP_IF_FALSE || c2.op === n.JUMP_IF || c2.op === n.JUMP_IF_TRUE || c2.op === n.BREAK || c2.op === n.CONTINUE) && c2.arg !== void 0 && c2.arg >= t2.length) {
-          s2.status = "error";
-          const i2 = c2.op === n.JUMP || c2.op === n.JUMP_IF_FALSE || c2.op === n.JUMP_IF || c2.op === n.JUMP_IF_TRUE ? "jump" : c2.op === n.BREAK ? "break" : "continue";
-          s2.error = `Invalid ${i2} target: ${c2.arg}`;
+        if ((c2.op === i$2.JUMP || c2.op === i$2.JUMP_IF_FALSE || c2.op === i$2.JUMP_IF || c2.op === i$2.JUMP_IF_TRUE || c2.op === i$2.BREAK || c2.op === i$2.CONTINUE) && c2.arg !== void 0 && c2.arg >= t2.length) {
+          o2.status = "error";
+          const u2 = c2.op === i$2.JUMP || c2.op === i$2.JUMP_IF_FALSE || c2.op === i$2.JUMP_IF || c2.op === i$2.JUMP_IF_TRUE ? "jump" : c2.op === i$2.BREAK ? "break" : "continue";
+          o2.error = `Invalid ${u2} target: ${c2.arg}`;
           break;
         }
-        const u2 = p2.execute(s2, c2);
-        if (u2) {
-          const i2 = s2.pc + 1;
-          if (i2 < t2.length && t2[i2].op === n.CC) {
-            s2.ccPrompt = `ERROR: ${u2.message}. How should I proceed?`, s2.status = "waiting_cc", s2.pc = i2;
+        const i2 = p2.execute(o2, c2);
+        if (i2) {
+          const u2 = o2.pc + 1;
+          if (u2 < t2.length && t2[u2].op === i$2.CC) {
+            o2.ccPrompt = `ERROR: ${i2.message}. How should I proceed?`, o2.status = "waiting_cc", o2.pc = u2;
             break;
           }
-          s2.status = "error", s2.error = u2.message;
+          o2.status = "error", o2.error = i2.message;
           break;
         }
-        p2.controlsPC || s2.pc++;
+        p2.controlsPC || o2.pc++;
         continue;
       }
-      s2.status = "error", s2.error = `Unknown opcode: ${n[c2.op]}`;
+      o2.status = "error", o2.error = `Unknown opcode: ${i$2[c2.op]}`;
       break;
     }
-    return s2;
+    return o2;
   }
-  resume(t2, r2, o2, s2) {
+  resume(t2, r2, s2, o2) {
     if (t2.status !== "waiting_cc")
       throw new Error("Cannot resume: VM not waiting for CC");
     const c2 = {
@@ -2765,47 +2989,47 @@ class w {
       ccPrompt: void 0,
       pc: t2.pc + 1
     };
-    return this.execute(o2, c2, s2 || t2.fileSystem);
+    return this.execute(s2, c2, o2 || t2.fileSystem);
   }
 }
-class D {
+class V {
   constructor() {
-    b(this, "sandboxPaths", []);
+    _(this, "sandboxPaths", []);
     const t2 = process.env.CVM_SANDBOX_PATHS, r2 = process.env.CVM_SANDBOX_ROOT;
-    t2 ? this.sandboxPaths = t2.split(",").map((o2) => r__namespace.resolve(o2.trim())) : r2 && (this.sandboxPaths = [r__namespace.resolve(r2)]);
+    t2 ? this.sandboxPaths = t2.split(",").map((s2) => r__namespace.resolve(s2.trim())) : r2 && (this.sandboxPaths = [r__namespace.resolve(r2)]);
   }
   isPathAllowed(t2) {
     const r2 = r__namespace.resolve(t2);
     return r2.includes("..") || this.sandboxPaths.length === 0 ? false : this.sandboxPaths.some(
-      (o2) => r2.startsWith(o2)
+      (s2) => r2.startsWith(s2)
     );
   }
   listFiles(t2, r2 = {}) {
-    const o2 = s();
+    const s$12 = s();
     if (!this.isPathAllowed(t2))
-      return o2;
+      return s$12;
     try {
-      const s2 = r__namespace.resolve(t2);
-      this.listFilesRecursive(s2, s2, o2.elements, r2);
+      const o2 = r__namespace.resolve(t2);
+      this.listFilesRecursive(o2, o2, s$12.elements, r2);
     } catch {
     }
-    return o2;
+    return s$12;
   }
   matchesPattern(t2, r2) {
-    let o2 = r2.replace(/\./g, "\\.").replace(/\*\*/g, "__DOUBLESTAR__").replace(/\*/g, "[^/]*").replace(/__DOUBLESTAR__/g, ".*").replace(/\?/g, ".");
-    o2 = "^" + o2 + "$";
+    let s2 = r2.replace(/\./g, "\\.").replace(/\*\*/g, "__DOUBLESTAR__").replace(/\*/g, "[^/]*").replace(/__DOUBLESTAR__/g, ".*").replace(/\?/g, ".");
+    s2 = "^" + s2 + "$";
     try {
-      return new RegExp(o2).test(t2);
+      return new RegExp(s2).test(t2);
     } catch {
       return true;
     }
   }
-  listFilesRecursive(t2, r2, o2, s2, c2 = 0) {
+  listFilesRecursive(t2, r2, s2, o2, c2 = 0) {
     try {
-      const p2 = x__namespace.readdirSync(r2, { withFileTypes: true });
+      const p2 = N__namespace.readdirSync(r2, { withFileTypes: true });
       for (const a2 of p2) {
-        const u2 = r__namespace.join(r2, a2.name), i2 = r__namespace.relative(t2, u2);
-        a2.isSymbolicLink() || s2.filter && !this.matchesPattern(i2, s2.filter) || (o2.push(u2), a2.isDirectory() && s2.recursive && this.listFilesRecursive(t2, u2, o2, s2, c2 + 1));
+        const i2 = r__namespace.join(r2, a2.name), u2 = r__namespace.relative(t2, i2);
+        a2.isSymbolicLink() || o2.filter && !this.matchesPattern(u2, o2.filter) || (s2.push(i2), a2.isDirectory() && o2.recursive && this.listFilesRecursive(t2, i2, s2, o2, c2 + 1));
       }
     } catch {
     }
@@ -2814,8 +3038,8 @@ class D {
     if (!this.isPathAllowed(t2))
       return null;
     try {
-      const r2 = r__namespace.resolve(t2), o2 = x__namespace.lstatSync(r2);
-      return o2.isSymbolicLink() || !o2.isFile() ? null : x__namespace.readFileSync(r2, "utf-8");
+      const r2 = r__namespace.resolve(t2), s2 = N__namespace.lstatSync(r2);
+      return s2.isSymbolicLink() || !s2.isFile() ? null : N__namespace.readFileSync(r2, "utf-8");
     } catch {
       return null;
     }
@@ -2824,29 +3048,29 @@ class D {
     if (!this.isPathAllowed(t2))
       return false;
     try {
-      const o2 = r__namespace.resolve(t2), s2 = r__namespace.dirname(o2);
-      if (!this.isPathAllowed(s2))
+      const s2 = r__namespace.resolve(t2), o2 = r__namespace.dirname(s2);
+      if (!this.isPathAllowed(o2))
         return false;
       try {
-        if (x__namespace.lstatSync(o2).isSymbolicLink())
+        if (N__namespace.lstatSync(s2).isSymbolicLink())
           return false;
       } catch (c2) {
         if (c2.code !== "ENOENT")
           return false;
       }
-      return x__namespace.mkdirSync(s2, { recursive: true }), x__namespace.writeFileSync(o2, r2, "utf-8"), true;
+      return N__namespace.mkdirSync(o2, { recursive: true }), N__namespace.writeFileSync(s2, r2, "utf-8"), true;
     } catch {
       return false;
     }
   }
 }
-new D();
-class he {
+new V();
+class Ie {
   constructor(t2, r2) {
-    b(this, "vms", /* @__PURE__ */ new Map());
-    b(this, "storage");
-    b(this, "fileSystem");
-    t2 ? this.storage = t2 : this.storage = E.create(), this.fileSystem = r2 || new D();
+    _(this, "vms", /* @__PURE__ */ new Map());
+    _(this, "storage");
+    _(this, "fileSystem");
+    t2 ? this.storage = t2 : this.storage = E.create(), this.fileSystem = r2 || new V();
   }
   /**
    * Initialize the VMManager (connect to database)
@@ -2864,18 +3088,18 @@ class he {
    * Load and compile a program from source code
    */
   async loadProgram(t2, r2) {
-    const o2 = X(r2);
-    if (!o2.success)
-      throw new Error(`Compilation failed: ${o2.errors.join(", ")}`);
-    const s2 = {
+    const s2 = te$1(r2);
+    if (!s2.success)
+      throw new Error(`Compilation failed: ${s2.errors.join(", ")}`);
+    const o2 = {
       id: t2,
       name: t2,
       source: r2,
-      bytecode: o2.bytecode,
+      bytecode: s2.bytecode,
       // VM decides internal format
       created: /* @__PURE__ */ new Date()
     };
-    await this.storage.saveProgram(s2);
+    await this.storage.saveProgram(o2);
   }
   /**
    * Start execution of a loaded program
@@ -2883,7 +3107,7 @@ class he {
   async startExecution(t2, r2) {
     if (!await this.storage.getProgram(t2))
       throw new Error(`Program not found: ${t2}`);
-    const s2 = {
+    const o2 = {
       id: r2,
       programId: t2,
       state: "READY",
@@ -2892,8 +3116,8 @@ class he {
       variables: {},
       created: /* @__PURE__ */ new Date()
     };
-    await this.storage.saveExecution(s2);
-    const c2 = new w();
+    await this.storage.saveExecution(o2);
+    const c2 = new C();
     this.vms.set(r2, c2);
   }
   /**
@@ -2905,17 +3129,17 @@ class he {
     if (!r2)
       throw new Error(`Execution not found: ${t2}`);
     if (r2.state === "READY" || r2.state === "RUNNING") {
-      const o2 = await this.storage.getProgram(r2.programId);
-      if (!o2)
+      const s2 = await this.storage.getProgram(r2.programId);
+      if (!s2)
         throw new Error(`Program not found: ${r2.programId}`);
-      let s2 = this.vms.get(t2);
-      s2 || (s2 = new w(), this.vms.set(t2, s2));
+      let o2 = this.vms.get(t2);
+      o2 || (o2 = new C(), this.vms.set(t2, o2));
       const c2 = r2.state === "READY" ? {
         pc: 0,
         stack: [],
         variables: /* @__PURE__ */ new Map(),
         output: []
-      } : this.deserializeVMState(r2), p2 = s2.execute(o2.bytecode, c2, this.fileSystem);
+      } : this.deserializeVMState(r2), p2 = o2.execute(s2.bytecode, c2, this.fileSystem);
       p2.output.length > 0 && await this.storage.appendOutput(t2, p2.output);
       const a2 = this.serializeVMState(p2);
       if (Object.assign(r2, a2), p2.status === "complete")
@@ -2956,24 +3180,24 @@ class he {
    * Report result from cognitive operation and continue execution
    */
   async reportCCResult(t2, r2) {
-    const o2 = await this.storage.getExecution(t2);
-    if (!o2)
-      throw new Error(`Execution not found: ${t2}`);
-    const s2 = await this.storage.getProgram(o2.programId);
+    const s2 = await this.storage.getExecution(t2);
     if (!s2)
-      throw new Error(`Program not found: ${o2.programId}`);
+      throw new Error(`Execution not found: ${t2}`);
+    const o2 = await this.storage.getProgram(s2.programId);
+    if (!o2)
+      throw new Error(`Program not found: ${s2.programId}`);
     let c2 = this.vms.get(t2);
-    c2 || (c2 = new w(), this.vms.set(t2, c2));
+    c2 || (c2 = new C(), this.vms.set(t2, c2));
     const p2 = {
-      ...this.deserializeVMState(o2),
+      ...this.deserializeVMState(s2),
       status: "waiting_cc",
       output: [],
       // Start with empty output for resumed execution
       ccPrompt: void 0
-    }, a2 = c2.resume(p2, r2, s2.bytecode, this.fileSystem);
+    }, a2 = c2.resume(p2, r2, o2.bytecode, this.fileSystem);
     a2.output.length > 0 && await this.storage.appendOutput(t2, a2.output);
-    const u2 = this.serializeVMState(a2);
-    Object.assign(o2, u2), a2.status === "complete" ? (o2.state = "COMPLETED", a2.returnValue !== void 0 && (o2.returnValue = a2.returnValue), this.vms.delete(t2)) : a2.status === "error" ? (o2.state = "ERROR", o2.error = a2.error, this.vms.delete(t2)) : a2.status === "waiting_cc" ? (o2.state = "AWAITING_COGNITIVE_RESULT", o2.ccPrompt = a2.ccPrompt) : o2.state = "RUNNING", await this.storage.saveExecution(o2);
+    const i2 = this.serializeVMState(a2);
+    Object.assign(s2, i2), a2.status === "complete" ? (s2.state = "COMPLETED", a2.returnValue !== void 0 && (s2.returnValue = a2.returnValue), this.vms.delete(t2)) : a2.status === "error" ? (s2.state = "ERROR", s2.error = a2.error, this.vms.delete(t2)) : a2.status === "waiting_cc" ? (s2.state = "AWAITING_COGNITIVE_RESULT", s2.ccPrompt = a2.ccPrompt) : s2.state = "RUNNING", await this.storage.saveExecution(s2);
   }
   /**
    * Get current execution status
@@ -3045,22 +3269,22 @@ class he {
    * Restart a program (create new execution and set as current)
    */
   async restartExecution(t2, r2) {
-    const o2 = r2 || `${t2}-${Date.now()}`;
-    return await this.startExecution(t2, o2), await this.setCurrentExecutionId(o2), o2;
+    const s2 = r2 || `${t2}-${Date.now()}`;
+    return await this.startExecution(t2, s2), await this.setCurrentExecutionId(s2), s2;
   }
   /**
    * Serialize heap to storage format
    */
   serializeHeap(t2) {
-    const r2 = (s2, c2) => u$1(c2) || b$1(c2) ? { $ref: c2.id } : c2, o2 = {};
-    return t2.objects.forEach((s2, c2) => {
-      o2[c2] = {
-        type: s2.type,
+    const r2 = (o2, c2) => u$1(c2) || b(c2) ? { $ref: c2.id } : c2, s2 = {};
+    return t2.objects.forEach((o2, c2) => {
+      s2[c2] = {
+        type: o2.type,
         // Serialize each object's data individually with replacer
-        data: JSON.parse(JSON.stringify(s2.data, r2))
+        data: JSON.parse(JSON.stringify(o2.data, r2))
       };
     }), {
-      objects: o2,
+      objects: s2,
       nextId: t2.nextId
     };
   }
@@ -3068,19 +3292,19 @@ class he {
    * Deserialize heap from storage format
    */
   deserializeHeap(t2) {
-    const r2 = j();
+    const r2 = w();
     r2.nextId = t2.nextId;
-    for (const o2 in t2.objects) {
-      const s2 = parseInt(o2, 10), c2 = t2.objects[s2];
-      r2.objects.set(s2, {
-        id: s2,
+    for (const s2 in t2.objects) {
+      const o2 = parseInt(s2, 10), c2 = t2.objects[o2];
+      r2.objects.set(o2, {
+        id: o2,
         type: c2.type,
         data: c2.data
         // Still contains $ref stubs
       });
     }
-    return r2.objects.forEach((o2) => {
-      o2.data = this.restoreReferences(o2.data, r2);
+    return r2.objects.forEach((s2) => {
+      s2.data = this.restoreReferences(s2.data, r2);
     }), r2;
   }
   /**
@@ -3108,7 +3332,7 @@ class he {
       pc: t2.pc || 0,
       stack: t2.stack || [],
       variables: new Map(Object.entries(t2.variables || {})),
-      heap: t2.heap ? this.deserializeHeap(t2.heap) : j(),
+      heap: t2.heap ? this.deserializeHeap(t2.heap) : w(),
       iterators: t2.iterators || [],
       status: t2.status || "running",
       error: t2.error || null,
@@ -3119,16 +3343,16 @@ class he {
   }
   restoreReferences(t2, r2) {
     if (t2 && typeof t2 == "object" && t2.$ref !== void 0) {
-      const o2 = r2.objects.get(t2.$ref);
-      return (o2 == null ? void 0 : o2.type) === "array" ? { type: "array-ref", id: t2.$ref } : (o2 == null ? void 0 : o2.type) === "object" ? { type: "object-ref", id: t2.$ref } : t2;
+      const s2 = r2.objects.get(t2.$ref);
+      return (s2 == null ? void 0 : s2.type) === "array" ? { type: "array-ref", id: t2.$ref } : (s2 == null ? void 0 : s2.type) === "object" ? { type: "object-ref", id: t2.$ref } : t2;
     }
     if (Array.isArray(t2))
-      return t2.map((o2) => this.restoreReferences(o2, r2));
+      return t2.map((s2) => this.restoreReferences(s2, r2));
     if (t2 && typeof t2 == "object") {
-      const o2 = {};
-      for (const s2 in t2)
-        o2[s2] = this.restoreReferences(t2[s2], r2);
-      return o2;
+      const s2 = {};
+      for (const o2 in t2)
+        s2[o2] = this.restoreReferences(t2[o2], r2);
+      return s2;
     }
     return t2;
   }
@@ -3142,7 +3366,7 @@ class $ {
     i(this, "transport", null);
     i(this, "vmManager");
     i(this, "version");
-    this.version = e2, this.vmManager = new he(), this.server = new mcp_js.McpServer({
+    this.version = e2, this.vmManager = new Ie(), this.server = new mcp_js.McpServer({
       name: "cvm-server",
       version: this.version
     }), this.setupTools();
@@ -3180,19 +3404,19 @@ class $ {
       },
       async ({ programId: e2, filePath: r$1 }) => {
         try {
-          const t2 = r.resolve(r$1), n2 = await promises.readFile(t2, "utf-8");
-          return await this.vmManager.loadProgram(e2, n2), {
+          const t2 = r.resolve(r$1), n = await promises.readFile(t2, "utf-8");
+          return await this.vmManager.loadProgram(e2, n), {
             content: [{ type: "text", text: `Program loaded successfully from ${r$1}: ${e2}` }]
           };
         } catch (t2) {
           if (t2 instanceof Error) {
-            const n2 = t2;
-            if (n2.code === "ENOENT")
+            const n = t2;
+            if (n.code === "ENOENT")
               return {
                 content: [{ type: "text", text: `Error: File not found: ${r$1}` }],
                 isError: true
               };
-            if (n2.code === "EACCES")
+            if (n.code === "EACCES")
               return {
                 content: [{ type: "text", text: `Error: Permission denied: ${r$1}` }],
                 isError: true
@@ -3216,9 +3440,9 @@ class $ {
           return await this.vmManager.startExecution(e2, r2), t2 && await this.vmManager.setCurrentExecutionId(r2), {
             content: [{ type: "text", text: `Execution started: ${r2}${t2 ? " (set as current)" : ""}` }]
           };
-        } catch (n2) {
+        } catch (n) {
           return {
-            content: [{ type: "text", text: `Error: ${n2 instanceof Error ? n2.message : "Unknown error"}` }],
+            content: [{ type: "text", text: `Error: ${n instanceof Error ? n.message : "Unknown error"}` }],
             isError: true
           };
         }
@@ -3232,12 +3456,12 @@ class $ {
         try {
           let r2 = e2;
           if (!r2) {
-            const n2 = await this.vmManager.getCurrentExecutionId();
-            if (!n2)
+            const n = await this.vmManager.getCurrentExecutionId();
+            if (!n)
               return {
                 content: [{ type: "text", text: "No current execution set. Use list_executions to see available executions." }]
               };
-            r2 = n2;
+            r2 = n;
           }
           const t2 = await this.vmManager.getNext(r2);
           return t2.type === "completed" ? {
@@ -3268,13 +3492,13 @@ class $ {
         try {
           let t2 = e2;
           if (!t2) {
-            const n2 = await this.vmManager.getCurrentExecutionId();
-            if (!n2)
+            const n = await this.vmManager.getCurrentExecutionId();
+            if (!n)
               return {
                 content: [{ type: "text", text: "Error: No current execution set" }],
                 isError: true
               };
-            t2 = n2;
+            t2 = n;
           }
           return await this.vmManager.reportCCResult(t2, r2), {
             content: [{ type: "text", text: "Execution resumed" }]
@@ -3295,13 +3519,13 @@ class $ {
         try {
           let r2 = e2;
           if (!r2) {
-            const n2 = await this.vmManager.getCurrentExecutionId();
-            if (!n2)
+            const n = await this.vmManager.getCurrentExecutionId();
+            if (!n)
               return {
                 content: [{ type: "text", text: "Error: No current execution set" }],
                 isError: true
               };
-            r2 = n2;
+            r2 = n;
           }
           const t2 = await this.vmManager.getExecutionStatus(r2);
           return {
@@ -3319,14 +3543,14 @@ class $ {
       {},
       async () => {
         try {
-          const e2 = await this.vmManager.listExecutions(), r2 = await this.vmManager.getCurrentExecutionId(), t2 = e2.map((n2) => ({
-            executionId: n2.id,
-            programId: n2.programId,
-            state: n2.state,
-            created: n2.created,
-            isCurrent: n2.id === r2,
+          const e2 = await this.vmManager.listExecutions(), r2 = await this.vmManager.getCurrentExecutionId(), t2 = e2.map((n) => ({
+            executionId: n.id,
+            programId: n.programId,
+            state: n.state,
+            created: n.created,
+            isCurrent: n.id === r2,
             summary: {
-              currentPrompt: n2.state === "AWAITING_COGNITIVE_RESULT" ? n2.ccPrompt : void 0,
+              currentPrompt: n.state === "AWAITING_COGNITIVE_RESULT" ? n.ccPrompt : void 0,
               tasksCompleted: 0
               // TODO: Track this in future
             }
@@ -3358,12 +3582,12 @@ class $ {
               };
             r2 = a2;
           }
-          const t2 = await this.vmManager.getExecutionWithAttempts(r2), n2 = await this.vmManager.getCurrentExecutionId(), c2 = {
+          const t2 = await this.vmManager.getExecutionWithAttempts(r2), n = await this.vmManager.getCurrentExecutionId(), c2 = {
             executionId: t2.id,
             programId: t2.programId,
             state: t2.state,
             created: t2.created,
-            isCurrent: t2.id === n2,
+            isCurrent: t2.id === n,
             currentTask: t2.state === "AWAITING_COGNITIVE_RESULT" ? {
               prompt: t2.ccPrompt,
               attempts: t2.attempts || 1,
@@ -3620,7 +3844,7 @@ async function main() {
     ];
     for (const packageJsonPath of possiblePaths) {
       try {
-        const packageJson = JSON.parse(x$2.readFileSync(packageJsonPath, "utf-8"));
+        const packageJson = JSON.parse(N$1.readFileSync(packageJsonPath, "utf-8"));
         if (packageJson.name === "cvm-server" && packageJson.version) {
           version = packageJson.version;
           break;