starlight-cli 1.0.46 → 1.0.48

package/dist/index.js

@@ -1352,6 +1352,29 @@ class ReturnValue {
 }
 class BreakSignal {}
 class ContinueSignal {}
+class RuntimeError extends Error {
+    constructor(message, node, source) {
+        const line = node?.line ?? '?';
+        const column = node?.column ?? '?';
+
+        let output = ` ${message} at line ${line}, column ${column}\n`;
+
+        if (source && node?.line != null) {
+            const lines = source.split('\n');
+            const srcLine = lines[node.line - 1] || '';
+            output += `  ${srcLine}\n`;
+            output += `  ${' '.repeat(column - 1)}^\n`;
+        }
+
+        super(output);
+
+        this.name = 'RuntimeError';
+        this.line = line;
+        this.column = column;
+    }
+}
+
+
 
 class Environment {
   constructor(parent = null) {
@@ -1365,11 +1388,11 @@ class Environment {
     return false;
   }
 
-  get(name) {
-    if (name in this.store) return this.store[name];
-    if (this.parent) return this.parent.get(name);
-    throw new Error(`Undefined variable: ${name}`);
-  }
+  get(name, node) {
+  if (name in this.store) return this.store[name];
+  if (this.parent) return this.parent.get(name, node);
+  throw new RuntimeError(`Undefined variable: ${name}`, node);
+}
 
   set(name, value) {
     if (name in this.store) { this.store[name] = value; return value; }
@@ -1385,7 +1408,8 @@ class Environment {
 }
 
 class Evaluator {
-  constructor() {
+  constructor(source = '') {
+    this.source = source;
     this.global = new Environment();
     this.setupBuiltins();
   }
@@ -1472,11 +1496,11 @@ this.global.define('range', (...args) => {
     end = Number(args[1]);
     step = Number(args[2]);
   } else {
-    throw new Error('range() expects 1 to 3 arguments');
+    throw new RuntimeError('range() expects 1 to 3 arguments', null, this.source);
   }
 
   if (step === 0) {
-    throw new Error('range() step cannot be 0');
+    throw new RuntimeError('range() step cannot be 0', null, this.source);
   }
 
   const result = [];
@@ -1500,7 +1524,7 @@ this.global.define('range', (...args) => {
     this.global.define('num', arg => {
     const n = Number(arg);
     if (Number.isNaN(n)) {
-        throw new Error('Cannot convert value to number');
+        throw new RuntimeError('Cannot convert value to number', null, this.source);
     }
     return n;
 });
@@ -1553,7 +1577,7 @@ async evaluate(node, env = this.global) {
     case 'LogicalExpression': return await this.evalLogical(node, env);
     case 'UnaryExpression': return await this.evalUnary(node, env);
     case 'Literal': return node.value;
-    case 'Identifier': return env.get(node.name);
+    case 'Identifier': return env.get(node.name, node);
     case 'IfStatement': return await this.evalIf(node, env);
     case 'WhileStatement': return await this.evalWhile(node, env);
     case 'ForStatement':
@@ -1576,14 +1600,8 @@ case 'DoTrackStatement':
     case 'ArrayExpression':
       return await Promise.all(node.elements.map(el => this.evaluate(el, env)));
     case 'IndexExpression': return await this.evalIndex(node, env);
-    case 'ObjectExpression': {
-  const out = {};
-  for (const p of node.props) {
-    const key = await this.evaluate(p.key, env);
-    out[key] = await this.evaluate(p.value, env);
-  }
-  return out;
-}
+    case 'ObjectExpression': return await this.evalObject(node, env);
+
 
     case 'MemberExpression': return await this.evalMember(node, env);
     case 'UpdateExpression': return await this.evalUpdate(node, env);
@@ -1611,7 +1629,7 @@ case 'DoTrackStatement':
   }
 
   if (typeof callee !== 'function') {
-    throw new Error('NewExpression callee is not a function');
+    throw new RuntimeError('NewExpression callee is not a function', node, this.source);
   }
 
   const args = [];
@@ -1620,31 +1638,51 @@ case 'DoTrackStatement':
 }
 
     default:
-      throw new Error(`Unknown node type in evaluator: ${node.type}`);
+       throw new RuntimeError(`Unknown node type in evaluator: ${node.type}`, node, this.source);
+
   }
 }
 
 async evalProgram(node, env) {
   let result = null;
   for (const stmt of node.body) {
-    result = await this.evaluate(stmt, env);
+    try {
+      result = await this.evaluate(stmt, env);
+    } catch (e) {
+      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);
+    }
   }
   return result;
 }
 
+
 async evalDoTrack(node, env) {
   try {
     return await this.evaluate(node.body, env);
   } catch (err) {
-    if (!node.handler) throw err;
+    if (!node.handler) {
+      // Wrap any raw error into RuntimeError with line info
+      if (err instanceof RuntimeError) throw err;
+      throw new RuntimeError(err.message || 'Error in doTrack body', node.body, this.source);
+    }
 
     const trackEnv = new Environment(env);
     trackEnv.define('error', err);
 
-    return await this.evaluate(node.handler, trackEnv);
+    try {
+      return await this.evaluate(node.handler, trackEnv);
+    } catch (handlerErr) {
+      // Wrap handler errors as well
+      if (handlerErr instanceof RuntimeError) throw handlerErr;
+      throw new RuntimeError(handlerErr.message || 'Error in doTrack handler', node.handler, this.source);
+    }
   }
 }
 
+
 async evalImport(node, env) {
   const spec = node.path;
   let lib;
@@ -1660,7 +1698,7 @@ async evalImport(node, env) {
       : path.join(process.cwd(), spec.endsWith('.sl') ? spec : spec + '.sl');
 
     if (!fs.existsSync(fullPath)) {
-      throw new Error(`Import not found: ${spec}`);
+      throw new RuntimeError(`Import not found: ${spec}`, node, this.source);
     }
 
     const code = fs.readFileSync(fullPath, 'utf-8');
@@ -1687,7 +1725,7 @@ async evalImport(node, env) {
     }
     if (imp.type === 'NamedImport') {
       if (!(imp.imported in lib)) {
-        throw new Error(`Module '${spec}' has no export '${imp.imported}'`);
+        throw new RuntimeError(`Module '${spec}' has no export '${imp.imported}'`, node, this.source);
       }
       env.define(imp.local, lib[imp.imported]);
     }
@@ -1703,18 +1741,32 @@ async evalBlock(node, env) {
       result = await this.evaluate(stmt, env);
     } catch (e) {
       if (e instanceof ReturnValue || e instanceof BreakSignal || e instanceof ContinueSignal) throw e;
-      throw e;
+      // Wrap any other error in RuntimeError with the current block node
+      throw new RuntimeError(e.message || 'Error in block', stmt, this.source);
     }
   }
   return result;
 }
 
+
 async evalVarDeclaration(node, env) {
+  if (!node.expr) {
+    throw new RuntimeError('Variable declaration requires an initializer', node, this.source);
+  }
+
   const val = await this.evaluate(node.expr, env);
   return env.define(node.id, val);
 }
 
+
 evalArrowFunction(node, env) {
+  if (!node.body) {
+    throw new RuntimeError('Arrow function missing body', node, this.source);
+  }
+  if (!Array.isArray(node.params)) {
+    throw new RuntimeError('Invalid arrow function parameters', node, this.source);
+  }
+
   return {
     params: node.params,
     body: node.body,
@@ -1724,24 +1776,29 @@ evalArrowFunction(node, env) {
   };
 }
 
+
 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);
   if (left.type === 'MemberExpression') {
-    const obj = await this.evaluate(left.object, env);
-    obj[left.property] = rightVal;
-    return rightVal;
-  }
-  if (left.type === 'IndexExpression') {
-    const obj = await this.evaluate(left.object, env);
-    const idx = await this.evaluate(left.indexer, env);
-    obj[idx] = rightVal;
-    return rightVal;
-  }
+  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;
+  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;
+  return rightVal;
+}
+
+
+ throw new RuntimeError('Invalid assignment target', node, this.source);
 
-  throw new Error('Invalid assignment target');
 }
 
 async evalCompoundAssignment(node, env) {
@@ -1751,7 +1808,8 @@ async evalCompoundAssignment(node, env) {
   if (left.type === 'Identifier') current = env.get(left.name);
   else if (left.type === 'MemberExpression') current = await this.evalMember(left, env);
   else if (left.type === 'IndexExpression') current = await this.evalIndex(left, env);
-  else throw new Error('Invalid compound assignment target');
+  else throw new RuntimeError('Invalid compound assignment target', node, this.source);
+
 
   const rhs = await this.evaluate(node.right, env);
   let computed;
@@ -1761,7 +1819,8 @@ async evalCompoundAssignment(node, env) {
     case 'STAREQ': computed = current * rhs; break;
     case 'SLASHEQ': computed = current / rhs; break;
     case 'MODEQ': computed = current % rhs; break;
-    default: throw new Error('Unknown compound operator');
+    default: throw new RuntimeError(`Unknown compound operator: ${node.operator}`, node, this.source);
+
   }
 
   if (left.type === 'Identifier') env.set(left.name, computed);
@@ -1780,21 +1839,33 @@ 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);
+  }
+
   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);
+  }
+
   const val = node.expr ? await this.evaluate(node.expr, env) : null;
-  return this.global.define(node.id, val);
+  return env.define(node.id, val);
+
 }
 
+
 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 Error('Division by zero');
+    throw new RuntimeError('Division by zero', node, this.source);
   }
 
   switch (node.operator) {
@@ -1809,7 +1880,8 @@ async evalBinary(node, env) {
     case 'LTE': return l <= r;
     case 'GT': return l > r;
     case 'GTE': return l >= r;
-    default: throw new Error(`Unknown binary operator ${node.operator}`);
+    default: throw new RuntimeError(`Unknown binary operator: ${node.operator}`, node, this.source);
+
   }
 }
 
@@ -1817,7 +1889,8 @@ async evalLogical(node, env) {
   const l = await this.evaluate(node.left, env);
   if (node.operator === 'AND') return l && await this.evaluate(node.right, env);
   if (node.operator === 'OR') return l || await this.evaluate(node.right, env);
-  throw new Error(`Unknown logical operator ${node.operator}`);
+  throw new RuntimeError(`Unknown logical operator: ${node.operator}`, node, this.source);
+
 }
 
 async evalUnary(node, env) {
@@ -1826,21 +1899,43 @@ async evalUnary(node, env) {
     case 'NOT': return !val;
     case 'MINUS': return -val;
     case 'PLUS': return +val;
-    default: throw new Error(`Unknown unary operator ${node.operator}`);
+    default: throw new RuntimeError(`Unknown unary operator: ${node.operator}`, node, this.source);
+
   }
 }
 
 async evalIf(node, env) {
   const test = await this.evaluate(node.test, env);
-  if (test) return await this.evaluate(node.consequent, env);
-  if (node.alternate) return await this.evaluate(node.alternate, env);
+
+  if (typeof test !== 'boolean') {
+    throw new RuntimeError('If condition must evaluate to a boolean', node.test, this.source);
+  }
+
+  if (test) {
+    return await this.evaluate(node.consequent, env);
+  }
+
+  if (node.alternate) {
+    return await this.evaluate(node.alternate, env);
+  }
+
   return null;
 }
 
+
 async evalWhile(node, env) {
-  while (await this.evaluate(node.test, env)) {
-    try { await this.evaluate(node.body, env); }
-    catch (e) {
+  while (true) {
+    const test = await this.evaluate(node.test, env);
+
+    if (typeof test !== 'boolean') {
+      throw new RuntimeError('While condition must evaluate to a boolean', node.test, this.source);
+    }
+
+    if (!test) break;
+
+    try {
+      await this.evaluate(node.body, env);
+    } catch (e) {
       if (e instanceof BreakSignal) break;
       if (e instanceof ContinueSignal) continue;
       throw e;
@@ -1848,6 +1943,7 @@ async evalWhile(node, env) {
   }
   return null;
 }
+
 async evalFor(node, env) {
   // -------------------------------
   // Python-style: for x in iterable (with optional 'let')
@@ -1856,7 +1952,7 @@ async evalFor(node, env) {
     const iterable = await this.evaluate(node.iterable, env);
 
     if (iterable == null || typeof iterable !== 'object') {
-      throw new Error('Cannot iterate over non-iterable');
+      throw new RuntimeError('Cannot iterate over non-iterable', node, this.source);
     }
 
     const loopVar = node.variable; // STRING from parser
@@ -1921,9 +2017,26 @@ async evalFor(node, env) {
 
   return null;
 }
-
 evalFunctionDeclaration(node, env) {
-  const fn = { params: node.params, body: node.body, env, async: node.async || false };
+  if (!node.name || typeof node.name !== 'string') {
+    throw new RuntimeError('Function declaration requires a valid name', node, this.source);
+  }
+
+  if (!Array.isArray(node.params)) {
+    throw new RuntimeError(`Invalid parameter list in function '${node.name}'`, node, this.source);
+  }
+
+  if (!node.body) {
+    throw new RuntimeError(`Function '${node.name}' has no body`, node, this.source);
+  }
+
+  const fn = {
+    params: node.params,
+    body: node.body,
+    env,
+    async: node.async || false
+  };
+
   env.define(node.name, fn);
   return null;
 }
@@ -1933,10 +2046,10 @@ async evalCall(node, env) {
   if (typeof calleeEvaluated === 'function') {
     const args = [];
     for (const a of node.arguments) args.push(await this.evaluate(a, env));
-    return calleeEvaluated(...args);
+    return await calleeEvaluated(...args);
   }
   if (!calleeEvaluated || typeof calleeEvaluated !== 'object' || !calleeEvaluated.body) {
-    throw new Error('Call to non-function');
+    throw new RuntimeError('Call to non-function', node, this.source);
   }
 
   const fn = calleeEvaluated;
@@ -1949,7 +2062,7 @@ async evalCall(node, env) {
 
   try {
     const result = await this.evaluate(fn.body, callEnv);
-    return fn.arrow ? result : result;
+    return result;
   } catch (e) {
     if (e instanceof ReturnValue) return e.value;
     throw e;
@@ -1960,12 +2073,13 @@ 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 Error('Indexing null or undefined');
+  if (obj == null) throw new RuntimeError('Indexing null or undefined', node, this.source);
+
   if (Array.isArray(obj) && (idx < 0 || idx >= obj.length)) {
-    throw new Error('Array index out of bounds');
+    throw new RuntimeError('Array index out of bounds', node, this.source);
   }
   if (typeof obj === 'object' && !(idx in obj)) {
-    throw new Error(`Property '${idx}' does not exist`);
+    throw new RuntimeError(`Property '${idx}' does not exist`, node, this.source);
   }
 
   return obj[idx];
@@ -1973,14 +2087,22 @@ async evalIndex(node, env) {
 
 async evalObject(node, env) {
   const out = {};
-  for (const p of node.props) out[p.key] = await this.evaluate(p.value, env);
+  for (const p of node.props) {
+    if (!p.key || !p.value) {
+      throw new RuntimeError('Invalid object property', node, this.source);
+    }
+    const key = await this.evaluate(p.key, env);
+    const value = await this.evaluate(p.value, env);
+    out[key] = value;
+  }
   return out;
 }
 
+
 async evalMember(node, env) {
   const obj = await this.evaluate(node.object, env);
-  if (obj == null) throw new Error('Member access of null or undefined');
-  if (!(node.property in obj)) throw new Error(`Property '${node.property}' does not exist`);
+ if (obj == null) throw new RuntimeError('Member access of null or undefined', node, this.source);
+if (!(node.property in obj)) throw new RuntimeError(`Property '${node.property}' does not exist`, node, this.source);
   return obj[node.property];
 }
 
@@ -1990,7 +2112,8 @@ async evalUpdate(node, env) {
     if (arg.type === 'Identifier') return env.get(arg.name);
     if (arg.type === 'MemberExpression') return await this.evalMember(arg, env);
     if (arg.type === 'IndexExpression') return await this.evalIndex(arg, env);
-    throw new Error('Invalid update target');
+    throw new RuntimeError('Invalid update target', node, this.source);
+
   };
   const setValue = async (v) => {
     if (arg.type === 'Identifier') env.set(arg.name, v);
@@ -2020,14 +2143,33 @@ module.exports = Evaluator;
 /***/ 211:
 /***/ ((module) => {
 
+class LexerError extends Error {
+  constructor(message, line, column, source = '') {
+    let output = `SyntaxError: ${message}\n`;
+    output += `  at line ${line}, column ${column}\n`;
+
+    if (source && line != null) {
+      const lines = source.split('\n');
+      const srcLine = lines[line - 1] || '';
+      output += `    ${srcLine}\n`;
+      output += `    ${' '.repeat(column - 1)}^\n`;
+    }
+
+    super(output);
+    this.name = 'SyntaxError';
+  }
+}
+
 class Lexer {
   constructor(input) {
-    this.input = input;
-    this.pos = 0;
-    this.currentChar = input[0] || null;
-    this.line = 1;     // current line
-    this.column = 1;   // current column
-  }
+  this.input = input;
+  this.source = input;
+  this.pos = 0;
+  this.currentChar = input[0] || null;
+  this.line = 1;
+  this.column = 1;
+}
+
 
   advance() {
     if (this.currentChar === '\n') {
@@ -2045,8 +2187,14 @@ class Lexer {
   }
 
   error(msg) {
-    throw new Error(`${msg} at line ${this.line}, column ${this.column}`);
-  }
+  throw new LexerError(
+    msg,
+    this.line,
+    this.column,
+    this.source
+  );
+}
+
 
   skipWhitespace() {
     while (this.currentChar && /\s/.test(this.currentChar)) this.advance();
@@ -2214,25 +2362,54 @@ module.exports = Lexer;
 /***/ 222:
 /***/ ((module) => {
 
-class Parser {
-  constructor(tokens) {
-    this.tokens = tokens;
-    this.pos = 0;
-    this.current = this.tokens[this.pos];
+class ParseError extends Error {
+  constructor(message, token, source) {
+    const line = token?.line ?? '?';
+    const column = token?.column ?? '?';
+
+    let output = `SyntaxError: ${message}\n`;
+
+    if (source && token?.line != null) {
+      const lines = source.split('\n');
+      const srcLine = lines[token.line - 1] || '';
+      output += `  at line ${line}, column ${column}\n`;
+      output += `    ${srcLine}\n`;
+      output += `    ${' '.repeat(column - 1)}^\n`;
+    } else {
+      output += `  at line ${line}, column ${column}\n`;
+    }
+
+    super(output);
+    this.name = 'SyntaxError';
   }
+}
+
+class Parser {
+  constructor(tokens, source = '') {
+  this.tokens = tokens;
+  this.source = source;
+  this.pos = 0;
+  this.current = this.tokens[this.pos];
+}
+
 
   advance() {
     this.pos++;
     this.current = this.pos < this.tokens.length ? this.tokens[this.pos] : { type: 'EOF' };
   }
 
-  eat(type) {
-    if (this.current.type === type) this.advance();
-    else throw new Error(
-  `Expected ${type}, got ${this.current.type} at line ${this.current.line}, column ${this.current.column}`
-);
-
+ eat(type) {
+  if (this.current.type === type) {
+    this.advance();
+  } else {
+    throw new ParseError(
+      `Expected '${type}' but got '${this.current.type}'`,
+      this.current,
+      this.source
+    );
   }
+}
+
 
   peekType(offset = 1) {
     return (this.tokens[this.pos + offset] || { type: 'EOF' }).type;
@@ -2270,10 +2447,11 @@ class Parser {
         return this.expressionStatement();
     }
   }
-
-  varDeclaration() {
+varDeclaration() {
+  const t = this.current; // LET token
   this.eat('LET');
-  const id = this.current.value;
+  const idToken = this.current; // identifier token
+  const id = idToken.value;
   this.eat('IDENTIFIER');
 
   let expr = null;
@@ -2285,16 +2463,30 @@ class Parser {
   // semicolon optional
   if (this.current.type === 'SEMICOLON') this.eat('SEMICOLON');
 
-  return { type: 'VarDeclaration', id, expr };
+  return { 
+    type: 'VarDeclaration', 
+    id, 
+    expr, 
+    line: t.line, 
+    column: t.column 
+  };
 }
 
 sldeployStatement() {
+  const t = this.current; // SLDEPLOY token
   this.eat('SLDEPLOY');
   const expr = this.expression();
   if (this.current.type === 'SEMICOLON') this.eat('SEMICOLON');
-  return { type: 'SldeployStatement', expr };
+  return { 
+    type: 'SldeployStatement', 
+    expr, 
+    line: t.line, 
+    column: t.column 
+  };
 }
+
 doTrackStatement() {
+  const t = this.current; // DO token
   this.eat('DO');
 
   const body = this.block();
@@ -2308,13 +2500,17 @@ doTrackStatement() {
   return {
     type: 'DoTrackStatement',
     body,
-    handler
+    handler,
+    line: t.line,
+    column: t.column
   };
 }
 
 defineStatement() {
+  const t = this.current; // DEFINE token
   this.eat('DEFINE');
-  const id = this.current.value;
+  const idToken = this.current; // identifier token
+  const id = idToken.value;
   this.eat('IDENTIFIER');
 
   let expr = null;
@@ -2325,10 +2521,17 @@ defineStatement() {
 
   if (this.current.type === 'SEMICOLON') this.eat('SEMICOLON');
 
-  return { type: 'DefineStatement', id, expr };
+  return { 
+    type: 'DefineStatement', 
+    id, 
+    expr, 
+    line: t.line, 
+    column: t.column 
+  };
 }
 
 asyncFuncDeclaration() {
+  const t = this.current; // first token of function (identifier)
   const name = this.current.value;
   this.eat('IDENTIFIER');
 
@@ -2354,10 +2557,19 @@ asyncFuncDeclaration() {
   }
 
   const body = this.block();
-  return { type: 'FunctionDeclaration', name, params, body, async: true };
+  return { 
+    type: 'FunctionDeclaration', 
+    name, 
+    params, 
+    body, 
+    async: true,
+    line: t.line,
+    column: t.column
+  };
 }
 
 ifStatement() {
+  const t = this.current; // IF token
   this.eat('IF');
 
   let test;
@@ -2366,7 +2578,7 @@ ifStatement() {
     test = this.expression();
     this.eat('RPAREN');
   } else {
-    // python style: no parentheses
+    // Python style: no parentheses
     test = this.expression();
   }
 
@@ -2379,10 +2591,18 @@ ifStatement() {
     else alternate = this.block();
   }
 
-  return { type: 'IfStatement', test, consequent, alternate };
+  return { 
+    type: 'IfStatement', 
+    test, 
+    consequent, 
+    alternate, 
+    line: t.line, 
+    column: t.column 
+  };
 }
 
 whileStatement() {
+  const t = this.current; // WHILE token
   this.eat('WHILE');
 
   let test;
@@ -2395,10 +2615,17 @@ whileStatement() {
   }
 
   const body = this.block();
-  return { type: 'WhileStatement', test, body };
+  return { 
+    type: 'WhileStatement', 
+    test, 
+    body, 
+    line: t.line, 
+    column: t.column 
+  };
 }
 
 importStatement() {
+  const t = this.current; // IMPORT token
   this.eat('IMPORT');
 
   let specifiers = [];
@@ -2407,11 +2634,13 @@ importStatement() {
     this.eat('AS');
     const name = this.current.value;
     this.eat('IDENTIFIER');
-    specifiers.push({ type: 'NamespaceImport', local: name });
+    specifiers.push({ type: 'NamespaceImport', local: name, line: t.line, column: t.column });
   } else if (this.current.type === 'LBRACE') {
     this.eat('LBRACE');
     while (this.current.type !== 'RBRACE') {
       const importedName = this.current.value;
+      const importedLine = this.current.line;
+      const importedColumn = this.current.column;
       this.eat('IDENTIFIER');
 
       let localName = importedName;
@@ -2421,14 +2650,16 @@ importStatement() {
         this.eat('IDENTIFIER');
       }
 
-      specifiers.push({ type: 'NamedImport', imported: importedName, local: localName });
+      specifiers.push({ type: 'NamedImport', imported: importedName, local: localName, line: importedLine, column: importedColumn });
       if (this.current.type === 'COMMA') this.eat('COMMA');
     }
     this.eat('RBRACE');
   } else if (this.current.type === 'IDENTIFIER') {
     const localName = this.current.value;
+    const localLine = this.current.line;
+    const localColumn = this.current.column;
     this.eat('IDENTIFIER');
-    specifiers.push({ type: 'DefaultImport', local: localName });
+    specifiers.push({ type: 'DefaultImport', local: localName, line: localLine, column: localColumn });
   } else {
     throw new Error(`Unexpected token in import at line ${this.current.line}, column ${this.current.column}`);
   }
@@ -2440,9 +2671,17 @@ importStatement() {
 
   if (this.current.type === 'SEMICOLON') this.eat('SEMICOLON');
 
-  return { type: 'ImportStatement', path: pathToken.value, specifiers };
+  return { 
+    type: 'ImportStatement', 
+    path: pathToken.value, 
+    specifiers, 
+    line: t.line, 
+    column: t.column 
+  };
 }
+
 forStatement() {
+  const t = this.current; // FOR token
   this.eat('FOR');
 
   // --- Python-style: for variable in iterable (supports optional 'let') ---
@@ -2450,17 +2689,22 @@ forStatement() {
       (this.current.type === 'IDENTIFIER' && this.peekType() === 'IN')) {
 
     let variable;
+    let variableLine, variableColumn;
     let iterable;
     let letKeyword = false;
 
     if (this.current.type === 'LET') {
       letKeyword = true;
       this.eat('LET');
+      variableLine = this.current.line;
+      variableColumn = this.current.column;
       variable = this.current.value;
       this.eat('IDENTIFIER');
       this.eat('IN');
       iterable = this.expression();
     } else {
+      variableLine = this.current.line;
+      variableColumn = this.current.column;
       variable = this.current.value;
       this.eat('IDENTIFIER');
       this.eat('IN');
@@ -2468,7 +2712,17 @@ forStatement() {
     }
 
     const body = this.block();
-    return { type: 'ForInStatement', variable, iterable, letKeyword, body };
+    return { 
+      type: 'ForInStatement', 
+      variable, 
+      variableLine, 
+      variableColumn,
+      iterable, 
+      letKeyword, 
+      body,
+      line: t.line,
+      column: t.column
+    };
   }
 
   // --- C-style: for(init; test; update) ---
@@ -2503,37 +2757,51 @@ forStatement() {
   }
 
   const body = this.block();
-  return { type: 'ForStatement', init, test, update, body };
+  return { 
+    type: 'ForStatement', 
+    init, 
+    test, 
+    update, 
+    body,
+    line: t.line,
+    column: t.column
+  };
 }
 
 breakStatement() {
+  const t = this.current; // BREAK token
   this.eat('BREAK');
   // Python-style: no semicolon needed, ignore if present
   if (this.current.type === 'SEMICOLON') this.advance();
-  return { type: 'BreakStatement' };
+  return { type: 'BreakStatement', line: t.line, column: t.column };
 }
 
 continueStatement() {
+  const t = this.current; // CONTINUE token
   this.eat('CONTINUE');
   // Python-style: no semicolon needed, ignore if present
   if (this.current.type === 'SEMICOLON') this.advance();
-  return { type: 'ContinueStatement' };
+  return { type: 'ContinueStatement', line: t.line, column: t.column };
 }
 
 funcDeclaration() {
+  const t = this.current; // FUNC token
   this.eat('FUNC');
-  const name = this.current.value;
+  const nameToken = this.current;
+  const name = nameToken.value;
   this.eat('IDENTIFIER');
 
   let params = [];
   if (this.current.type === 'LPAREN') {
     this.eat('LPAREN');
     if (this.current.type !== 'RPAREN') {
-      params.push(this.current.value);
+      const paramToken = this.current;
+      params.push({ name: paramToken.value, line: paramToken.line, column: paramToken.column });
       this.eat('IDENTIFIER');
       while (this.current.type === 'COMMA') {
         this.eat('COMMA');
-        params.push(this.current.value);
+        const paramToken2 = this.current;
+        params.push({ name: paramToken2.value, line: paramToken2.line, column: paramToken2.column });
         this.eat('IDENTIFIER');
       }
     }
@@ -2541,16 +2809,18 @@ funcDeclaration() {
   } else {
     // Python-style: single param without parentheses
     if (this.current.type === 'IDENTIFIER') {
-      params.push(this.current.value);
+      const paramToken = this.current;
+      params.push({ name: paramToken.value, line: paramToken.line, column: paramToken.column });
       this.eat('IDENTIFIER');
     }
   }
 
   const body = this.block();
-  return { type: 'FunctionDeclaration', name, params, body };
+  return { type: 'FunctionDeclaration', name, params, body, line: t.line, column: t.column };
 }
 
 returnStatement() {
+  const t = this.current; // RETURN token
   this.eat('RETURN');
 
   let argument = null;
@@ -2561,24 +2831,26 @@ returnStatement() {
   // semicolon optional
   if (this.current.type === 'SEMICOLON') this.eat('SEMICOLON');
 
-  return { type: 'ReturnStatement', argument };
+  return { type: 'ReturnStatement', argument, line: t.line, column: t.column };
 }
 
 block() {
+  const t = this.current; // LBRACE token
   this.eat('LBRACE');
   const body = [];
   while (this.current.type !== 'RBRACE') {
     body.push(this.statement());
   }
   this.eat('RBRACE');
-  return { type: 'BlockStatement', body };
+  return { type: 'BlockStatement', body, line: t.line, column: t.column };
 }
 
 expressionStatement() {
+  const exprToken = this.current; // first token of the expression
   const expr = this.expression();
   // semicolon optional
   if (this.current.type === 'SEMICOLON') this.eat('SEMICOLON');
-  return { type: 'ExpressionStatement', expression: expr };
+  return { type: 'ExpressionStatement', expression: expr, line: exprToken.line, column: exprToken.column };
 }
 
 expression() {
@@ -2589,17 +2861,19 @@ assignment() {
   const node = this.logicalOr();
   const compoundOps = ['PLUSEQ', 'MINUSEQ', 'STAREQ', 'SLASHEQ', 'MODEQ'];
 
-  if (compoundOps.includes(this.current.type)) {
-    const op = this.current.type;
+  const t = this.current;
+
+  if (compoundOps.includes(t.type)) {
+    const op = t.type;
     this.eat(op);
     const right = this.assignment();
-    return { type: 'CompoundAssignment', operator: op, left: node, right };
+    return { type: 'CompoundAssignment', operator: op, left: node, right, line: t.line, column: t.column };
   }
 
-  if (this.current.type === 'EQUAL') {
+  if (t.type === 'EQUAL') {
     this.eat('EQUAL');
     const right = this.assignment();
-    return { type: 'AssignmentExpression', left: node, right };
+    return { type: 'AssignmentExpression', left: node, right, line: t.line, column: t.column };
   }
 
   return node;
@@ -2608,9 +2882,10 @@ assignment() {
 logicalOr() {
   let node = this.logicalAnd();
   while (this.current.type === 'OR') {
-    const op = this.current.type;
+    const t = this.current;
+    const op = t.type;
     this.eat(op);
-    node = { type: 'LogicalExpression', operator: op, left: node, right: this.logicalAnd() };
+    node = { type: 'LogicalExpression', operator: op, left: node, right: this.logicalAnd(), line: t.line, column: t.column };
   }
   return node;
 }
@@ -2618,18 +2893,21 @@ logicalOr() {
 logicalAnd() {
   let node = this.equality();
   while (this.current.type === 'AND') {
-    const op = this.current.type;
+    const t = this.current;
+    const op = t.type;
     this.eat(op);
-    node = { type: 'LogicalExpression', operator: op, left: node, right: this.equality() };
+    node = { type: 'LogicalExpression', operator: op, left: node, right: this.equality(), line: t.line, column: t.column };
   }
   return node;
 }
+
 equality() {
   let node = this.comparison();
   while (['EQEQ', 'NOTEQ'].includes(this.current.type)) {
-    const op = this.current.type;
+    const t = this.current;
+    const op = t.type;
     this.eat(op);
-    node = { type: 'BinaryExpression', operator: op, left: node, right: this.comparison() };
+    node = { type: 'BinaryExpression', operator: op, left: node, right: this.comparison(), line: t.line, column: t.column };
   }
   return node;
 }
@@ -2637,9 +2915,10 @@ equality() {
 comparison() {
   let node = this.term();
   while (['LT', 'LTE', 'GT', 'GTE'].includes(this.current.type)) {
-    const op = this.current.type;
+    const t = this.current;
+    const op = t.type;
     this.eat(op);
-    node = { type: 'BinaryExpression', operator: op, left: node, right: this.term() };
+    node = { type: 'BinaryExpression', operator: op, left: node, right: this.term(), line: t.line, column: t.column };
   }
   return node;
 }
@@ -2647,9 +2926,10 @@ comparison() {
 term() {
   let node = this.factor();
   while (['PLUS', 'MINUS'].includes(this.current.type)) {
-    const op = this.current.type;
+    const t = this.current;
+    const op = t.type;
     this.eat(op);
-    node = { type: 'BinaryExpression', operator: op, left: node, right: this.factor() };
+    node = { type: 'BinaryExpression', operator: op, left: node, right: this.factor(), line: t.line, column: t.column };
   }
   return node;
 }
@@ -2657,26 +2937,43 @@ term() {
 factor() {
   let node = this.unary();
   while (['STAR', 'SLASH', 'MOD'].includes(this.current.type)) {
-    const op = this.current.type;
+    const t = this.current;
+    const op = t.type;
     this.eat(op);
-    node = { type: 'BinaryExpression', operator: op, left: node, right: this.unary() };
+    node = { type: 'BinaryExpression', operator: op, left: node, right: this.unary(), line: t.line, column: t.column };
   }
   return node;
 }
 
+
 unary() {
-  if (['NOT', 'MINUS', 'PLUS'].includes(this.current.type)) {
-    const op = this.current.type;
+  const t = this.current;
+
+  if (['NOT', 'MINUS', 'PLUS'].includes(t.type)) {
+    const op = t.type;
     this.eat(op);
-    return { type: 'UnaryExpression', operator: op, argument: this.unary() };
+    return {
+      type: 'UnaryExpression',
+      operator: op,
+      argument: this.unary(),
+      line: t.line,
+      column: t.column
+    };
   }
 
   // Python-like: ignore ++ and -- if not used
-  if (this.current.type === 'PLUSPLUS' || this.current.type === 'MINUSMINUS') {
-    const op = this.current.type;
+  if (t.type === 'PLUSPLUS' || t.type === 'MINUSMINUS') {
+    const op = t.type;
     this.eat(op);
     const argument = this.unary();
-    return { type: 'UpdateExpression', operator: op, argument, prefix: true };
+    return {
+      type: 'UpdateExpression',
+      operator: op,
+      argument,
+      prefix: true,
+      line: t.line,
+      column: t.column
+    };
   }
 
   return this.postfix();
@@ -2685,15 +2982,21 @@ unary() {
 postfix() {
   let node = this.primary();
   while (true) {
-    if (this.current.type === 'LBRACKET') {
+    const t = this.current;
+
+    if (t.type === 'LBRACKET') {
+      const startLine = t.line;
+      const startCol = t.column;
       this.eat('LBRACKET');
       const index = this.expression();
       if (this.current.type === 'RBRACKET') this.eat('RBRACKET');
-      node = { type: 'IndexExpression', object: node, indexer: index };
+      node = { type: 'IndexExpression', object: node, indexer: index, line: startLine, column: startCol };
       continue;
     }
 
-    if (this.current.type === 'LPAREN') {
+    if (t.type === 'LPAREN') {
+      const startLine = t.line;
+      const startCol = t.column;
       this.eat('LPAREN');
       const args = [];
       while (this.current.type !== 'RPAREN' && this.current.type !== 'EOF') {
@@ -2701,30 +3004,30 @@ postfix() {
         if (this.current.type === 'COMMA') this.eat('COMMA'); // optional comma
       }
       if (this.current.type === 'RPAREN') this.eat('RPAREN');
-      node = { type: 'CallExpression', callee: node, arguments: args };
+      node = { type: 'CallExpression', callee: node, arguments: args, line: startLine, column: startCol };
       continue;
     }
 
-    if (this.current.type === 'DOT') {
+    if (t.type === 'DOT') {
+      const startLine = t.line;
+      const startCol = t.column;
       this.eat('DOT');
       const property = this.current.value || '';
       if (this.current.type === 'IDENTIFIER') this.eat('IDENTIFIER');
-      node = { type: 'MemberExpression', object: node, property };
+      node = { type: 'MemberExpression', object: node, property, line: startLine, column: startCol };
       continue;
     }
 
-    if (this.current.type === 'PLUSPLUS' || this.current.type === 'MINUSMINUS') {
-      const op = this.current.type;
-      this.eat(op);
-      node = { type: 'UpdateExpression', operator: op, argument: node, prefix: false };
+    if (t.type === 'PLUSPLUS' || t.type === 'MINUSMINUS') {
+      this.eat(t.type);
+      node = { type: 'UpdateExpression', operator: t.type, argument: node, prefix: false, line: t.line, column: t.column };
       continue;
     }
 
-    // Python-style: implicit function calls (if identifier followed by identifier)
-    if (node.type === 'Identifier' && this.current.type === 'IDENTIFIER') {
-      const argNode = { type: 'Identifier', name: this.current.value };
+    if (node.type === 'Identifier' && t.type === 'IDENTIFIER') {
+      const argNode = { type: 'Identifier', name: t.value, line: t.line, column: t.column };
       this.eat('IDENTIFIER');
-      node = { type: 'CallExpression', callee: node, arguments: [argNode] };
+      node = { type: 'CallExpression', callee: node, arguments: [argNode], line: node.line, column: node.column };
       continue;
     }
 
@@ -2734,12 +3037,18 @@ postfix() {
 }
 
 arrowFunction(params) {
-  if (this.current.type === 'ARROW') this.eat('ARROW');
+  const t = this.current;
+  if (t.type === 'ARROW') this.eat('ARROW');
   const body = this.expression();
+  const startLine = params.length > 0 ? params[0].line : t.line;
+  const startCol = params.length > 0 ? params[0].column : t.column;
+
   return {
     type: 'ArrowFunctionExpression',
     params,
-    body
+    body,
+    line: startLine,
+    column: startCol
   };
 }
 
@@ -2747,16 +3056,35 @@ arrowFunction(params) {
   primary() {
   const t = this.current;
 
-  if (t.type === 'NUMBER') { this.eat('NUMBER'); return { type: 'Literal', value: t.value }; }
-  if (t.type === 'STRING') { this.eat('STRING'); return { type: 'Literal', value: t.value }; }
-  if (t.type === 'TRUE') { this.eat('TRUE'); return { type: 'Literal', value: true }; }
-  if (t.type === 'FALSE') { this.eat('FALSE'); return { type: 'Literal', value: false }; }
-  if (t.type === 'NULL') { this.eat('NULL'); return { type: 'Literal', value: null }; }
+  if (t.type === 'NUMBER') { 
+    this.eat('NUMBER'); 
+    return { type: 'Literal', value: t.value, line: t.line, column: t.column }; 
+  }
+
+  if (t.type === 'STRING') { 
+    this.eat('STRING'); 
+    return { type: 'Literal', value: t.value, line: t.line, column: t.column }; 
+  }
+
+  if (t.type === 'TRUE') { 
+    this.eat('TRUE'); 
+    return { type: 'Literal', value: true, line: t.line, column: t.column }; 
+  }
+
+  if (t.type === 'FALSE') { 
+    this.eat('FALSE'); 
+    return { type: 'Literal', value: false, line: t.line, column: t.column }; 
+  }
+
+  if (t.type === 'NULL') { 
+    this.eat('NULL'); 
+    return { type: 'Literal', value: null, line: t.line, column: t.column }; 
+  }
 
   if (t.type === 'AWAIT') {
     this.eat('AWAIT');
     const argument = this.expression(); 
-    return { type: 'AwaitExpression', argument };
+    return { type: 'AwaitExpression', argument, line: t.line, column: t.column };
   }
 
   if (t.type === 'NEW') {
@@ -2772,7 +3100,7 @@ arrowFunction(params) {
       }
     }
     this.eat('RPAREN');
-    return { type: 'NewExpression', callee, arguments: args };
+    return { type: 'NewExpression', callee, arguments: args, line: t.line, column: t.column };
   }
 
   if (t.type === 'ASK') {
@@ -2787,7 +3115,13 @@ arrowFunction(params) {
       }
     }
     this.eat('RPAREN');
-    return { type: 'CallExpression', callee: { type: 'Identifier', name: 'ask' }, arguments: args };
+    return { 
+      type: 'CallExpression', 
+      callee: { type: 'Identifier', name: 'ask', line: t.line, column: t.column }, 
+      arguments: args, 
+      line: t.line, 
+      column: t.column 
+    };
   }
 
   if (t.type === 'IDENTIFIER') {
@@ -2795,13 +3129,15 @@ arrowFunction(params) {
     this.eat('IDENTIFIER');
 
     if (this.current.type === 'ARROW') {
-      return this.arrowFunction([name]);
+      return this.arrowFunction([{ type: 'Identifier', name, line: t.line, column: t.column }]);
     }
 
-    return { type: 'Identifier', name };
+    return { type: 'Identifier', name, line: t.line, column: t.column };
   }
 
   if (t.type === 'LPAREN') {
+    const startLine = t.line;
+    const startCol = t.column;
     this.eat('LPAREN');
     const elements = [];
 
@@ -2817,10 +3153,12 @@ arrowFunction(params) {
 
     if (this.current.type === 'ARROW') return this.arrowFunction(elements);
 
-    return elements.length === 1 ? elements[0] : { type: 'ArrayExpression', elements };
+    return elements.length === 1 ? elements[0] : { type: 'ArrayExpression', elements, line: startLine, column: startCol };
   }
 
   if (t.type === 'LBRACKET') {
+    const startLine = t.line;
+    const startCol = t.column;
     this.eat('LBRACKET');
     const elements = [];
     if (this.current.type !== 'RBRACKET') {
@@ -2831,10 +3169,12 @@ arrowFunction(params) {
       }
     }
     this.eat('RBRACKET');
-    return { type: 'ArrayExpression', elements };
+    return { type: 'ArrayExpression', elements, line: startLine, column: startCol };
   }
 
   if (t.type === 'LBRACE') {
+    const startLine = t.line;
+    const startCol = t.column;
     this.eat('LBRACE');
     const props = [];
     while (this.current.type !== 'RBRACE') {
@@ -2845,12 +3185,17 @@ arrowFunction(params) {
       if (this.current.type === 'COMMA') this.eat('COMMA'); // optional trailing comma
     }
     this.eat('RBRACE');
-    return { type: 'ObjectExpression', props };
+    return { type: 'ObjectExpression', props, line: startLine, column: startCol };
   }
 
-  throw new Error(`Unexpected token in primary: ${t.type} at line ${this.current.line}, column ${this.current.column}`);
+  throw new ParseError(
+    `Unexpected token '${t.type}'`,
+    t,
+    this.source
+  );
 }
 
+
 }
 
 module.exports = Parser;
@@ -2955,7 +3300,7 @@ const Lexer = __nccwpck_require__(211);
 const Parser = __nccwpck_require__(222);
 const Evaluator = __nccwpck_require__(112);
 
-const VERSION = '1.0.46';
+const VERSION = '1.0.48';
 
 const COLOR = {
     reset: '\x1b[0m',
@@ -2966,7 +3311,8 @@ const COLOR = {
     cyan: '\x1b[36m',
     gray: '\x1b[90m',
     green: '\x1b[32m',
-    magenta: '\x1b[35m'
+    magenta: '\x1b[35m',
+    white: '\x1b[37m'
 };
 
 function waitAndExit(code = 0) {
@@ -2977,7 +3323,7 @@ function waitAndExit(code = 0) {
 }
 
 function fatal(msg) {
-    console.error(COLOR.red + msg + COLOR.reset);
+    console.error(COLOR.white + msg + COLOR.reset);
     waitAndExit(1);
 }
 
@@ -3118,24 +3464,35 @@ function savePrompt(lines) {
     waitAndExit(0);
 }
 
-function runFile(filePath, isTemp = false, callback) {
+async function runFile(filePath, isTemp = false, callback) {
     const code = fs.readFileSync(filePath, 'utf8');
 
+    const lexer = new Lexer(code);
+    const tokens = lexer.getTokens();
+    const parser = new Parser(tokens, code);
+    const ast = parser.parse();
+    const evaluator = new Evaluator(code);
+
     try {
-        const lexer = new Lexer(code);
-        const parser = new Parser(lexer.getTokens());
-        const ast = parser.parse();
-        new Evaluator().evaluate(ast);
+        await evaluator.evaluate(ast);
     } catch (e) {
-        console.error(COLOR.red + e.message + COLOR.reset);
+        if (e.name === 'RuntimeError' || e.name === 'SyntaxError') {
+            console.error(COLOR.white + e.message + COLOR.reset);
+        } else {
+            console.error(COLOR.white + `Unexpected Error: ${e.message || e}` + COLOR.reset);
+        }
         return waitAndExit(1);
     }
 
-    
     if (callback) callback();
-    if (isTemp) try { fs.unlinkSync(filePath); } catch {}
+
+    if (isTemp) {
+        try { fs.unlinkSync(filePath); } catch {}
+    }
 }
 
+
+
 if (!args[0].startsWith('--')) {
     runFile(path.resolve(args[0]));
 }