starlight-cli 1.0.46 → 1.0.47

package/dist/index.js

@@ -1352,6 +1352,14 @@ class ReturnValue {
 }
 class BreakSignal {}
 class ContinueSignal {}
+class RuntimeError extends Error {
+  constructor(message, node) {
+    const line = node?.line ?? '?';
+    const column = node?.column ?? '?';
+    super(`RuntimeError: ${message} at line ${line}, column ${column}`);
+    this.name = 'RuntimeError';
+  }
+}
 
 class Environment {
   constructor(parent = null) {
@@ -1368,7 +1376,7 @@ class Environment {
   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}`);
+    throw new RuntimeError(`Undefined variable: ${name}`);
   }
 
   set(name, value) {
@@ -1472,11 +1480,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');
   }
 
   if (step === 0) {
-    throw new Error('range() step cannot be 0');
+    throw new RuntimeError('range() step cannot be 0');
   }
 
   const result = [];
@@ -1500,7 +1508,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');
     }
     return n;
 });
@@ -1611,7 +1619,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);
   }
 
   const args = [];
@@ -1620,7 +1628,8 @@ case 'DoTrackStatement':
 }
 
     default:
-      throw new Error(`Unknown node type in evaluator: ${node.type}`);
+       throw new RuntimeError(`Unknown node type in evaluator: ${node.type}`, node);
+
   }
 }
 
@@ -1636,15 +1645,26 @@ 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);
+    }
 
     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);
+    }
   }
 }
 
+
 async evalImport(node, env) {
   const spec = node.path;
   let lib;
@@ -1660,7 +1680,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);
     }
 
     const code = fs.readFileSync(fullPath, 'utf-8');
@@ -1687,7 +1707,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);
       }
       env.define(imp.local, lib[imp.imported]);
     }
@@ -1703,12 +1723,14 @@ 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);
     }
   }
   return result;
 }
 
+
 async evalVarDeclaration(node, env) {
   const val = await this.evaluate(node.expr, env);
   return env.define(node.id, val);
@@ -1741,7 +1763,8 @@ async evalAssignment(node, env) {
     return rightVal;
   }
 
-  throw new Error('Invalid assignment target');
+ throw new RuntimeError('Invalid assignment target', node);
+
 }
 
 async evalCompoundAssignment(node, env) {
@@ -1751,7 +1774,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);
+
 
   const rhs = await this.evaluate(node.right, env);
   let computed;
@@ -1761,7 +1785,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);
+
   }
 
   if (left.type === 'Identifier') env.set(left.name, computed);
@@ -1794,7 +1819,7 @@ async evalBinary(node, 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);
   }
 
   switch (node.operator) {
@@ -1809,7 +1834,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);
+
   }
 }
 
@@ -1817,7 +1843,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);
+
 }
 
 async evalUnary(node, env) {
@@ -1826,7 +1853,8 @@ 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);
+
   }
 }
 
@@ -1856,7 +1884,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);
     }
 
     const loopVar = node.variable; // STRING from parser
@@ -1936,7 +1964,7 @@ async evalCall(node, env) {
     return calleeEvaluated(...args);
   }
   if (!calleeEvaluated || typeof calleeEvaluated !== 'object' || !calleeEvaluated.body) {
-    throw new Error('Call to non-function');
+    throw new RuntimeError('Call to non-function', node);
   }
 
   const fn = calleeEvaluated;
@@ -1960,12 +1988,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);
+
   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);
   }
   if (typeof obj === 'object' && !(idx in obj)) {
-    throw new Error(`Property '${idx}' does not exist`);
+    throw new RuntimeError(`Property '${idx}' does not exist`, node);
   }
 
   return obj[idx];
@@ -1973,14 +2002,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);
+    }
+    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);
+if (!(node.property in obj)) throw new RuntimeError(`Property '${node.property}' does not exist`, node);
   return obj[node.property];
 }
 
@@ -1990,7 +2027,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);
+
   };
   const setValue = async (v) => {
     if (arg.type === 'Identifier') env.set(arg.name, v);
@@ -2020,14 +2058,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 +2102,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 +2277,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;
@@ -2848,7 +2940,12 @@ arrowFunction(params) {
     return { type: 'ObjectExpression', props };
   }
 
-  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
+);
+
 }
 
 }
@@ -2955,7 +3052,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.47';
 
 const COLOR = {
     reset: '\x1b[0m',
@@ -3123,19 +3220,28 @@ function runFile(filePath, isTemp = false, callback) {
 
     try {
         const lexer = new Lexer(code);
-        const parser = new Parser(lexer.getTokens());
+        const tokens = lexer.getTokens();
+        const parser = new Parser(tokens);
         const ast = parser.parse();
         new Evaluator().evaluate(ast);
     } catch (e) {
-        console.error(COLOR.red + e.message + COLOR.reset);
+        if (e.name === 'RuntimeError') {
+            console.error(COLOR.red + e.message + COLOR.reset);
+        } else if (e instanceof SyntaxError) {
+            console.error(COLOR.red + `SyntaxError: ${e.message}` + COLOR.reset);
+        } else {
+            console.error(COLOR.red + `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]));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "starlight-cli",
-  "version": "1.0.46",
+  "version": "1.0.47",
   "description": "Starlight Programming Language CLI",
   "bin": {
     "starlight": "index.js"

package/src/evaluator.js

@@ -9,6 +9,14 @@ class ReturnValue {
 }
 class BreakSignal {}
 class ContinueSignal {}
+class RuntimeError extends Error {
+  constructor(message, node) {
+    const line = node?.line ?? '?';
+    const column = node?.column ?? '?';
+    super(`RuntimeError: ${message} at line ${line}, column ${column}`);
+    this.name = 'RuntimeError';
+  }
+}
 
 class Environment {
   constructor(parent = null) {
@@ -25,7 +33,7 @@ class Environment {
   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}`);
+    throw new RuntimeError(`Undefined variable: ${name}`);
   }
 
   set(name, value) {
@@ -129,11 +137,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');
   }
 
   if (step === 0) {
-    throw new Error('range() step cannot be 0');
+    throw new RuntimeError('range() step cannot be 0');
   }
 
   const result = [];
@@ -157,7 +165,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');
     }
     return n;
 });
@@ -268,7 +276,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);
   }
 
   const args = [];
@@ -277,7 +285,8 @@ case 'DoTrackStatement':
 }
 
     default:
-      throw new Error(`Unknown node type in evaluator: ${node.type}`);
+       throw new RuntimeError(`Unknown node type in evaluator: ${node.type}`, node);
+
   }
 }
 
@@ -293,15 +302,26 @@ 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);
+    }
 
     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);
+    }
   }
 }
 
+
 async evalImport(node, env) {
   const spec = node.path;
   let lib;
@@ -317,7 +337,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);
     }
 
     const code = fs.readFileSync(fullPath, 'utf-8');
@@ -344,7 +364,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);
       }
       env.define(imp.local, lib[imp.imported]);
     }
@@ -360,12 +380,14 @@ 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);
     }
   }
   return result;
 }
 
+
 async evalVarDeclaration(node, env) {
   const val = await this.evaluate(node.expr, env);
   return env.define(node.id, val);
@@ -398,7 +420,8 @@ async evalAssignment(node, env) {
     return rightVal;
   }
 
-  throw new Error('Invalid assignment target');
+ throw new RuntimeError('Invalid assignment target', node);
+
 }
 
 async evalCompoundAssignment(node, env) {
@@ -408,7 +431,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);
+
 
   const rhs = await this.evaluate(node.right, env);
   let computed;
@@ -418,7 +442,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);
+
   }
 
   if (left.type === 'Identifier') env.set(left.name, computed);
@@ -451,7 +476,7 @@ async evalBinary(node, 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);
   }
 
   switch (node.operator) {
@@ -466,7 +491,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);
+
   }
 }
 
@@ -474,7 +500,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);
+
 }
 
 async evalUnary(node, env) {
@@ -483,7 +510,8 @@ 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);
+
   }
 }
 
@@ -513,7 +541,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);
     }
 
     const loopVar = node.variable; // STRING from parser
@@ -593,7 +621,7 @@ async evalCall(node, env) {
     return calleeEvaluated(...args);
   }
   if (!calleeEvaluated || typeof calleeEvaluated !== 'object' || !calleeEvaluated.body) {
-    throw new Error('Call to non-function');
+    throw new RuntimeError('Call to non-function', node);
   }
 
   const fn = calleeEvaluated;
@@ -617,12 +645,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);
+
   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);
   }
   if (typeof obj === 'object' && !(idx in obj)) {
-    throw new Error(`Property '${idx}' does not exist`);
+    throw new RuntimeError(`Property '${idx}' does not exist`, node);
   }
 
   return obj[idx];
@@ -630,14 +659,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);
+    }
+    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);
+if (!(node.property in obj)) throw new RuntimeError(`Property '${node.property}' does not exist`, node);
   return obj[node.property];
 }
 
@@ -647,7 +684,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);
+
   };
   const setValue = async (v) => {
     if (arg.type === 'Identifier') env.set(arg.name, v);

package/src/lexer.js

@@ -1,11 +1,30 @@
+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') {
@@ -23,8 +42,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();

package/src/parser.js

@@ -1,22 +1,51 @@
-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;
@@ -632,7 +661,12 @@ arrowFunction(params) {
     return { type: 'ObjectExpression', props };
   }
 
-  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
+);
+
 }
 
 }

package/src/starlight.js

@@ -9,7 +9,7 @@ const Lexer = require('./lexer');
 const Parser = require('./parser');
 const Evaluator = require('./evaluator');
 
-const VERSION = '1.0.46';
+const VERSION = '1.0.47';
 
 const COLOR = {
     reset: '\x1b[0m',
@@ -177,19 +177,28 @@ function runFile(filePath, isTemp = false, callback) {
 
     try {
         const lexer = new Lexer(code);
-        const parser = new Parser(lexer.getTokens());
+        const tokens = lexer.getTokens();
+        const parser = new Parser(tokens);
         const ast = parser.parse();
         new Evaluator().evaluate(ast);
     } catch (e) {
-        console.error(COLOR.red + e.message + COLOR.reset);
+        if (e.name === 'RuntimeError') {
+            console.error(COLOR.red + e.message + COLOR.reset);
+        } else if (e instanceof SyntaxError) {
+            console.error(COLOR.red + `SyntaxError: ${e.message}` + COLOR.reset);
+        } else {
+            console.error(COLOR.red + `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]));
 }