novac 1.0.0

package/src/core/executor.js

@@ -0,0 +1,1005 @@
+const {
+  NovaValue,
+  NovaNumber,
+  NovaString,
+  NovaArray,
+  NovaObject,
+  NovaFunction,
+  NovaTemplateString,
+  NovaPointer,
+  NovaBool,
+  NovaNull,
+} = require("./types.js");
+const { CustomError, formatError, NovaException } = require("./error");
+class Scope {
+  constructor(kind = "block", parent = null, globalScope = null) {
+    this.kind = kind;
+    this.parent = parent;
+    this.globalScope = globalScope;
+    this.variables = {
+      scope: this,
+      array: {
+	toCallable: () => (values) => new NovaArray(values)
+      }
+    };
+    this.consts = {};
+    this.prototypes = []; // array of other Scopes or JS objects
+  }
+
+  get(name, prop = null) {
+    let value = null;
+    if (name in this.variables) value = this.variables[name];
+
+    // Look through prototypes
+    for (const proto of this.prototypes) {
+      if (proto instanceof Scope) {
+        // Look up properties directly in the variables of the prototype scope
+        if (proto.parent || proto.globalScope) {
+          const val = proto.get(name);
+          if (val !== undefined) value = val;
+        }
+      } else if (proto && name in proto) {
+        value = proto[name];
+      }
+    }
+
+    if (!value && this.globalScope) value = this.globalScope.get(name);
+    if (!value && this.parent) value = this.parent.get(name);
+
+    if (value?.read) return value?.read?.();
+
+    return prop
+      ? value instanceof Scope
+        ? value.get(prop)
+        : value[prop]
+      : value;
+  }
+
+  delete(name) {
+    if (name in this.variables) delete this.variables[name];
+
+    if (this.parent) this.parent.delete(name);
+    if (this.globalScope) this.globalScope.delete(name);
+
+    return undefined;
+  }
+
+  set(name, value, isConst) {
+    if (this.variables?.[name]?.write) {
+      return (this.variables?.[name]?.write)(value);
+    }
+    if (
+      this.consts.hasOwnProperty(name) &&
+      this.variables.hasOwnProperty(name)
+    ) {
+      throw "Cannot reassign a const.";
+    }
+    if (isConst) {
+      this.consts[name] = value;
+      this.variables[name] = value;
+    } else this.variables[name] = value;
+    return value;
+  }
+
+  has(name) {
+    return name in this.variables;
+  }
+
+  toString() {
+    return `${this.kind.toUpperCase()}`;
+  }
+}
+
+class Executor {
+  // In Executor constructor:
+  constructor(source, stdlib = {}) {
+    this.rawsrc = source;
+    this.taskQueue = [];
+    this.isProcessing = false;
+    this.globalScope = new Scope("global");
+    this.globalScope.variables.std = stdlib;
+
+    // Register setTimeout here
+    const self = this;
+    this.globalScope.set("setTimeout", (fn, delay) => {
+      // fn: The function to call (either native JS or a Nova function node)
+      // delay: The time in ms
+
+      if (typeof fn === "function") {
+        // Case 1: Native JS function (like an arrowfunc or standard JS built-in)
+        setTimeout(fn, delay);
+      } else if (fn && fn.kind === "function" && fn.body) {
+        // Case 2: Nova AST function node
+        // The Nova function node carries its definition scope implicitly, but
+        // here we just use the global scope for simplicity of a scheduled task.
+        // A more robust solution would require passing the function's closure/scope.
+        setTimeout(() => {
+          // Execute the function body using the helper method.
+          // We use the globalScope as the execution environment for the task.
+          self.runFunctionNode(fn, self.globalScope);
+        }, delay);
+      } else {
+        // You may want to throw an error here: 'setTimeout requires a function'
+      }
+    });
+
+    // existing core library addition
+    this.globalScope.set("core", {
+      test: {
+        object: { foo: 42 },
+      },
+      getAst: () => this.ast,
+      json: JSON,
+      print: (value) => {
+        let result = this.stringify(value);
+        process.stdout.write(result + "\n");
+        return "";
+      },
+      register: (fn) => {
+        let fnScope = new Scope("function");
+        let func = function(...args) { self.runFunctionNode(fn, self.globalScope, ...args); };
+        func.registered = true;
+        return func;
+      },
+      vars: self.globalScope.variables,
+    });
+    this.globalScope.set("k", (a) => a * 1000);
+    this.globalScope.set("m", (a) => a * 1000000);
+    this.globalScope.set("h", (a) => a * 100);
+    this.globalScope.set("b", (a) => a * 1000000000);
+  }
+
+  // ===== executor.js (Updated stringify method) =====
+  stringify(value) {
+    if (value instanceof Scope) return value.toString();
+    if (value === null) return '[-Null{null}-]'
+    // Handle all NovaValue wrappers
+    if (value instanceof NovaValue) {
+      if (value instanceof NovaString) return value.valueOf();
+      if (value instanceof NovaNumber) return value.valueOf();
+      if (value instanceof NovaArray) return `Array [${value.length}]`;
+      if (value instanceof NovaObject)
+        return `Object [${Object.keys(value.inner).length}]`;
+      if (value instanceof NovaNull) return "null"; // 🔥 NEW: NovaNull handling
+      if (value instanceof NovaBool) return value.valueOf() ? "true" : "false"; // 🔥 NEW: NovaBool handling
+      return value.toString();
+    }
+
+    // Handle Nova AST/Function Kinds
+    switch (value?.kind) {
+      case "function":
+        return `Function [${value.name}]`;
+      case "class":
+        return `Class [${value.node.name}]`;
+      default:
+        // Handle raw JavaScript types (for external/stdlib values)
+        switch (typeof value) {
+          case "number":
+            return isNaN(value) ? "NaN" : value;
+          case "string":
+            return value;
+          case "object":
+            return `Object [${value}]`;
+          case "function":
+            return `Function [${value.registered ? "Registered" : "NativeJs"}]`;
+        }
+    }
+  }
+
+  // Add this method to the Executor class
+  runFunctionNode(fn, scope, args = []) {
+    const localScope = new Scope("function", scope, this.globalScope); // Parent scope is the definition scope
+    localScope.set("this", scope);
+
+    fn.args.forEach((argName, i) => localScope.set(argName, args[i]));
+
+    let result;
+    try {
+      for (const stmt of fn.body) {
+        result = this.execute(stmt, localScope);
+      }
+    } catch (e) {
+      if (e && "__return" in e) {
+        return e.__return;
+      } else {
+        throw e;
+      }
+    }
+
+    return localScope.get("__return") ?? result;
+  }
+
+  error(msg, node) {
+    throw new new CustomError("RuntimeError")(
+      formatError("ExecError", msg, node.line, node.column, this.rawsrc),
+    );
+  }
+
+  run(ast) {
+    this.ast = ast;
+    if (!ast) return;
+    const statements = Array.isArray(ast) ? ast : ast.nodes;
+    let result;
+    for (const node of statements) {
+      result = this.execute(node, this.globalScope);
+    }
+    return result; // Return the result (may be a Promise)
+  }
+  checkAsync(cond) {
+    setTimeout(() => {
+      if (!cond()) this.checkAsync(cond);
+    }, 10);
+  }
+  execute(node, scope = this.globalScope) {
+    if (!node) return undefined;
+
+    switch (node.kind) {
+      case "EOF":
+        return undefined;
+
+      case "declare": {
+        if (node.destructure) {
+          const val = this.evaluate(node.value, scope);
+          if (node.destructure.kind === "objpattern") {
+            for (const { key, alias } of node.destructure.props) {
+              if (val && Object.prototype.hasOwnProperty.call(val, key)) {
+                scope.set(alias, val[key], node.isConst);
+              } else {
+                this.error(
+                  `Missing property '${key}' in destructured object`,
+                  node,
+                );
+              }
+            }
+          } else if (node.destructure.kind === "arrpattern") {
+            node.destructure.elements.forEach((name, i) => {
+              scope.set(name, val?.[i], node.isConst);
+            });
+          } else {
+            this.error("Invalid destructuring pattern", node);
+          }
+          return val;
+        }
+
+        scope.set(node.name, undefined);
+        let val = this.evaluate(node.value, scope);
+        // 🔥 NEW: Check for isPointer and wrap value
+        if (node.isPointer) {
+          val = new NovaPointer(
+            val,
+            (v) => v, // simple read
+            (newVal, address) => {
+              // Update the pointer's inner value when written to
+              val.inner = newVal;
+            },
+          );
+        }
+
+        return scope.set(node.name, val, node.isConst);
+      }
+
+      case "branch": {
+        let current = node;
+        let executed = false;
+
+        while (current && !executed) {
+          switch (current.type) {
+            // ───── Conditional ─────
+            case "if": {
+              const condition = this.evaluate(current.args, scope);
+              if (condition) {
+                this.run(current.body);
+                executed = true; // stop chaining
+              } else {
+                current = current.next; // try next branch
+              }
+              break;
+            }
+
+            case "else": {
+              this.run(current.body);
+              executed = true;
+              break;
+            }
+
+            case "unless": {
+              // like `if !condition`
+              const condition = this.evaluate(current.args, scope);
+              if (!condition) {
+                this.run(current.body);
+              }
+              executed = true;
+              break;
+            }
+
+            // ───── Loops ─────
+            case "while": {
+              while (
+                this.evaluate(
+                  Array.isArray(current.args) ? current.args[0] : current.args,
+                  scope,
+                )
+              ) {
+                this.run(current.body);
+              }
+              executed = true;
+              break;
+            }
+
+            case "until": {
+              while (
+                !this.evaluate(
+                  Array.isArray(current.args) ? current.args[0] : current.args,
+                  scope,
+                )
+              ) {
+                this.run(current.body);
+              }
+              executed = true;
+              break;
+            }
+
+            case "do": {
+              do {
+                this.run(current.body);
+              } while (
+                this.evaluate(
+                  Array.isArray(current.args) ? current.args[0] : current.args,
+                  scope,
+                )
+              );
+              executed = true;
+              break;
+            }
+
+            case "repeat": {
+              // args[0] = count
+              const times = this.evaluate(
+                Array.isArray(current.args) ? current.args[0] : current.args,
+              );
+              for (let i = 0; i < times; i++) {
+                this.run(current.body);
+              }
+              executed = true;
+              break;
+            }
+
+            case "for": {
+              // for loops: args = [init, condition, update]
+              const [initNode, condNode, updateNode] = current.args;
+              if (initNode) this.execute(initNode, scope);
+              while (!condNode || this.evaluate(condNode, scope)) {
+                this.run(current.body);
+                if (updateNode) this.execute(updateNode, scope);
+              }
+              executed = true;
+              break;
+            }
+
+            default:
+              this.error(`Unknown branch type '${current.type}'`, current);
+          }
+        }
+        break;
+      }
+      case "function": {
+        scope.set(node.name, undefined); // placeholder first
+        const val = node;
+        return scope.set(node.name, val);
+      }
+
+      case "class": {
+        const cls = {};
+        for (const m of node.members) {
+          if (m.kind === "declare") cls[m.name] = m.value;
+          if (m.kind === "function") cls[m.name] = m;
+        }
+
+        let SuperClassConstructor = null;
+        let SuperClassPrototype = null; // Holds the instance Scope of the parent
+
+        if (node.superClass) {
+          const superRef = this.evaluate(node.superClass, scope);
+          if (typeof superRef !== "function") {
+            this.error(`Superclass must be a callable class/constructor`, node);
+          }
+          SuperClassConstructor = superRef;
+
+          SuperClassPrototype = SuperClassConstructor();
+        }
+
+        const constructor = (...args) => {
+          const instanceScope = new Scope("instance", scope, this.globalScope);
+          instanceScope.set("this", instanceScope);
+
+          if (SuperClassPrototype) {
+            instanceScope.prototypes.push(SuperClassPrototype);
+          }
+
+          // Initialize fields and methods (remains the same)
+          for (const key in cls) {
+            const val = cls[key];
+            if (val && val.args && val.body) {
+              instanceScope.set(key, val);
+            } else {
+              instanceScope.set(key, this.evaluate(val, instanceScope));
+            }
+          }
+
+          if (SuperClassConstructor) {
+            const superFunc = function (...superArgs) {
+              // 1. Check if 'super' has already been called (optional, but good for safety)
+              if (instanceScope.get("__super_called__")) {
+                self.error("Super constructor already called", node);
+              }
+              // 2. Call the SuperClassConstructor, binding 'this' to the current instanceScope
+              // We use runFunctionNode if it's a Nova function, or apply if it's a native JS function.
+              if (
+                SuperClassConstructor &&
+                SuperClassConstructor.args &&
+                SuperClassConstructor.body
+              ) {
+                // If the super constructor is a Nova AST function node:
+                self.runFunctionNode(
+                  SuperClassConstructor,
+                  instanceScope,
+                  superArgs,
+                );
+              } else if (typeof SuperClassConstructor === "function") {
+                // If it's a native JS constructor:
+                SuperClassConstructor.apply(instanceScope, superArgs);
+              }
+              // 3. Mark super as called
+              instanceScope.set("__super_called__", true);
+            };
+            // Set the 'super' function within the instance scope
+            instanceScope.set("super", superFunc, true); // Set as const
+          }
+
+          if (SuperClassPrototype) {
+            instanceScope.prototypes.push(SuperClassPrototype);
+          }
+
+          return instanceScope;
+        };
+
+        // Define a key on the constructor function to hold the SuperClass reference
+        constructor.SuperClassConstructor = SuperClassConstructor;
+        constructor.SuperClassPrototype = SuperClassPrototype;
+        constructor.definitionScope = scope;
+        constructor.node = node;
+        constructor.kind = "class";
+
+        return scope.set(node.name, constructor);
+      }
+
+      case "return": {
+        const val = this.evaluate(node.value, scope);
+        scope.set("__return", val);
+        if (node.terminate) throw { __return: val }; // signal function end
+        return val;
+      }
+
+      case "exec":
+        return this.evaluate(node.expr, scope);
+
+      case "throw": {
+        const value = this.evaluate(node.value, scope);
+        const err = new NovaException(value);
+        err.payload = value;
+        err.node = node;
+        throw err;
+      }
+
+      case "try": {
+        let thrownValue = null; // The Nova value to be passed to the 'catch' block
+
+        try {
+          // 1. Run try block
+          for (const stmt of node.tryBody) {
+            this.execute(stmt, scope);
+          }
+        } catch (e) {
+          // Non-local exit: Propagate return/give immediately
+          if (e && "__return" in e) {
+            throw e;
+          }
+
+          // Nova-level exception (thrown from 'throw')
+          else if (e instanceof NovaException) {
+            thrownValue = e.payload; // Retrieve the actual thrown Nova value
+          }
+
+          // Native JS errors (like division by zero). We re-throw for external handling.
+          else {
+            throw e;
+          }
+        } finally {
+          // 3. Run finally block (always runs, and any exit *must* propagate)
+          if (node.finallyBody) {
+            try {
+              for (const stmt of node.finallyBody) {
+                this.execute(stmt, scope);
+              }
+            } catch (e) {
+              // An exit (return, give, or error) in 'finally' takes precedence
+              throw e;
+            }
+          }
+        }
+
+        // 2. Run catch block (only runs if a NovaException was caught)
+        if (thrownValue !== null && node.catchBody) {
+          // The catch block itself can throw or return, so wrap it
+          try {
+            const catchScope = new Scope("catch", scope, this.globalScope);
+            // Bind the thrown value to the catch variable (e.g., 'err' in catch(err))
+            catchScope.set(node.catchName, thrownValue);
+
+            // Execute statements inside the catch block
+            for (const stmt of node.catchBody) {
+              this.execute(stmt, catchScope);
+            }
+          } catch (e) {
+            // Propagate any exit (return, give, or error) from catch
+            throw e;
+          }
+        }
+
+        return undefined;
+      }
+
+      default:
+        this.error(`Unknown node kind: ${node.kind}`, node);
+    }
+  }
+
+  evaluate(expr, scope) {
+    if (!expr || !expr.kind) return undefined;
+
+    switch (expr.kind) {
+      case "EOF":
+        return undefined;
+
+      case "deref": {
+        const ptr = this.evaluate(expr.operand, scope, false);
+        if (ptr instanceof NovaPointer) {
+          // Returning the pointer itself allows it to be the LHS of an assignment
+          return ptr;
+        }
+        this.error("Attempt to dereference a non-pointer value", expr);
+      }
+
+      case "value":
+        const rawValue = expr.value;
+        switch (typeof rawValue) {
+          case "string":
+          case "number":
+            return rawValue;
+          default:
+            // 🔥 NEW: Check for Lexer symbols and wrap them
+            if (rawValue === Symbol("NOVA_TRUE")) return new NovaBool(true);
+            if (rawValue === Symbol("NOVA_FALSE")) return new NovaBool(false);
+            if (rawValue === Symbol("NOVA_NULL")) return new NovaNull();
+
+            return rawValue; // Pass through any other raw JS values
+        }
+
+      case "template": {
+        const parts = [];
+        for (const part of expr.parts) {
+          // 1. If the part is a simple string, use its raw value
+          if (part.kind === "value" && typeof part.value === "string") {
+            parts.push(part.value);
+          } else {
+            // 2. If the part is an expression, evaluate it and stringify
+            const evaluated = this.evaluate(part, scope);
+            parts.push(this.stringify(evaluated));
+          }
+        }
+        // Return the wrapper
+        return new NovaTemplateString(parts);
+      }
+
+      case "ref":
+        return scope.get(expr.name);
+
+      case "array": {
+        const elements = expr.elements.map((el) => this.evaluate(el, scope));
+        // 🔥 NEW: Use NovaArray wrapper
+        return new NovaArray(elements);
+      }
+
+      case "assign": {
+        const val = this.evaluate(expr.value, scope);
+
+        // 🔥 NEW: Handle dereference assignment: *ptr = val
+        if (expr.name.kind === "deref") {
+          const ptr = this.evaluate(expr.name.operand, scope);
+          if (ptr instanceof NovaPointer) {
+            ptr.write(val);
+            return val;
+          }
+          this.error(
+            "Attempt to assign to a dereferenced non-pointer value",
+            expr,
+          );
+        }
+
+        if (expr.name.kind === "prop") {
+          const obj = this.evaluate(expr.name.object, scope);
+          const propName = expr.name.name;
+
+          // 🔥 NEW: Check for NovaObject/NovaArray and use their set() method
+          if (obj instanceof NovaObject || obj instanceof NovaArray) {
+            obj.set(propName, val);
+          } else {
+            // Existing logic for Scope or raw JS object
+            obj instanceof Scope
+              ? obj.set(propName, val)
+              : (obj[propName] = val);
+          }
+          return val;
+        }
+
+        if (expr.name.kind === "subscript") {
+          const obj = this.evaluate(expr.name.object, scope);
+          const index = this.evaluate(expr.name.index, scope);
+
+          // 🔥 NEW: Check for NovaObject/NovaArray and use their set() method
+          if (obj instanceof NovaObject || obj instanceof NovaArray) {
+            obj.set(index, val);
+          } else {
+            // Existing logic for Scope or raw JS object
+            obj instanceof Scope ? obj.set(index, val) : (obj[index] = val);
+          }
+          return val;
+        }
+        // normal variable assignment
+        return scope.set(expr.name.name, val);
+      }
+
+      case "subscript": {
+        const obj = this.evaluate(expr.object, scope);
+        const index = this.evaluate(expr.index, scope);
+        if (obj == null) this.error("Cannot subscript null or undefined", expr);
+
+        // 🔥 NEW: Check for NovaObject/NovaArray and use their get() method
+        if (obj instanceof NovaObject || obj instanceof NovaArray) {
+          return obj.get(index);
+        }
+
+        // Existing logic for Scope or raw JS object
+        return obj instanceof Scope ? obj.get(index) : obj[index];
+      }
+
+      case "arrowfunc": {
+        // Create a callable JS function bound to lexical scope
+        const fn = (...args) => {
+          const localScope = new Scope("function", scope, this.globalScope);
+          fn.args.forEach((argName, i) => localScope.set(argName, args[i]));
+          let result;
+          try {
+            for (const stmt of expr.body) {
+              result = this.execute(stmt, localScope);
+            }
+          } catch (e) {
+            if (e && "__return" in e) return e.__return;
+            else throw e;
+          }
+          return localScope.get("__return") ?? result;
+        };
+        fn.args = expr.args;
+        fn.body = expr.body;
+        return fn;
+      }
+
+      case "object": {
+        const innerObj = {};
+        for (const [k, v] of Object.entries(expr.props)) {
+          innerObj[k] = this.evaluate(v, scope);
+        }
+        // 🔥 NEW: Use NovaObject wrapper
+        return new NovaObject(innerObj);
+      }
+
+      case "currency": {
+        let value = this.evaluate(expr.operand, scope);
+        let multiplier = scope.get(expr.name) || expr.name;
+        return (!isNaN(multiplier)) ? multiplier * value : multiplier?.(value);
+      }
+
+      case "construct": {
+        let Construct = this.evaluate(expr.left, scope);
+        let Values = [];
+        for (let node of expr.args) {
+	  Values.push(this.evaluate(node, scope));
+        }
+        return Construct.toCallable()(Values);
+      }
+
+      case "binary": {
+        const left = this.evaluate(expr.left, scope);
+        const right = this.evaluate(expr.right, scope);
+        switch (expr.operator) {
+          case "+":
+            return left + right;
+          case "-":
+            return left - right;
+          case "*":
+            return left * right;
+          case "/":
+            return left / right;
+          case "%":
+            return left % right;
+          case "==":
+            return left == right;
+          case "!=":
+            return left != right;
+          case "<":
+            return left < right;
+          case "<=":
+            return left <= right;
+          case ">":
+            return left > right;
+          case ">=":
+            return left >= right;
+          case "&&":
+            return left && right;
+          case "||":
+            return left || right;
+          default:
+            if (expr.operator.custom) return this.evaluate({ type: "call", args: [left, right], name: expr.operator.left });
+            this.error(`Unknown binary operator '${expr.operator}'`, expr);
+        }
+      }
+
+      case "unary": {
+        switch (expr.operator) {
+          case "-":
+            return -this.evaluate(expr.operand, scope);
+          case "!":
+            return !this.evaluate(expr.operand, scope);
+          case "delete": {
+            const operand = expr.operand;
+
+            // ───── Case 1: Variable reference ─────
+            if (operand.kind === "ref") {
+              return scope.delete(operand.name);
+            }
+
+            // ───── Case 2: Object property access (obj.prop) ─────
+            if (operand.kind === "prop") {
+              const obj = this.evaluate(operand.object, scope);
+              const propName = operand.name;
+
+              // 🔥 NEW: Check for NovaObject/NovaArray and use their delete() method
+              if (obj instanceof NovaObject || obj instanceof NovaArray) {
+                obj.delete(propName);
+              } else if (obj instanceof Scope) {
+                obj.delete(propName);
+              } else if (obj && typeof obj === "object") {
+                delete obj[propName];
+              } else {
+                this.error(
+                  `Cannot delete property '${propName}' of non-object`,
+                  expr,
+                );
+              }
+              return true;
+            }
+
+            // ───── Case 3: Subscript (obj[key]) ─────
+            if (operand.kind === "subscript") {
+              const obj = this.evaluate(operand.object, scope);
+              const index = this.evaluate(operand.index, scope);
+
+              // 🔥 NEW: Check for NovaObject/NovaArray and use their delete() method
+              if (obj instanceof NovaObject || obj instanceof NovaArray) {
+                obj.delete(index);
+              } else if (obj instanceof Scope) {
+                obj.delete(index);
+              } else if (obj && typeof obj === "object") {
+                delete obj[index];
+              } else {
+                this.error(
+                  `Cannot delete index '${index}' of non-object`,
+                  expr,
+                );
+              }
+              return true;
+            }
+
+            this.error(`Invalid operand for delete`, expr);
+          }
+          default:
+            this.error(`Unknown unary operator '${expr.operator}'`, expr);
+        }
+      }
+
+      // ────────────── Property access ──────────────
+      case "prop": {
+        const obj = this.evaluate(expr.object, scope);
+        const propName = expr.name;
+
+        // 🔥 NEW: Check for NovaObject/NovaArray and use their get() method
+        if (obj instanceof NovaObject || obj instanceof NovaArray) {
+          return obj.get(propName);
+        }
+
+        // Existing logic for Scope or raw JS object
+        return obj instanceof Scope ? obj.get(propName) : obj[propName];
+      }
+
+      // ────────────── Function / Method call ──────────────
+      case "call": {
+        let fn;
+        let thisBinding = scope;
+
+        if (typeof expr.name === "string") {
+          // normal function
+          fn = scope.get(expr.name);
+        } else if (expr.name.kind === "prop") {
+          // method call like obj.method()
+          const obj = this.evaluate(expr.name.object, scope);
+          thisBinding = obj;
+
+          // if obj is a Scope, use get(); otherwise use JS property
+          if (obj instanceof Scope) fn = obj.get(expr.name.name);
+          else if (
+            obj &&
+            (typeof obj === "object" || typeof obj === "function")
+          )
+            fn = obj[expr.name.name];
+          else
+            this.error(`Cannot call '${expr.name.name}' of non-object`, expr);
+        } else {
+          fn = this.evaluate(expr.name, scope);
+        }
+
+        const args = expr.args.map((a) => this.evaluate(a, scope));
+
+        // Native JS function
+if (typeof fn === "function") {
+  const isClass =
+    fn.prototype &&
+    Object.getOwnPropertyNames(fn.prototype).length > 1;
+
+  if (isClass) {
+    // Class constructor — no binding, just instantiate
+    return new fn(...args);
+  } else {
+    // Normal function — apply with thisBinding
+    return fn.apply(thisBinding, args);
+  }
+}
+
+        // AST function
+        if (fn && fn.args && fn.body) {
+          return this.runFunctionNode(fn, thisBinding, args);
+        }
+
+        if (typeof fn === "number") return fn * args[0];
+
+        this.error(`${fn} is not callable`, expr);
+      }
+
+      case "postfix": {
+        // Evaluate operand reference
+        const operand = expr.operand;
+
+        // Handle variable refs (like i++)
+        if (operand.kind === "ref") {
+          const name = operand.name;
+          const oldVal = scope.get(name);
+          let newVal;
+
+          switch (expr.operator) {
+            case "++":
+              newVal = oldVal + 1;
+              break;
+            case "--":
+              newVal = oldVal - 1;
+              break;
+            default:
+              this.error(`Unknown postfix operator '${expr.operator}'`, expr);
+          }
+
+          // Update the variable in its actual scope
+          // (walk up parent chain until found)
+          let targetScope = scope;
+          while (targetScope && !targetScope.has(name)) {
+            targetScope = targetScope.parent;
+          }
+          if (targetScope) targetScope.set(name, newVal);
+          else scope.set(name, newVal); // define globally if not found
+
+          // Return *old* value, just like JS
+          return oldVal;
+        }
+
+        if (operand.kind === "prop") {
+          const obj = this.evaluate(operand.object, scope);
+          const propName = operand.name;
+
+          // 🔥 NEW: Get the old value using NovaObject/NovaArray get()
+          const oldVal =
+            obj instanceof NovaObject || obj instanceof NovaArray
+              ? obj.get(propName)
+              : obj instanceof Scope
+                ? obj.get(propName)
+                : obj[propName];
+
+          let newVal;
+          switch (expr.operator) {
+            case "++":
+              newVal = oldVal + 1;
+              break;
+            case "--":
+              newVal = oldVal - 1;
+              break;
+            default:
+              this.error(`Unknown postfix operator '${expr.operator}'`, expr);
+          }
+
+          // 🔥 NEW: Set the new value using NovaObject/NovaArray set()
+          if (obj instanceof NovaObject || obj instanceof NovaArray) {
+            obj.set(propName, newVal);
+          } else {
+            let val = newVal;
+            obj instanceof Scope
+              ? obj.set(propName, val)
+              : (obj[propName] = val);
+          }
+          return oldVal;
+        }
+
+        // Handle subscripts like obj[key]++
+        if (operand.kind === "subscript") {
+          const obj = this.evaluate(operand.object, scope);
+          const index = this.evaluate(operand.index, scope);
+
+          // 🔥 NEW: Get the old value using NovaObject/NovaArray get()
+          const oldVal =
+            obj instanceof NovaObject || obj instanceof NovaArray
+              ? obj.get(index)
+              : obj instanceof Scope
+                ? obj.get(index)
+                : obj[index];
+
+          let newVal;
+
+          switch (expr.operator) {
+            case "++":
+              newVal = oldVal + 1;
+              break;
+            case "--":
+              newVal = oldVal - 1;
+              break;
+            default:
+              this.error(`Unknown postfix operator '${expr.operator}'`, expr);
+          }
+
+          // 🔥 NEW: Set the new value using NovaObject/NovaArray set()
+          if (obj instanceof NovaObject || obj instanceof NovaArray) {
+            obj.set(index, newVal);
+          } else {
+            let val = newVal;
+            obj instanceof Scope ? obj.set(index, val) : (obj[index] = val);
+          }
+          return oldVal;
+        }
+
+        this.error("Invalid operand for postfix operator", expr);
+      }
+
+      default:
+        this.error("RuntimeError")(
+          `Unknown expression kind: ${expr.kind}`,
+          expr,
+        );
+    }
+  }
+}
+
+module.exports = { Executor, Scope };