starlight-cli 1.1.11 → 1.1.12

package/src/evaluator.js

@@ -10,10 +10,9 @@ class ReturnValue {
 class BreakSignal {}
 class ContinueSignal {}
 class RuntimeError extends Error {
-    constructor(message, node, source) {
+    constructor(message, node, source, env = null) {
         const line = node?.line ?? '?';
         const column = node?.column ?? '?';
-
         let output = ` ${message} at line ${line}, column ${column}\n`;
 
         if (source && node?.line != null) {
@@ -21,23 +20,55 @@ class RuntimeError extends Error {
             const srcLine = lines[node.line - 1] || '';
             output += `  ${srcLine}\n`;
             const caretPos =
-  typeof column === 'number' && column > 0
-    ? column - 1
-    : 0;
+                typeof column === 'number' && column > 0
+                    ? column - 1
+                    : 0;
+            output += `  ${' '.repeat(caretPos)}^\n`;
+        }
 
-output += `  ${' '.repeat(caretPos)}^\n`;
-;
+        if (env && message.startsWith('Undefined variable:')) {
+            const nameMatch = message.match(/"(.+?)"/);
+            if (nameMatch) {
+                const name = nameMatch[1];
+                const suggestion = RuntimeError.suggest(name, env);
+                if (suggestion) {
+                    output += `Did you mean "${suggestion}"?\n`;
+                }
+            }
         }
 
         super(output);
-
         this.name = 'RuntimeError';
         this.line = line;
         this.column = column;
     }
-}
 
+    static suggest(name, env) {
+        const names = new Set();
+        let current = env;
+        while (current) {
+            for (const key of Object.keys(current.store)) {
+                names.add(key);
+            }
+            current = current.parent;
+        }
+
+        let best = null;
+        let bestScore = Infinity;
+
+        for (const item of names) {
+            const dist = Math.abs(item.length - name.length) +
+                [...name].filter((c, i) => c !== item[i]).length;
 
+            if (dist < bestScore && dist <= 2) {
+                bestScore = dist;
+                best = item;
+            }
+        }
+
+        return best;
+    }
+}
 
 class Environment {
   constructor(parent = null) {
@@ -55,16 +86,7 @@ class Environment {
   if (name in this.store) return this.store[name];
   if (this.parent) return this.parent.get(name, node, source);
 
-  let suggestion = null;
-  if (node && source) {
-    suggestion = this.suggest?.(name, this) || null;
-  }
-
-  const message = suggestion
-    ? `Undefined variable: "${name}". Did you mean "${suggestion}"?`
-    : `Undefined variable: "${name}"`;
-
-  throw new RuntimeError(message, node, source);
+  throw new RuntimeError(`Undefined variable: "${name}"`, node, source, this);
 }
 
 
@@ -116,31 +138,7 @@ async callFunction(fn, args, env, node = null) {
 }
 
 
-suggest(name, env) {
-  const names = new Set();
-  let current = env;
-  while (current) {
-    for (const key of Object.keys(current.store)) {
-      names.add(key);
-    }
-    current = current.parent;
-  }
-
-  let best = null;
-  let bestScore = Infinity;
-
-  for (const item of names) {
-    const dist = Math.abs(item.length - name.length) +
-      [...name].filter((c, i) => c !== item[i]).length;
 
-    if (dist < bestScore && dist <= 2) { 
-      bestScore = dist;
-      best = item;
-    }
-  }
-
-  return best;
-}
 formatValue(value, seen = new Set()) {
   const color = require('starlight-color');
 
@@ -483,10 +481,17 @@ async evalProgram(node, env) {
     try {
       result = await this.evaluate(stmt, env);
     } catch (e) {
+      // Re-throw known runtime control signals
       if (e instanceof RuntimeError || e instanceof BreakSignal || e instanceof ContinueSignal || e instanceof ReturnValue) {
         throw e;
       }
-      throw new RuntimeError(e.message || 'Error in program', stmt, this.source);
+      // Wrap unexpected errors with RuntimeError including env for suggestions
+      throw new RuntimeError(
+        e.message || 'Error in program',
+        stmt,
+        this.source,
+        env
+      );
     }
   }
   return result;
@@ -496,6 +501,7 @@ async evalStartStatement(node, env) {
   try {
     const value = await this.evaluate(node.discriminant, env);
     let executing = false;
+
     for (const c of node.cases) {
       try {
         if (!executing) {
@@ -513,11 +519,11 @@ async evalStartStatement(node, env) {
             caseErr instanceof ContinueSignal) {
           throw caseErr; // propagate signals
         }
-
         throw new RuntimeError(
           caseErr.message || 'Error evaluating case in start statement',
           c,
-          this.source
+          this.source,
+          env
         );
       }
     }
@@ -533,28 +539,31 @@ async evalStartStatement(node, env) {
     throw new RuntimeError(
       err.message || 'Error evaluating start statement',
       node,
-      this.source
+      this.source,
+      env
     );
   }
 }
 
-
 async evalRaceClause(node, env) {
   try {
     const testValue = await this.evaluate(node.test, env);
     const result = await this.evaluate(node.consequent, new Environment(env));
     return { testValue, result };
   } catch (err) {
-    if (err instanceof RuntimeError ||
-        err instanceof ReturnValue ||
-        err instanceof BreakSignal ||
-        err instanceof ContinueSignal) {
+    if (
+      err instanceof RuntimeError ||
+      err instanceof ReturnValue ||
+      err instanceof BreakSignal ||
+      err instanceof ContinueSignal
+    ) {
       throw err; 
     }
     throw new RuntimeError(
       err.message || 'Error evaluating race clause',
       node,
-      this.source
+      this.source,
+      env
     );
   }
 }
@@ -565,7 +574,12 @@ async evalDoTrack(node, env) {
   } catch (err) {
     if (!node.handler) {
       if (err instanceof RuntimeError) throw err;
-      throw new RuntimeError(err.message || 'Error in doTrack body', node.body, this.source);
+      throw new RuntimeError(
+        err.message || 'Error in doTrack body',
+        node.body,
+        this.source,
+        env
+      );
     }
 
     const trackEnv = new Environment(env);
@@ -575,12 +589,16 @@ async evalDoTrack(node, env) {
       return await this.evaluate(node.handler, trackEnv);
     } catch (handlerErr) {
       if (handlerErr instanceof RuntimeError) throw handlerErr;
-      throw new RuntimeError(handlerErr.message || 'Error in doTrack handler', node.handler, this.source);
+      throw new RuntimeError(
+        handlerErr.message || 'Error in doTrack handler',
+        node.handler,
+        this.source,
+        trackEnv
+      );
     }
   }
 }
 
-
 async evalImport(node, env) {
   const spec = node.path;
   let lib;
@@ -596,34 +614,51 @@ async evalImport(node, env) {
       : path.join(process.cwd(), spec.endsWith('.sl') ? spec : spec + '.sl');
 
     if (!fs.existsSync(fullPath)) {
-      throw new RuntimeError(`Import not found: ${spec}`, node, this.source);
+      throw new RuntimeError(
+        `Import not found: ${spec}`,
+        node,
+        this.source,
+        env
+      );
     }
 
-    const code = fs.readFileSync(fullPath, 'utf-8');
-    const tokens = new Lexer(code).getTokens();
-    const ast = new Parser(tokens).parse();
+    try {
+      const code = fs.readFileSync(fullPath, 'utf-8');
+      const tokens = new Lexer(code).getTokens();
+      const ast = new Parser(tokens).parse();
 
-    const moduleEnv = new Environment(env);
-    await this.evaluate(ast, moduleEnv);
+      const moduleEnv = new Environment(env);
+      await this.evaluate(ast, moduleEnv);
 
-    lib = {};
-    for (const key of Object.keys(moduleEnv.store)) {
-      lib[key] = moduleEnv.store[key];
-    }
+      lib = {};
+      for (const key of Object.keys(moduleEnv.store)) {
+        lib[key] = moduleEnv.store[key];
+      }
 
-    lib.default = lib;
+      lib.default = lib;
+    } catch (parseErr) {
+      throw new RuntimeError(
+        parseErr.message || `Failed to import module: ${spec}`,
+        node,
+        this.source,
+        env
+      );
+    }
   }
 
   for (const imp of node.specifiers) {
     if (imp.type === 'DefaultImport') {
       env.define(imp.local, lib.default ?? lib);
-    }
-    if (imp.type === 'NamespaceImport') {
+    } else if (imp.type === 'NamespaceImport') {
       env.define(imp.local, lib);
-    }
-    if (imp.type === 'NamedImport') {
+    } else if (imp.type === 'NamedImport') {
       if (!(imp.imported in lib)) {
-        throw new RuntimeError(`Module '${spec}' has no export '${imp.imported}'`, node, this.source);
+        throw new RuntimeError(
+          `Module '${spec}' has no export '${imp.imported}'`,
+          node,
+          this.source,
+          env
+        );
       }
       env.define(imp.local, lib[imp.imported]);
     }
@@ -631,7 +666,6 @@ async evalImport(node, env) {
 
   return null;
 }
-
 async evalBlock(node, env) {
   let result = null;
   for (const stmt of node.body) {
@@ -650,32 +684,55 @@ async evalBlock(node, env) {
       throw new RuntimeError(
         e.message || 'Error in block',
         stmt,
-        this.source
+        this.source,
+        env // pass env for suggestions
       );
     }
   }
   return result;
 }
 
-
-
 async evalVarDeclaration(node, env) {
   if (!node.expr) {
-    throw new RuntimeError('Variable declaration requires an initializer', node, this.source);
+    throw new RuntimeError(
+      'Variable declaration requires an initializer',
+      node,
+      this.source,
+      env // pass env for suggestions
+    );
   }
 
-  const val = await this.evaluate(node.expr, env);
-  return env.define(node.id, val);
+  try {
+    const val = await this.evaluate(node.expr, env);
+    return env.define(node.id, val);
+  } catch (e) {
+    if (e instanceof RuntimeError) throw e;
+    throw new RuntimeError(
+      e.message || 'Error evaluating variable declaration',
+      node,
+      this.source,
+      env
+    );
+  }
 }
 
-
 evalArrowFunction(node, env) {
   if (!node.body) {
-    throw new RuntimeError('Arrow function missing body', node, this.source);
+    throw new RuntimeError(
+      'Arrow function missing body',
+      node,
+      this.source,
+      env
+    );
   }
 
   if (!Array.isArray(node.params)) {
-    throw new RuntimeError('Invalid arrow function parameters', node, this.source);
+    throw new RuntimeError(
+      'Invalid arrow function parameters',
+      node,
+      this.source,
+      env
+    );
   }
 
   const evaluator = this;
@@ -683,7 +740,6 @@ evalArrowFunction(node, env) {
   return async function (...args) {
     const localEnv = new Environment(env);
 
-    // Bind parameters safely
     node.params.forEach((p, i) => {
       const paramName = typeof p === 'string' ? p : p.name;
       localEnv.define(paramName, args[i]);
@@ -691,77 +747,127 @@ evalArrowFunction(node, env) {
 
     try {
       if (node.isBlock) {
-        // Block body
         const result = await evaluator.evaluate(node.body, localEnv);
-        return result === undefined ? null : result;  // ensure null instead of undefined
+        return result === undefined ? null : result; 
       } else {
-        // Expression body
         const result = await evaluator.evaluate(node.body, localEnv);
-        return result === undefined ? null : result;  // ensure null instead of undefined
+        return result === undefined ? null : result; 
       }
     } catch (err) {
       if (err instanceof ReturnValue) return err.value === undefined ? null : err.value;
-      throw err;
+      if (err instanceof RuntimeError) throw err; // preserve RuntimeErrors
+      throw new RuntimeError(
+        err.message || 'Error evaluating arrow function',
+        node,
+        evaluator.source,
+        localEnv
+      );
     }
   };
 }
 
-
-
 async evalAssignment(node, env) {
   const rightVal = await this.evaluate(node.right, env);
   const left = node.left;
 
-  if (left.type === 'Identifier') return env.set(left.name, rightVal);
+  try {
+    if (left.type === 'Identifier') return env.set(left.name, rightVal);
+
+    if (left.type === 'MemberExpression') {
+      const obj = await this.evaluate(left.object, env);
+      if (obj == null) throw new RuntimeError(
+        'Cannot assign to null or undefined',
+        node,
+        this.source,
+        env
+      );
+      obj[left.property] = rightVal; // dynamic creation allowed
+      return rightVal;
+    }
 
-  if (left.type === 'MemberExpression') {
-    const obj = await this.evaluate(left.object, env);
-    if (obj == null) throw new RuntimeError('Cannot assign to null or undefined', node, this.source);
-    obj[left.property] = rightVal; // dynamic creation of new properties allowed
-    return rightVal;
-  }
+    if (left.type === 'IndexExpression') {
+      const obj = await this.evaluate(left.object, env);
+      const idx = await this.evaluate(left.indexer, env);
+      if (obj == null) throw new RuntimeError(
+        'Cannot assign to null or undefined',
+        node,
+        this.source,
+        env
+      );
+      obj[idx] = rightVal; // dynamic creation allowed
+      return rightVal;
+    }
 
-  if (left.type === 'IndexExpression') {
-    const obj = await this.evaluate(left.object, env);
-    const idx = await this.evaluate(left.indexer, env);
-    if (obj == null) throw new RuntimeError('Cannot assign to null or undefined', node, this.source);
-    obj[idx] = rightVal; // dynamic creation allowed
-    return rightVal;
-  }
+    throw new RuntimeError(
+      'Invalid assignment target',
+      node,
+      this.source,
+      env
+    );
 
-  throw new RuntimeError('Invalid assignment target', node, this.source);
+  } catch (e) {
+    if (e instanceof RuntimeError) throw e;
+    throw new RuntimeError(
+      e.message || 'Error in assignment',
+      node,
+      this.source,
+      env
+    );
+  }
 }
 
 async evalCompoundAssignment(node, env) {
   const left = node.left;
   let current;
 
-  if (left.type === 'Identifier') current = env.get(left.name, left, this.source);
-  else if (left.type === 'MemberExpression') current = await this.evalMember(left, env) ?? 0;
-  else if (left.type === 'IndexExpression') current = await this.evalIndex(left, env) ?? 0;
-  else throw new RuntimeError('Invalid compound assignment target', node, this.source);
-
-  const rhs = await this.evaluate(node.right, env);
-  let computed;
-
-  switch (node.operator) {
-    case 'PLUSEQ': computed = current + rhs; break;
-    case 'MINUSEQ': computed = current - rhs; break;
-    case 'STAREQ': computed = current * rhs; break;
-    case 'SLASHEQ': computed = current / rhs; break;
-    case 'MODEQ': computed = current % rhs; break;
-    default: throw new RuntimeError(`Unknown compound operator: ${node.operator}`, node, this.source);
-  }
+  try {
+    if (left.type === 'Identifier') current = env.get(left.name, left, this.source);
+    else if (left.type === 'MemberExpression') current = await this.evalMember(left, env) ?? 0;
+    else if (left.type === 'IndexExpression') current = await this.evalIndex(left, env) ?? 0;
+    else throw new RuntimeError(
+      'Invalid compound assignment target',
+      node,
+      this.source,
+      env
+    );
 
-  if (left.type === 'Identifier') env.set(left.name, computed);
-  else if (left.type === 'MemberExpression') 
-    await this.evalAssignment({ left, right: { type: 'Literal', value: computed }, type: 'AssignmentExpression' }, env);
-  else 
-    await this.evalAssignment({ left, right: { type: 'Literal', value: computed }, type: 'AssignmentExpression' }, env);
+    const rhs = await this.evaluate(node.right, env);
+    let computed;
+
+    switch (node.operator) {
+      case 'PLUSEQ': computed = current + rhs; break;
+      case 'MINUSEQ': computed = current - rhs; break;
+      case 'STAREQ': computed = current * rhs; break;
+      case 'SLASHEQ': computed = current / rhs; break;
+      case 'MODEQ': computed = current % rhs; break;
+      default: throw new RuntimeError(
+        `Unknown compound operator: ${node.operator}`,
+        node,
+        this.source,
+        env
+      );
+    }
 
-  return computed;
-}
+    if (left.type === 'Identifier') env.set(left.name, computed);
+    else if (left.type === 'MemberExpression' || left.type === 'IndexExpression') {
+      await this.evalAssignment(
+        { left, right: { type: 'Literal', value: computed }, type: 'AssignmentExpression' },
+        env
+      );
+    }
 
+    return computed;
+
+  } catch (e) {
+    if (e instanceof RuntimeError) throw e;
+    throw new RuntimeError(
+      e.message || 'Error in compound assignment',
+      node,
+      this.source,
+      env
+    );
+  }
+}
 
 async evalSldeploy(node, env) {
   const val = await this.evaluate(node.expr, env);
@@ -770,108 +876,162 @@ async evalSldeploy(node, env) {
 }
 
 
-
 async evalAsk(node, env) {
-  const prompt = await this.evaluate(node.prompt, env);
-
-  if (typeof prompt !== 'string') {
-    throw new RuntimeError('ask() prompt must be a string', node, this.source);
-  }
+  try {
+    const prompt = await this.evaluate(node.prompt, env);
 
-  const input = readlineSync.question(prompt + ' ');
-  return input;
-}
+    if (typeof prompt !== 'string') {
+      throw new RuntimeError('ask() prompt must be a string', node, this.source, env);
+    }
 
+    const input = readlineSync.question(prompt + ' ');
+    return input;
 
-async evalDefine(node, env) {
-  if (!node.id || typeof node.id !== 'string') {
-    throw new RuntimeError('Invalid identifier in define statement', node, this.source);
+  } catch (e) {
+    if (e instanceof RuntimeError) throw e;
+    throw new RuntimeError(
+      e.message || 'Error evaluating ask()',
+      node,
+      this.source,
+      env
+    );
   }
-
-  const val = node.expr ? await this.evaluate(node.expr, env) : null;
-  return env.define(node.id, val);
-
 }
 
+async evalDefine(node, env) {
+  try {
+    if (!node.id || typeof node.id !== 'string') {
+      throw new RuntimeError('Invalid identifier in define statement', node, this.source, env);
+    }
 
-async evalBinary(node, env) {
-  const l = await this.evaluate(node.left, env);
-  const r = await this.evaluate(node.right, env);
-
-  if (node.operator === 'SLASH' && r === 0) {
-    throw new RuntimeError('Division by zero', node, this.source);
-  }
-
-  switch (node.operator) {
-    case 'PLUS': {
-  if (Array.isArray(l) && Array.isArray(r)) {
-    return l.concat(r);
-  }
+    const val = node.expr ? await this.evaluate(node.expr, env) : null;
+    return env.define(node.id, val);
 
-  if (typeof l === 'string' || typeof r === 'string') {
-    return String(l) + String(r);
+  } catch (e) {
+    if (e instanceof RuntimeError) throw e;
+    throw new RuntimeError(
+      e.message || 'Error in define statement',
+      node,
+      this.source,
+      env
+    );
   }
+}
 
-  if (typeof l === 'number' && typeof r === 'number') {
-    return l + r;
-  }
+async evalBinary(node, env) {
+  try {
+    const l = await this.evaluate(node.left, env);
+    const r = await this.evaluate(node.right, env);
 
-  if (typeof l === 'object' && typeof r === 'object') {
-    return { ...l, ...r };
-  }
+    if (node.operator === 'SLASH' && r === 0) {
+      throw new RuntimeError('Division by zero', node, this.source, env);
+    }
 
-  throw new RuntimeError(
-    `Unsupported operands for +: ${typeof l} and ${typeof r}`,
-    node,
-    this.source
-  );
-}
+    switch (node.operator) {
+      case 'PLUS': {
+        if (Array.isArray(l) && Array.isArray(r)) return l.concat(r);
+        if (typeof l === 'string' || typeof r === 'string') return String(l) + String(r);
+        if (typeof l === 'number' && typeof r === 'number') return l + r;
+        if (typeof l === 'object' && typeof r === 'object') return { ...l, ...r };
 
-    case 'MINUS': return l - r;
-    case 'STAR': return l * r;
-    case 'SLASH': return l / r;
-    case 'MOD': return l % r;
-    case 'EQEQ': return l === r;
-    case 'NOTEQ': return l !== r;
-    case 'LT': return l < r;
-    case 'LTE': return l <= r;
-    case 'GT': return l > r;
-    case 'GTE': return l >= r;
-    default: throw new RuntimeError(`Unknown binary operator: ${node.operator}`, node, this.source);
+        throw new RuntimeError(
+          `Unsupported operands for +: ${typeof l} and ${typeof r}`,
+          node,
+          this.source,
+          env
+        );
+      }
+      case 'MINUS': return l - r;
+      case 'STAR': return l * r;
+      case 'SLASH': return l / r;
+      case 'MOD': return l % r;
+      case 'EQEQ': return l === r;
+      case 'NOTEQ': return l !== r;
+      case 'LT': return l < r;
+      case 'LTE': return l <= r;
+      case 'GT': return l > r;
+      case 'GTE': return l >= r;
+      default:
+        throw new RuntimeError(
+          `Unknown binary operator: ${node.operator}`,
+          node,
+          this.source,
+          env
+        );
+    }
 
+  } catch (e) {
+    if (e instanceof RuntimeError) throw e;
+    throw new RuntimeError(
+      e.message || 'Error evaluating binary expression',
+      node,
+      this.source,
+      env
+    );
   }
 }
-
 async evalLogical(node, env) {
-  const l = await this.evaluate(node.left, env);
-
-  switch(node.operator) {
-    case 'AND': return l && await this.evaluate(node.right, env);
-    case 'OR': return l || await this.evaluate(node.right, env);
-    case '??': {
-      const r = await this.evaluate(node.right, env);
-      return (l !== null && l !== undefined) ? l : r;
+  try {
+    const l = await this.evaluate(node.left, env);
+
+    switch (node.operator) {
+      case 'AND': return l && await this.evaluate(node.right, env);
+      case 'OR': return l || await this.evaluate(node.right, env);
+      case '??': {
+        const r = await this.evaluate(node.right, env);
+        return (l !== null && l !== undefined) ? l : r;
+      }
+      default:
+        throw new RuntimeError(
+          `Unknown logical operator: ${node.operator}`,
+          node,
+          this.source,
+          env
+        );
     }
-    default:
-      throw new RuntimeError(`Unknown logical operator: ${node.operator}`, node, this.source);
+
+  } catch (e) {
+    if (e instanceof RuntimeError) throw e;
+    throw new RuntimeError(
+      e.message || 'Error evaluating logical expression',
+      node,
+      this.source,
+      env
+    );
   }
 }
 
-
 async evalUnary(node, env) {
-  const val = await this.evaluate(node.argument, env);
-  switch (node.operator) {
-    case 'NOT': return !val;
-    case 'MINUS': return -val;
-    case 'PLUS': return +val;
-    default: throw new RuntimeError(`Unknown unary operator: ${node.operator}`, node, this.source);
+  try {
+    const val = await this.evaluate(node.argument, env);
 
+    switch (node.operator) {
+      case 'NOT': return !val;
+      case 'MINUS': return -val;
+      case 'PLUS': return +val;
+      default:
+        throw new RuntimeError(
+          `Unknown unary operator: ${node.operator}`,
+          node,
+          this.source,
+          env
+        );
+    }
+
+  } catch (e) {
+    if (e instanceof RuntimeError) throw e;
+    throw new RuntimeError(
+      e.message || 'Error evaluating unary expression',
+      node,
+      this.source,
+      env
+    );
   }
 }
+
 async evalIf(node, env) {
   let test = await this.evaluate(node.test, env);
-
-  test = !!test;
+  test = !!test; // coerce to boolean
 
   if (test) {
     return await this.evaluate(node.consequent, env);
@@ -885,183 +1045,270 @@ async evalIf(node, env) {
 }
 
 async evalWhile(node, env) {
-  while (true) {
-    let test = await this.evaluate(node.test, env);
-
-    test = !!test;
+  try {
+    while (true) {
+      let test = await this.evaluate(node.test, env);
+      test = !!test;
 
-    if (!test) break;
+      if (!test) break;
 
-    try {
-      await this.evaluate(node.body, env);
-    } catch (e) {
-      if (e instanceof BreakSignal) break;     
-      if (e instanceof ContinueSignal) continue; 
-      throw e;                                
+      try {
+        await this.evaluate(node.body, env);
+      } catch (e) {
+        if (e instanceof BreakSignal) break;
+        if (e instanceof ContinueSignal) continue;
+        throw e;
+      }
     }
-  }
 
-  return null;
-}
+    return null;
 
+  } catch (e) {
+    if (e instanceof RuntimeError || e instanceof BreakSignal || e instanceof ContinueSignal) throw e;
+    throw new RuntimeError(
+      e.message || 'Error evaluating while loop',
+      node,
+      this.source,
+      env
+    );
+  }
+}
 async evalFor(node, env) {
-  if (node.type === 'ForInStatement') {
-    const iterable = await this.evaluate(node.iterable, env);
+  try {
+    // ForInStatement
+    if (node.type === 'ForInStatement') {
+      const iterable = await this.evaluate(node.iterable, env);
 
-    if (iterable == null || typeof iterable !== 'object') {
-      throw new RuntimeError('Cannot iterate over non-iterable', node, this.source);
-    }
+      if (iterable == null || typeof iterable !== 'object') {
+        throw new RuntimeError(
+          'Cannot iterate over non-iterable',
+          node,
+          this.source,
+          env
+        );
+      }
 
-    const loopVar = node.variable; // string name of the loop variable
-    const createLoopEnv = () => node.letKeyword ? new Environment(env) : env;
-    if (Array.isArray(iterable)) {
-      for (const value of iterable) {
-        const loopEnv = createLoopEnv();
-        loopEnv.define(loopVar, value);
-
-        try {
-          await this.evaluate(node.body, loopEnv);
-        } catch (e) {
-          if (e instanceof BreakSignal) break;
-          if (e instanceof ContinueSignal) continue;
-          throw e;
+      const loopVar = node.variable; // string name of the loop variable
+      const createLoopEnv = () => node.letKeyword ? new Environment(env) : env;
+
+      if (Array.isArray(iterable)) {
+        for (const value of iterable) {
+          const loopEnv = createLoopEnv();
+          loopEnv.define(loopVar, value);
+
+          try {
+            await this.evaluate(node.body, loopEnv);
+          } catch (e) {
+            if (e instanceof BreakSignal) break;
+            if (e instanceof ContinueSignal) continue;
+            throw e;
+          }
         }
-      }
-    }
-    else {
-      for (const key of Object.keys(iterable)) {
-        const loopEnv = createLoopEnv();
-        loopEnv.define(loopVar, key);
-
-        try {
-          await this.evaluate(node.body, loopEnv);
-        } catch (e) {
-          if (e instanceof BreakSignal) break;
-          if (e instanceof ContinueSignal) continue;
-          throw e;
+      } else {
+        for (const key of Object.keys(iterable)) {
+          const loopEnv = createLoopEnv();
+          loopEnv.define(loopVar, key);
+
+          try {
+            await this.evaluate(node.body, loopEnv);
+          } catch (e) {
+            if (e instanceof BreakSignal) break;
+            if (e instanceof ContinueSignal) continue;
+            throw e;
+          }
         }
       }
-    }
 
-    return null;
-  }
+      return null;
+    }
 
-  const local = new Environment(env);
+    // Standard for loop
+    const local = new Environment(env);
 
-  if (node.init) await this.evaluate(node.init, local);
+    if (node.init) await this.evaluate(node.init, local);
 
-  while (!node.test || await this.evaluate(node.test, local)) {
-    try {
-      await this.evaluate(node.body, local);
-    } catch (e) {
-      if (e instanceof BreakSignal) break;
-      if (e instanceof ContinueSignal) {
-        if (node.update) await this.evaluate(node.update, local);
-        continue;
+    while (!node.test || await this.evaluate(node.test, local)) {
+      try {
+        await this.evaluate(node.body, local);
+      } catch (e) {
+        if (e instanceof BreakSignal) break;
+        if (e instanceof ContinueSignal) {
+          if (node.update) await this.evaluate(node.update, local);
+          continue;
+        }
+        throw e;
       }
-      throw e;
+
+      if (node.update) await this.evaluate(node.update, local);
     }
 
-    if (node.update) await this.evaluate(node.update, local);
-  }
+    return null;
 
-  return null;
+  } catch (err) {
+    if (err instanceof RuntimeError || err instanceof BreakSignal || err instanceof ContinueSignal) throw err;
+    throw new RuntimeError(
+      err.message || 'Error evaluating for loop',
+      node,
+      this.source,
+      env
+    );
+  }
 }
 
 evalFunctionDeclaration(node, env) {
-  if (!node.name || typeof node.name !== 'string') {
-    throw new RuntimeError('Function declaration requires a valid name', node, this.source);
-  }
+  try {
+    if (!node.name || typeof node.name !== 'string') {
+      throw new RuntimeError('Function declaration requires a valid name', node, this.source, env);
+    }
 
-  if (!Array.isArray(node.params)) {
-    throw new RuntimeError(`Invalid parameter list in function '${node.name}'`, node, this.source);
-  }
+    if (!Array.isArray(node.params)) {
+      throw new RuntimeError(`Invalid parameter list in function '${node.name}'`, node, this.source, env);
+    }
 
-  if (!node.body) {
-    throw new RuntimeError(`Function '${node.name}' has no body`, node, this.source);
-  }
+    if (!node.body) {
+      throw new RuntimeError(`Function '${node.name}' has no body`, node, this.source, env);
+    }
 
-  const fn = {
-    params: node.params,
-    body: node.body,
-    env,
-    async: node.async || false
-  };
+    const fn = {
+      params: node.params,
+      body: node.body,
+      env,
+      async: node.async || false
+    };
 
-  env.define(node.name, fn);
-  return null;
-}
+    env.define(node.name, fn);
+    return null;
 
-async evalCall(node, env) {
-  const calleeEvaluated = await this.evaluate(node.callee, env);
-  if (typeof calleeEvaluated === 'function') {
-    const args = [];
-    for (const a of node.arguments) args.push(await this.evaluate(a, env));
-    return await calleeEvaluated(...args);
-  }
-  if (!calleeEvaluated || typeof calleeEvaluated !== 'object' || !calleeEvaluated.body) {
-    throw new RuntimeError('Call to non-function', node, this.source);
+  } catch (err) {
+    if (err instanceof RuntimeError) throw err;
+    throw new RuntimeError(
+      err.message || 'Error defining function',
+      node,
+      this.source,
+      env
+    );
   }
+}
+async evalCall(node, env) {
+  try {
+    const calleeEvaluated = await this.evaluate(node.callee, env);
 
-  const fn = calleeEvaluated;
-  const callEnv = new Environment(fn.env);
+    // Native JS function
+    if (typeof calleeEvaluated === 'function') {
+      const args = [];
+      for (const a of node.arguments) args.push(await this.evaluate(a, env));
+      return await calleeEvaluated(...args);
+    }
+
+    // Not a callable object
+    if (!calleeEvaluated || typeof calleeEvaluated !== 'object' || !calleeEvaluated.body) {
+      throw new RuntimeError(
+        'Call to non-function',
+        node,
+        this.source,
+        env
+      );
+    }
 
-  for (let i = 0; i < fn.params.length; i++) {
-  const argVal = node.arguments[i]
-    ? await this.evaluate(node.arguments[i], env)
-    : null;
+    const fn = calleeEvaluated;
+    const callEnv = new Environment(fn.env);
 
-  const param = fn.params[i];
-  const paramName = typeof param === 'string' ? param : param.name;
+    for (let i = 0; i < fn.params.length; i++) {
+      const argVal = node.arguments[i]
+        ? await this.evaluate(node.arguments[i], env)
+        : null;
 
-  callEnv.define(paramName, argVal);
-}
+      const param = fn.params[i];
+      const paramName = typeof param === 'string' ? param : param.name;
+      callEnv.define(paramName, argVal);
+    }
 
-  try {
-    const result = await this.evaluate(fn.body, callEnv);
-    return result;
-  } catch (e) {
-    if (e instanceof ReturnValue) return e.value;
-    throw e;
+    try {
+      const result = await this.evaluate(fn.body, callEnv);
+      return result === undefined ? null : result; // enforce null instead of undefined
+    } catch (e) {
+      if (e instanceof ReturnValue) return e.value === undefined ? null : e.value;
+      throw e;
+    }
+
+  } catch (err) {
+    if (err instanceof RuntimeError) throw err;
+    throw new RuntimeError(
+      err.message || 'Error during function call',
+      node,
+      this.source,
+      env
+    );
   }
 }
 
 async evalIndex(node, env) {
-  const obj = await this.evaluate(node.object, env);
-  const idx = await this.evaluate(node.indexer, env);
-
-  if (obj == null) throw new RuntimeError('Cannot index null or undefined', node, this.source);
-  if (Array.isArray(obj)) {
-    if (idx < 0 || idx >= obj.length) return undefined;
-    return obj[idx];
-  }
-  if (typeof obj === 'object') {
-    return obj[idx]; // undefined if missing
-  }
+  try {
+    const obj = await this.evaluate(node.object, env);
+    const idx = await this.evaluate(node.indexer, env);
 
-  return undefined;
-}
-async evalObject(node, env) {
-  const out = {};
-  for (const p of node.props) {
-    if (!p.key) {
-      throw new RuntimeError('Object property must have a key', node, this.source);
+    if (obj == null) {
+      throw new RuntimeError(
+        'Cannot index null or undefined',
+        node,
+        this.source,
+        env
+      );
     }
 
-    const key = await this.evaluate(p.key, env);
-    let value = null;
-
-    if (p.value) {
-      value = await this.evaluate(p.value, env);
-      if (value === undefined) value = null; // <- force null instead of undefined
+    if (Array.isArray(obj)) {
+      if (idx < 0 || idx >= obj.length) return undefined;
+      return obj[idx];
     }
 
-    out[key] = value;
+    if (typeof obj === 'object') return obj[idx]; // undefined if missing
+
+    return undefined;
+  } catch (err) {
+    if (err instanceof RuntimeError) throw err;
+    throw new RuntimeError(
+      err.message || 'Error during index access',
+      node,
+      this.source,
+      env
+    );
   }
-  return out;
 }
 
+async evalObject(node, env) {
+  try {
+    const out = {};
+    for (const p of node.props) {
+      if (!p.key) {
+        throw new RuntimeError(
+          'Object property must have a key',
+          node,
+          this.source,
+          env
+        );
+      }
 
+      const key = await this.evaluate(p.key, env);
+      let value = null;
+
+      if (p.value) {
+        value = await this.evaluate(p.value, env);
+        if (value === undefined) value = null; // force null instead of undefined
+      }
+
+      out[key] = value;
+    }
+    return out;
+  } catch (err) {
+    if (err instanceof RuntimeError) throw err;
+    throw new RuntimeError(
+      err.message || 'Error evaluating object literal',
+      node,
+      this.source,
+      env
+    );
+  }
+}
 
 
 async evalMember(node, env) {
@@ -1080,33 +1327,61 @@ async evalMember(node, env) {
   return prop;
 }
 
-
 async evalUpdate(node, env) {
   const arg = node.argument;
-  const getCurrent = async () => {
-    if (arg.type === 'Identifier') return env.get(arg.name, arg, this.source);
-    if (arg.type === 'MemberExpression') return await this.evalMember(arg, env);
-    if (arg.type === 'IndexExpression') return await this.evalIndex(arg, env);
-    throw new RuntimeError('Invalid update target', node, this.source);
 
+  const getCurrent = async () => {
+    try {
+      if (arg.type === 'Identifier') return env.get(arg.name, arg, this.source);
+      if (arg.type === 'MemberExpression') return await this.evalMember(arg, env);
+      if (arg.type === 'IndexExpression') return await this.evalIndex(arg, env);
+      throw new RuntimeError('Invalid update target', node, this.source, env);
+    } catch (err) {
+      if (err instanceof RuntimeError) throw err;
+      throw new RuntimeError(
+        err.message || 'Error accessing update target',
+        node,
+        this.source,
+        env
+      );
+    }
   };
+
   const setValue = async (v) => {
-    if (arg.type === 'Identifier') env.set(arg.name, v);
-    else if (arg.type === 'MemberExpression') {
-      const obj = await this.evaluate(arg.object, env);
-      obj[arg.property] = v;
-    } else if (arg.type === 'IndexExpression') {
-      const obj = await this.evaluate(arg.object, env);
-      const idx = await this.evaluate(arg.indexer, env);
-      obj[idx] = v;
+    try {
+      if (arg.type === 'Identifier') {
+        env.set(arg.name, v);
+      } else if (arg.type === 'MemberExpression') {
+        const obj = await this.evaluate(arg.object, env);
+        if (obj == null) throw new RuntimeError('Cannot update property of null or undefined', node, this.source, env);
+        obj[arg.property] = v;
+      } else if (arg.type === 'IndexExpression') {
+        const obj = await this.evaluate(arg.object, env);
+        const idx = await this.evaluate(arg.indexer, env);
+        if (obj == null) throw new RuntimeError('Cannot update index of null or undefined', node, this.source, env);
+        obj[idx] = v;
+      }
+    } catch (err) {
+      if (err instanceof RuntimeError) throw err;
+      throw new RuntimeError(
+        err.message || 'Error setting update target',
+        node,
+        this.source,
+        env
+      );
     }
   };
 
   const current = await getCurrent();
-  const newVal = (node.operator === 'PLUSPLUS') ? current + 1 : current - 1;
+  const newVal = node.operator === 'PLUSPLUS' ? current + 1 : current - 1;
 
-  if (node.prefix) { await setValue(newVal); return newVal; }
-  else { await setValue(newVal); return current; }
+  if (node.prefix) {
+    await setValue(newVal);
+    return newVal;
+  } else {
+    await setValue(newVal);
+    return current;
+  }
 }
 
 }