starlight-cli 1.1.11 → 1.1.13

package/dist/index.js

@@ -10219,35 +10219,77 @@ class ReturnValue {
 }
 class BreakSignal {}
 class ContinueSignal {}
+const COLOR = {
+  reset: '\x1b[0m',
+  red: '\x1b[31m',
+  yellow: '\x1b[33m',
+  white: '\x1b[37m'
+};
+
 class RuntimeError extends Error {
-    constructor(message, node, source) {
-        const line = node?.line ?? '?';
-        const column = node?.column ?? '?';
+  constructor(message, node, source, env = null) {
+    const line = node?.line ?? '?';
+    const column = node?.column ?? '?';
 
-        let output = ` ${message} at line ${line}, column ${column}\n`;
+    let output =
+      `${COLOR.red}${message}${COLOR.reset} 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`;
-            const caretPos =
-  typeof column === 'number' && column > 0
-    ? column - 1
-    : 0;
+    if (source && node?.line != null) {
+      const lines = source.split('\n');
+      const srcLine = lines[node.line - 1] || '';
+      const caretPos =
+        typeof column === 'number' && column > 0 ? column - 1 : 0;
+
+      output += `${COLOR.white}  ${srcLine}\n`;
+      output += `  ${' '.repeat(caretPos)}^\n${COLOR.reset}`;
+    }
 
-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 +=
+            `${COLOR.yellow}Did you mean "${suggestion}"?${COLOR.reset}\n`;
         }
+      }
+    }
+
+    super(output);
+    this.name = 'RuntimeError';
+    this.line = line;
+    this.column = column;
+  }
 
-        super(output);
+  static suggest(name, env) {
+    const names = new Set();
+    let current = env;
 
-        this.name = 'RuntimeError';
-        this.line = line;
-        this.column = column;
+    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) {
@@ -10265,16 +10307,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);
 }
 
 
@@ -10326,31 +10359,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 = __nccwpck_require__(55);
 
@@ -10693,10 +10702,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;
@@ -10706,6 +10722,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) {
@@ -10723,11 +10740,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
         );
       }
     }
@@ -10743,28 +10760,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
     );
   }
 }
@@ -10775,7 +10795,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);
@@ -10785,12 +10810,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;
@@ -10806,34 +10835,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]);
     }
@@ -10841,7 +10887,6 @@ async evalImport(node, env) {
 
   return null;
 }
-
 async evalBlock(node, env) {
   let result = null;
   for (const stmt of node.body) {
@@ -10860,32 +10905,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;
@@ -10893,7 +10961,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]);
@@ -10901,78 +10968,128 @@ 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);
+  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
+    );
 
-  const rhs = await this.evaluate(node.right, env);
-  let computed;
+    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
+      );
+    }
 
-  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);
-  }
+    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
+      );
+    }
 
-  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);
+    return computed;
 
-  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);
   console.log(this.formatValue(val));
@@ -10980,108 +11097,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);
@@ -11095,183 +11266,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);
-
-    if (iterable == null || typeof iterable !== 'object') {
-      throw new RuntimeError('Cannot iterate over non-iterable', node, this.source);
-    }
-
-    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;
-        }
+  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,
+          env
+        );
       }
-    }
-    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;
+
+      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;
+          }
         }
       }
-    }
 
-    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);
+    }
 
-  for (let i = 0; i < fn.params.length; i++) {
-  const argVal = node.arguments[i]
-    ? await this.evaluate(node.arguments[i], env)
-    : null;
+    // Not a callable object
+    if (!calleeEvaluated || typeof calleeEvaluated !== 'object' || !calleeEvaluated.body) {
+      throw new RuntimeError(
+        'Call to non-function',
+        node,
+        this.source,
+        env
+      );
+    }
 
-  const param = fn.params[i];
-  const paramName = typeof param === 'string' ? param : param.name;
+    const fn = calleeEvaluated;
+    const callEnv = new Environment(fn.env);
 
-  callEnv.define(paramName, argVal);
-}
+    for (let i = 0; i < fn.params.length; i++) {
+      const argVal = node.arguments[i]
+        ? await this.evaluate(node.arguments[i], env)
+        : null;
 
-  try {
-    const result = await this.evaluate(fn.body, callEnv);
-    return result;
-  } catch (e) {
-    if (e instanceof ReturnValue) return e.value;
-    throw e;
+      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 === 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) {
@@ -11290,33 +11548,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;
+  }
 }
 
 }
@@ -11560,21 +11846,39 @@ module.exports = Lexer;
 /***/ 222:
 /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
 
+const COLOR = {
+  reset: '\x1b[0m',
+  red: '\x1b[31m',
+  yellow: '\x1b[33m',
+  white: '\x1b[37m'
+};
+
 class ParseError extends Error {
-  constructor(message, token, source) {
+  constructor(message, token, source, suggestion = null) {
     const line = token?.line ?? '?';
     const column = token?.column ?? '?';
 
-    let output = `${message}\n`;
+    let output = `${COLOR.red}${message}${COLOR.reset}\n`;
+
+    if (suggestion) {
+      output += `${COLOR.yellow}${suggestion}${COLOR.reset}\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`;
+
+      output += `${COLOR.white}  at line ${line}, column ${column}\n`;
+      const caretPos =
+  typeof column === 'number' && column > 0
+    ? column - 1
+    : 0;
+
+output += `    ${srcLine}\n`;
+output += `    ${' '.repeat(caretPos)}^\n${COLOR.reset}`;
+
     } else {
-      output += `  at line ${line}, column ${column}\n`;
+      output += `${COLOR.white}  at line ${line}, column ${column}\n${COLOR.reset}`;
     }
 
     super(output);
@@ -11649,17 +11953,49 @@ class Parser {
 varDeclaration() {
   const t = this.current; 
   this.eat('LET');
+
+  if (this.current.type !== 'IDENTIFIER') {
+    throw new ParseError(
+      "Expected variable name after 'let'",
+      this.current,
+      this.source,
+      "Variable declarations must be followed by an identifier, e.g. let x = 5"
+    );
+  }
+
   const idToken = this.current; 
   const id = idToken.value;
   this.eat('IDENTIFIER');
 
   let expr = null;
+
+  if (this.current.type === 'EQEQ') {
+    throw new ParseError(
+      "Invalid '==' in variable declaration",
+      this.current,
+      this.source,
+      "Did you mean '=' for assignment?"
+    );
+  }
+
   if (this.current.type === 'EQUAL') {
     this.eat('EQUAL');
+
+    if (this.current.type === 'SEMICOLON') {
+      throw new ParseError(
+        "Expected expression after '='",
+        this.current,
+        this.source,
+        "Assignments require a value, e.g. let x = 10"
+      );
+    }
+
     expr = this.expression();
   }
 
-  if (this.current.type === 'SEMICOLON') this.eat('SEMICOLON');
+  if (this.current.type === 'SEMICOLON') {
+    this.eat('SEMICOLON');
+  }
 
   return { 
     type: 'VarDeclaration', 
@@ -11669,12 +12005,31 @@ varDeclaration() {
     column: t.column 
   };
 }
+
 startStatement() {
   const t = this.current; 
   this.eat('START');
 
+  if (this.current.type === 'LBRACE') {
+    throw new ParseError(
+      "Expected expression after 'start'",
+      this.current,
+      this.source,
+      "The 'start' statement requires a discriminant expression"
+    );
+  }
+
   const discriminant = this.expression();
 
+  if (this.current.type !== 'LBRACE') {
+    throw new ParseError(
+      "Expected '{' to start start-block",
+      this.current,
+      this.source,
+      "Start blocks must be enclosed in braces"
+    );
+  }
+
   this.eat('LBRACE');
 
   const cases = [];
@@ -11683,6 +12038,24 @@ startStatement() {
     cases.push(this.raceClause());
   }
 
+  if (cases.length === 0) {
+    throw new ParseError(
+      "Start statement must contain at least one 'race' clause",
+      this.current,
+      this.source,
+      "Use 'race <condition> { ... }' inside start blocks"
+    );
+  }
+
+  if (this.current.type !== 'RBRACE') {
+    throw new ParseError(
+      "Expected '}' to close start block",
+      this.current,
+      this.source,
+      "Did you forget to close the start block?"
+    );
+  }
+
   this.eat('RBRACE');
 
   return {
@@ -11697,8 +12070,26 @@ raceClause() {
   const t = this.current; 
   this.eat('RACE');
 
+  if (this.current.type === 'LBRACE') {
+    throw new ParseError(
+      "Expected condition after 'race'",
+      this.current,
+      this.source,
+      "Race clauses require a condition before the block"
+    );
+  }
+
   const test = this.expression();
 
+  if (this.current.type !== 'LBRACE') {
+    throw new ParseError(
+      "Expected '{' after race condition",
+      this.current,
+      this.source,
+      "Race clauses must use a block: race condition { ... }"
+    );
+  }
+
   const consequent = this.block();
 
   return {
@@ -11710,11 +12101,26 @@ raceClause() {
   };
 }
 
+
 sldeployStatement() {
   const t = this.current; 
   this.eat('SLDEPLOY');
+
+  if (this.current.type === 'SEMICOLON') {
+    throw new ParseError(
+      "Expected expression after 'sldeploy'",
+      this.current,
+      this.source,
+      "sldeploy requires a value or expression to deploy"
+    );
+  }
+
   const expr = this.expression();
-  if (this.current.type === 'SEMICOLON') this.eat('SEMICOLON');
+
+  if (this.current.type === 'SEMICOLON') {
+    this.eat('SEMICOLON');
+  }
+
   return { 
     type: 'SldeployStatement', 
     expr, 
@@ -11727,11 +12133,31 @@ doTrackStatement() {
   const t = this.current;
   this.eat('DO');
 
+  if (this.current.type !== 'LBRACE') {
+    throw new ParseError(
+      "Expected '{' after 'do'",
+      this.current,
+      this.source,
+      "The 'do' statement must be followed by a block"
+    );
+  }
+
   const body = this.block();
 
   let handler = null;
+
   if (this.current.type === 'TRACK') {
     this.eat('TRACK');
+
+    if (this.current.type !== 'LBRACE') {
+      throw new ParseError(
+        "Expected '{' after 'track'",
+        this.current,
+        this.source,
+        "Track handlers must be blocks"
+      );
+    }
+
     handler = this.block();
   }
 
@@ -11747,17 +12173,49 @@ doTrackStatement() {
 defineStatement() {
   const t = this.current; 
   this.eat('DEFINE');
+
+  if (this.current.type !== 'IDENTIFIER') {
+    throw new ParseError(
+      "Expected identifier after 'define'",
+      this.current,
+      this.source,
+      "Definitions must be followed by a name, e.g. define PI = 3.14"
+    );
+  }
+
   const idToken = this.current; 
   const id = idToken.value;
   this.eat('IDENTIFIER');
 
   let expr = null;
+
+  if (this.current.type === 'EQEQ') {
+    throw new ParseError(
+      "Invalid '==' in define statement",
+      this.current,
+      this.source,
+      "Did you mean '=' to assign a value?"
+    );
+  }
+
   if (this.current.type === 'EQUAL') {
     this.eat('EQUAL');
+
+    if (this.current.type === 'SEMICOLON') {
+      throw new ParseError(
+        "Expected expression after '='",
+        this.current,
+        this.source,
+        "Definitions require a value, e.g. define X = 10"
+      );
+    }
+
     expr = this.expression();
   }
 
-  if (this.current.type === 'SEMICOLON') this.eat('SEMICOLON');
+  if (this.current.type === 'SEMICOLON') {
+    this.eat('SEMICOLON');
+  }
 
   return { 
     type: 'DefineStatement', 
@@ -11770,30 +12228,80 @@ defineStatement() {
 
 asyncFuncDeclaration() {
   const t = this.current;
+
+  if (this.current.type !== 'IDENTIFIER') {
+    throw new ParseError(
+      "Expected function name after 'async func'",
+      this.current,
+      this.source,
+      "Async functions must have a name"
+    );
+  }
+
   const name = this.current.value;
   this.eat('IDENTIFIER');
 
   let params = [];
+
   if (this.current.type === 'LPAREN') {
     this.eat('LPAREN');
+
     if (this.current.type !== 'RPAREN') {
+      if (this.current.type !== 'IDENTIFIER') {
+        throw new ParseError(
+          "Expected parameter name",
+          this.current,
+          this.source,
+          "Function parameters must be identifiers"
+        );
+      }
+
       params.push(this.current.value);
       this.eat('IDENTIFIER');
+
       while (this.current.type === 'COMMA') {
         this.eat('COMMA');
+
+        if (this.current.type !== 'IDENTIFIER') {
+          throw new ParseError(
+            "Expected parameter name after ','",
+            this.current,
+            this.source,
+            "Separate parameters with commas"
+          );
+        }
+
         params.push(this.current.value);
         this.eat('IDENTIFIER');
       }
     }
-    this.eat('RPAREN');
-  } else {
-    if (this.current.type === 'IDENTIFIER') {
-      params.push(this.current.value);
-      this.eat('IDENTIFIER');
+
+    if (this.current.type !== 'RPAREN') {
+      throw new ParseError(
+        "Expected ')' after function parameters",
+        this.current,
+        this.source,
+        "Did you forget to close the parameter list?"
+      );
     }
+
+    this.eat('RPAREN');
+  } else if (this.current.type === 'IDENTIFIER') {
+    params.push(this.current.value);
+    this.eat('IDENTIFIER');
+  }
+
+  if (this.current.type !== 'LBRACE') {
+    throw new ParseError(
+      "Expected '{' to start function body",
+      this.current,
+      this.source,
+      "Function declarations require a block body"
+    );
   }
 
   const body = this.block();
+
   return { 
     type: 'FunctionDeclaration', 
     name, 
@@ -11804,32 +12312,62 @@ asyncFuncDeclaration() {
     column: t.column
   };
 }
-
 ifStatement() {
   const t = this.current;
   this.eat('IF');
 
   let test;
+
   if (this.current.type === 'LPAREN') {
     this.eat('LPAREN');
+
+    if (this.current.type === 'RPAREN') {
+      throw new ParseError(
+        "Missing condition in if statement",
+        this.current,
+        this.source,
+        "If statements require a condition"
+      );
+    }
+
     test = this.expression();
+
+    if (this.current.type !== 'RPAREN') {
+      throw new ParseError(
+        "Expected ')' after if condition",
+        this.current,
+        this.source,
+        "Did you forget to close the condition?"
+      );
+    }
+
     this.eat('RPAREN');
   } else {
     test = this.expression();
   }
 
+  if (this.current.type === 'EQUAL') {
+    throw new ParseError(
+      "Invalid assignment in if condition",
+      this.current,
+      this.source,
+      "Did you mean '==' for comparison?"
+    );
+  }
+
   const consequent = this.statementOrBlock();
 
   let alternate = null;
+
   if (this.current.type === 'ELSE') {
-  this.eat('ELSE');
-  if (this.current.type === 'IF') {
-    alternate = this.ifStatement();
-  } else {
-    alternate = this.statementOrBlock();
-  }
-}
+    this.eat('ELSE');
 
+    if (this.current.type === 'IF') {
+      alternate = this.ifStatement();
+    } else {
+      alternate = this.statementOrBlock();
+    }
+  }
 
   return { 
     type: 'IfStatement', 
@@ -11840,6 +12378,7 @@ ifStatement() {
     column: t.column 
   };
 }
+
 parseExpressionOnly() {
   return this.expression();
 }
@@ -11852,13 +12391,30 @@ whileStatement() {
 
   if (this.current.type === 'LPAREN') {
     this.eat('LPAREN');
-    test = this.expression();
-    this.eat('RPAREN');
+
+    if (this.current.type === 'RPAREN') {
+      throw new ParseError(
+        "Missing condition in while statement",
+        this.current,
+        this.source,
+        "While loops require a condition"
+      );
+    }
+
+    test = this.expression();
+
+    if (this.current.type !== 'RPAREN') {
+      throw new ParseError(
+        "Expected ')' after while condition",
+        this.current,
+        this.source,
+        "Did you forget to close the condition?"
+      );
+    }
+
+    this.eat('RPAREN');
   } 
   else {
-    const startPos = this.pos;
-    const startToken = this.current;
-
     const exprTokens = [];
     let braceFound = false;
     let depth = 0;
@@ -11878,7 +12434,8 @@ whileStatement() {
       throw new ParseError(
         "Expected '{' after while condition",
         this.current,
-        this.source
+        this.source,
+        "While loops must be followed by a block"
       );
     }
 
@@ -11887,7 +12444,17 @@ whileStatement() {
     test = exprParser.parseExpressionOnly(); 
   }
 
+  if (this.current.type !== 'LBRACE') {
+    throw new ParseError(
+      "Expected '{' to start while loop body",
+      this.current,
+      this.source,
+      "While loop bodies must be enclosed in braces"
+    );
+  }
+
   const body = this.block();
+
   return { 
     type: 'WhileStatement', 
     test, 
@@ -11897,21 +12464,67 @@ whileStatement() {
   };
 }
 
-
 importStatement() {
   const t = this.current; 
   this.eat('IMPORT');
 
   let specifiers = [];
+
   if (this.current.type === 'STAR') {
     this.eat('STAR');
+
+    if (this.current.type !== 'AS') {
+      throw new ParseError(
+        "Expected 'as' after '*' in import",
+        this.current,
+        this.source,
+        "Namespace imports require 'as', e.g. import * as name from 'mod'"
+      );
+    }
+
     this.eat('AS');
+
+    if (this.current.type !== 'IDENTIFIER') {
+      throw new ParseError(
+        "Expected identifier after 'as'",
+        this.current,
+        this.source,
+        "The namespace must have a local name"
+      );
+    }
+
     const name = this.current.value;
     this.eat('IDENTIFIER');
-    specifiers.push({ type: 'NamespaceImport', local: name, line: t.line, column: t.column });
+
+    specifiers.push({
+      type: 'NamespaceImport',
+      local: name,
+      line: t.line,
+      column: t.column
+    });
+
   } else if (this.current.type === 'LBRACE') {
     this.eat('LBRACE');
+
+    if (this.current.type === 'RBRACE') {
+      throw new ParseError(
+        "Empty import specifier list",
+        this.current,
+        this.source,
+        "Specify at least one name inside '{ }'"
+      );
+    }
+
     while (this.current.type !== 'RBRACE') {
+      if (this.current.type !== 'IDENTIFIER') {
+        throw new ParseError(
+          "Expected identifier in import specifier",
+          this.current,
+          this.source,
+          "Import names must be identifiers"
+        );
+      }
+
       const importedName = this.current.value;
       const importedLine = this.current.line;
       const importedColumn = this.current.column;
@@ -11920,27 +12533,77 @@ importStatement() {
       let localName = importedName;
       if (this.current.type === 'AS') {
         this.eat('AS');
+
+        if (this.current.type !== 'IDENTIFIER') {
+          throw new ParseError(
+            "Expected identifier after 'as'",
+            this.current,
+            this.source,
+            "Aliases must be valid identifiers"
+          );
+        }
+
         localName = this.current.value;
         this.eat('IDENTIFIER');
       }
 
-      specifiers.push({ type: 'NamedImport', imported: importedName, local: localName, line: importedLine, column: importedColumn });
+      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, line: localLine, column: localColumn });
+
+    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}`);
+    throw new ParseError(
+      "Invalid import syntax",
+      this.current,
+      this.source,
+      "Use import name, import { a }, or import * as name"
+    );
+  }
+
+  if (this.current.type !== 'FROM') {
+    throw new ParseError(
+      "Expected 'from' in import statement",
+      this.current,
+      this.source,
+      "Imports must specify a source module"
+    );
   }
 
   this.eat('FROM');
+
   const pathToken = this.current;
-  if (pathToken.type !== 'STRING') throw new Error(`Expected string after FROM at line ${this.current.line}, column ${this.current.column}`);
+
+  if (pathToken.type !== 'STRING') {
+    throw new ParseError(
+      "Expected string after 'from'",
+      pathToken,
+      this.source,
+      "Module paths must be strings"
+    );
+  }
+
   this.eat('STRING');
 
   if (this.current.type === 'SEMICOLON') this.eat('SEMICOLON');
@@ -11953,14 +12616,14 @@ importStatement() {
     column: t.column 
   };
 }
-
 forStatement() {
-  const t = this.current; // FOR token
+  const t = this.current;
   this.eat('FOR');
 
-  if ((this.current.type === 'LET' && this.peekType() === 'IDENTIFIER' && this.peekType(2) === 'IN') ||
-      (this.current.type === 'IDENTIFIER' && this.peekType() === 'IN')) {
-
+  if (
+    (this.current.type === 'LET' && this.peekType() === 'IDENTIFIER' && this.peekType(2) === 'IN') ||
+    (this.current.type === 'IDENTIFIER' && this.peekType() === 'IN')
+  ) {
     let variable;
     let variableLine, variableColumn;
     let iterable;
@@ -11969,22 +12632,45 @@ forStatement() {
     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');
-      iterable = this.expression();
+    }
+
+    if (this.current.type !== 'IDENTIFIER') {
+      throw new ParseError(
+        "Expected identifier in for-in loop",
+        this.current,
+        this.source,
+        "for-in loops require a loop variable"
+      );
+    }
+
+    variableLine = this.current.line;
+    variableColumn = this.current.column;
+    variable = this.current.value;
+    this.eat('IDENTIFIER');
+
+    if (this.current.type !== 'IN') {
+      throw new ParseError(
+        "Expected 'in' in for-in loop",
+        this.current,
+        this.source,
+        "Use: for item in iterable { ... }"
+      );
+    }
+
+    this.eat('IN');
+    iterable = this.expression();
+
+    if (this.current.type !== 'LBRACE') {
+      throw new ParseError(
+        "Expected '{' after for-in iterable",
+        this.current,
+        this.source,
+        "For-in loops require a block body"
+      );
     }
 
     const body = this.block();
+
     return { 
       type: 'ForInStatement', 
       variable, 
@@ -12006,25 +12692,53 @@ forStatement() {
     this.eat('LPAREN');
 
     if (this.current.type !== 'SEMICOLON') {
-      init = this.current.type === 'LET' ? this.varDeclaration() : this.expressionStatement();
+      init = this.current.type === 'LET'
+        ? this.varDeclaration()
+        : this.expressionStatement();
     } else {
       this.eat('SEMICOLON');
     }
 
-    if (this.current.type !== 'SEMICOLON') test = this.expression();
+    if (this.current.type !== 'SEMICOLON') {
+      test = this.expression();
+    }
+
     this.eat('SEMICOLON');
 
-    if (this.current.type !== 'RPAREN') update = this.expression();
+    if (this.current.type !== 'RPAREN') {
+      update = this.expression();
+    }
+
+    if (this.current.type !== 'RPAREN') {
+      throw new ParseError(
+        "Expected ')' after for loop clauses",
+        this.current,
+        this.source,
+        "Did you forget to close the for loop header?"
+      );
+    }
+
     this.eat('RPAREN');
   } else {
-    init = this.expression();
-    if (this.current.type === 'IN') {
-      this.eat('IN');
-      test = this.expression(); // iterable
-    }
+    throw new ParseError(
+      "Expected '(' after 'for'",
+      this.current,
+      this.source,
+      "Classic for loops require parentheses"
+    );
+  }
+
+  if (this.current.type !== 'LBRACE') {
+    throw new ParseError(
+      "Expected '{' to start for loop body",
+      this.current,
+      this.source,
+      "For loops require a block body"
+    );
   }
 
   const body = this.block();
+
   return { 
     type: 'ForStatement', 
     init, 
@@ -12049,41 +12763,111 @@ continueStatement() {
   if (this.current.type === 'SEMICOLON') this.advance();
   return { type: 'ContinueStatement', line: t.line, column: t.column };
 }
-
 funcDeclaration() {
   const t = this.current; 
   this.eat('FUNC');
+
+  if (this.current.type !== 'IDENTIFIER') {
+    throw new ParseError(
+      "Expected function name after 'func'",
+      this.current,
+      this.source,
+      "Functions must have a name, e.g. func add(a, b) { ... }"
+    );
+  }
+
   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') {
-      const paramToken = this.current;
-      params.push({ name: paramToken.value, line: paramToken.line, column: paramToken.column });
+      if (this.current.type !== 'IDENTIFIER') {
+        throw new ParseError(
+          "Expected parameter name",
+          this.current,
+          this.source,
+          "Function parameters must be identifiers"
+        );
+      }
+
+      let 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');
-        const paramToken2 = this.current;
-        params.push({ name: paramToken2.value, line: paramToken2.line, column: paramToken2.column });
+
+        if (this.current.type !== 'IDENTIFIER') {
+          throw new ParseError(
+            "Expected parameter name after ','",
+            this.current,
+            this.source,
+            "Each parameter must be an identifier"
+          );
+        }
+
+        paramToken = this.current;
+        params.push({
+          name: paramToken.value,
+          line: paramToken.line,
+          column: paramToken.column
+        });
         this.eat('IDENTIFIER');
       }
     }
-    this.eat('RPAREN');
-  } else {
-    if (this.current.type === 'IDENTIFIER') {
-      const paramToken = this.current;
-      params.push({ name: paramToken.value, line: paramToken.line, column: paramToken.column });
-      this.eat('IDENTIFIER');
+
+    if (this.current.type !== 'RPAREN') {
+      throw new ParseError(
+        "Expected ')' after function parameters",
+        this.current,
+        this.source,
+        "Did you forget to close the parameter list?"
+      );
     }
+
+    this.eat('RPAREN');
+  } 
+  else if (this.current.type === 'IDENTIFIER') {
+    const paramToken = this.current;
+    params.push({
+      name: paramToken.value,
+      line: paramToken.line,
+      column: paramToken.column
+    });
+    this.eat('IDENTIFIER');
+  }
+
+  if (this.current.type !== 'LBRACE') {
+    throw new ParseError(
+      "Expected '{' to start function body",
+      this.current,
+      this.source,
+      "Functions must have a block body"
+    );
   }
 
   const body = this.block();
-  return { type: 'FunctionDeclaration', name, params, body, line: t.line, column: t.column };
+
+  return {
+    type: 'FunctionDeclaration',
+    name,
+    params,
+    body,
+    line: t.line,
+    column: t.column
+  };
 }
 
+
 returnStatement() {
   const t = this.current; // RETURN token
   this.eat('RETURN');
@@ -12103,18 +12887,35 @@ statementOrBlock() {
   }
   return this.statement();
 }
-
 block() {
   const t = this.current; // LBRACE token
   this.eat('LBRACE');
+
   const body = [];
+
   while (this.current.type !== 'RBRACE') {
+    if (this.current.type === 'EOF') {
+      throw new ParseError(
+        "Unterminated block",
+        this.current,
+        this.source,
+        "Did you forget to close the block with '}'?"
+      );
+    }
     body.push(this.statement());
   }
+
   this.eat('RBRACE');
-  return { type: 'BlockStatement', body, line: t.line, column: t.column };
+
+  return {
+    type: 'BlockStatement',
+    body,
+    line: t.line,
+    column: t.column
+  };
 }
 
+
 expressionStatement() {
   const exprToken = this.current;
   const expr = this.expression();
@@ -12125,7 +12926,6 @@ expressionStatement() {
 expression() {
   return this.assignment();
 }
-
 assignment() {
   const node = this.ternary();
   const compoundOps = ['PLUSEQ', 'MINUSEQ', 'STAREQ', 'SLASHEQ', 'MODEQ'];
@@ -12136,29 +12936,76 @@ assignment() {
     const op = t.type;
     this.eat(op);
     const right = this.assignment();
-    return { type: 'CompoundAssignment', operator: op, left: node, right, line: t.line, column: t.column };
+
+    return {
+      type: 'CompoundAssignment',
+      operator: op,
+      left: node,
+      right,
+      line: t.line,
+      column: t.column
+    };
+  }
+
+  if (t.type === 'EQEQ') {
+    throw new ParseError(
+      "Unexpected '==' in assignment",
+      t,
+      this.source,
+      "Did you mean '=' to assign a value?"
+    );
   }
 
   if (t.type === 'EQUAL') {
     this.eat('EQUAL');
     const right = this.assignment();
-    return { type: 'AssignmentExpression', left: node, right, line: t.line, column: t.column };
+
+    return {
+      type: 'AssignmentExpression',
+      left: node,
+      right,
+      line: t.line,
+      column: t.column
+    };
   }
 
   return node;
 }
+
 ternary() {
   let node = this.nullishCoalescing();
+
   while (this.current.type === 'QUESTION') {
     const t = this.current;
     this.eat('QUESTION');
-    const consequent = this.expression(); 
+
+    const consequent = this.expression();
+
+    if (this.current.type !== 'COLON') {
+      throw new ParseError(
+        "Expected ':' in conditional expression",
+        this.current,
+        this.source,
+        "Ternary expressions must follow the form: condition ? a : b"
+      );
+    }
+
     this.eat('COLON');
-    const alternate = this.expression();   
-    node = { type: 'ConditionalExpression', test: node, consequent, alternate, line: t.line, column: t.column };
+    const alternate = this.expression();
+
+    node = {
+      type: 'ConditionalExpression',
+      test: node,
+      consequent,
+      alternate,
+      line: t.line,
+      column: t.column
+    };
   }
+
   return node;
 }
+
 nullishCoalescing() {
   let node = this.logicalOr(); 
   while (this.current.type === 'NULLISH_COALESCING') {
@@ -12241,6 +13088,16 @@ unary() {
   if (['NOT', 'MINUS', 'PLUS'].includes(t.type)) {
     const op = t.type;
     this.eat(op);
+
+    if (this.current.type === 'EOF') {
+      throw new ParseError(
+        "Missing operand for unary operator",
+        this.current,
+        this.source,
+        "Unary operators must be followed by an expression"
+      );
+    }
+
     return {
       type: 'UnaryExpression',
       operator: op,
@@ -12253,7 +13110,18 @@ unary() {
   if (t.type === 'PLUSPLUS' || t.type === 'MINUSMINUS') {
     const op = t.type;
     this.eat(op);
+
     const argument = this.unary();
+
+    if (!argument || !argument.type) {
+      throw new ParseError(
+        "Invalid operand for update operator",
+        t,
+        this.source,
+        "Increment and decrement operators must apply to a variable"
+      );
+    }
+
     return {
       type: 'UpdateExpression',
       operator: op,
@@ -12266,9 +13134,9 @@ unary() {
 
   return this.postfix();
 }
-
 postfix() {
   let node = this.primary();
+
   while (true) {
     const t = this.current;
 
@@ -12276,9 +13144,27 @@ postfix() {
       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, line: startLine, column: startCol };
+
+      if (this.current.type !== 'RBRACKET') {
+        throw new ParseError(
+          "Expected ']' after index expression",
+          this.current,
+          this.source,
+          "Index access must be closed, e.g. arr[0]"
+        );
+      }
+
+      this.eat('RBRACKET');
+
+      node = {
+        type: 'IndexExpression',
+        object: node,
+        indexer: index,
+        line: startLine,
+        column: startCol
+      };
       continue;
     }
 
@@ -12286,13 +13172,46 @@ postfix() {
       const startLine = t.line;
       const startCol = t.column;
       this.eat('LPAREN');
+
       const args = [];
-      while (this.current.type !== 'RPAREN' && this.current.type !== 'EOF') {
+
+      while (this.current.type !== 'RPAREN') {
+        if (this.current.type === 'EOF') {
+          throw new ParseError(
+            "Unterminated function call",
+            this.current,
+            this.source,
+            "Did you forget to close ')'?"
+          );
+        }
+
         args.push(this.expression());
-        if (this.current.type === 'COMMA') this.eat('COMMA');
+
+        if (this.current.type === 'COMMA') {
+          this.eat('COMMA');
+        } else {
+          break;
+        }
       }
-      if (this.current.type === 'RPAREN') this.eat('RPAREN');
-      node = { type: 'CallExpression', callee: node, arguments: args, line: startLine, column: startCol };
+
+      if (this.current.type !== 'RPAREN') {
+        throw new ParseError(
+          "Expected ')' after function arguments",
+          this.current,
+          this.source,
+          "Function calls must be closed with ')'"
+        );
+      }
+
+      this.eat('RPAREN');
+
+      node = {
+        type: 'CallExpression',
+        callee: node,
+        arguments: args,
+        line: startLine,
+        column: startCol
+      };
       continue;
     }
 
@@ -12300,21 +13219,46 @@ postfix() {
       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, line: startLine, column: startCol };
+
+      if (this.current.type !== 'IDENTIFIER') {
+        throw new ParseError(
+          "Expected property name after '.'",
+          this.current,
+          this.source,
+          "Member access requires a property name, e.g. obj.value"
+        );
+      }
+
+      const property = this.current.value;
+      this.eat('IDENTIFIER');
+
+      node = {
+        type: 'MemberExpression',
+        object: node,
+        property,
+        line: startLine,
+        column: startCol
+      };
       continue;
     }
 
     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 };
+
+      node = {
+        type: 'UpdateExpression',
+        operator: t.type,
+        argument: node,
+        prefix: false,
+        line: t.line,
+        column: t.column
+      };
       continue;
     }
 
-   
     break;
   }
+
   return node;
 }
 
@@ -12326,10 +13270,19 @@ arrowFunction(params) {
   let isBlock = false;
 
   if (this.current.type === 'LBRACE') {
-    body = this.block();      
+    body = this.block();
     isBlock = true;
-  } else {
-    body = this.expression(); 
+  } 
+  else if (this.current.type === 'EOF') {
+    throw new ParseError(
+      "Missing arrow function body",
+      this.current,
+      this.source,
+      "Arrow functions require a body, e.g. x => x * 2"
+    );
+  } 
+  else {
+    body = this.expression();
   }
 
   const startLine = params.length > 0 ? params[0].line : t.line;
@@ -12345,75 +13298,116 @@ arrowFunction(params) {
   };
 }
 
-
-  primary() {
+primary() {
   const t = this.current;
 
-  if (t.type === 'NUMBER') { 
-    this.eat('NUMBER'); 
-    return { type: 'Literal', value: t.value, line: t.line, column: t.column }; 
+  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 === '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 === '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 === '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 === '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(); 
+    const argument = this.expression();
     return { type: 'AwaitExpression', argument, line: t.line, column: t.column };
   }
 
   if (t.type === 'NEW') {
     this.eat('NEW');
     const callee = this.primary();
+
+    if (this.current.type !== 'LPAREN') {
+      throw new ParseError(
+        "Expected '(' after 'new'",
+        this.current,
+        this.source,
+        "Use 'new ClassName(...)'"
+      );
+    }
+
     this.eat('LPAREN');
     const args = [];
     if (this.current.type !== 'RPAREN') {
       args.push(this.expression());
       while (this.current.type === 'COMMA') {
         this.eat('COMMA');
-        if (this.current.type !== 'RPAREN') args.push(this.expression());
+        if (this.current.type === 'RPAREN') break;
+        args.push(this.expression());
       }
     }
+
+    if (this.current.type !== 'RPAREN') {
+      throw new ParseError(
+        "Expected ')' to close arguments for 'new'",
+        this.current,
+        this.source
+      );
+    }
+
     this.eat('RPAREN');
+
     return { type: 'NewExpression', callee, arguments: args, line: t.line, column: t.column };
   }
 
+  // ---- ask(...) function call ----
   if (t.type === 'ASK') {
     this.eat('ASK');
+
+    if (this.current.type !== 'LPAREN') {
+      throw new ParseError(
+        "Expected '(' after 'ask'",
+        this.current,
+        this.source
+      );
+    }
+
     this.eat('LPAREN');
     const args = [];
     if (this.current.type !== 'RPAREN') {
       args.push(this.expression());
       while (this.current.type === 'COMMA') {
         this.eat('COMMA');
-        if (this.current.type !== 'RPAREN') args.push(this.expression());
+        if (this.current.type === 'RPAREN') break;
+        args.push(this.expression());
       }
     }
+
+    if (this.current.type !== 'RPAREN') {
+      throw new ParseError(
+        "Expected ')' after arguments to 'ask'",
+        this.current,
+        this.source
+      );
+    }
+
     this.eat('RPAREN');
-    return { 
-      type: 'CallExpression', 
-      callee: { type: 'Identifier', name: 'ask', line: t.line, column: t.column }, 
-      arguments: args, 
-      line: t.line, 
-      column: t.column 
+
+    return {
+      type: 'CallExpression',
+      callee: { type: 'Identifier', name: 'ask', line: t.line, column: t.column },
+      arguments: args,
+      line: t.line,
+      column: t.column
     };
   }
 
@@ -12432,89 +13426,120 @@ arrowFunction(params) {
     const startLine = t.line;
     const startCol = t.column;
     this.eat('LPAREN');
-    const elements = [];
 
+    const elements = [];
     if (this.current.type !== 'RPAREN') {
       elements.push(this.expression());
       while (this.current.type === 'COMMA') {
         this.eat('COMMA');
-        if (this.current.type !== 'RPAREN') elements.push(this.expression());
+        if (this.current.type === 'RPAREN') break;
+        elements.push(this.expression());
       }
     }
 
+    if (this.current.type !== 'RPAREN') {
+      throw new ParseError(
+        "Expected ')' after expression",
+        this.current,
+        this.source
+      );
+    }
+
     this.eat('RPAREN');
 
-    if (this.current.type === 'ARROW') return this.arrowFunction(elements);
+    if (this.current.type === 'ARROW') {
+      return this.arrowFunction(elements);
+    }
 
-    return elements.length === 1 ? elements[0] : { type: 'ArrayExpression', elements, line: startLine, column: startCol };
+    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') {
       elements.push(this.expression());
       while (this.current.type === 'COMMA') {
         this.eat('COMMA');
-        if (this.current.type !== 'RBRACKET') elements.push(this.expression());
+        if (this.current.type === 'RBRACKET') break;
+        elements.push(this.expression());
       }
     }
+
+    if (this.current.type !== 'RBRACKET') {
+      throw new ParseError(
+        "Expected ']' after array elements",
+        this.current,
+        this.source
+      );
+    }
+
     this.eat('RBRACKET');
+
     return { type: 'ArrayExpression', elements, line: startLine, column: startCol };
   }
 
   if (t.type === 'LBRACE') {
-  const startLine = t.line;
-  const startCol = t.column;
-  this.eat('LBRACE');
+    const startLine = t.line;
+    const startCol = t.column;
+    this.eat('LBRACE');
 
-  const props = [];
+    const props = [];
 
-  while (this.current.type !== 'RBRACE') {
-    let key;
+    while (this.current.type !== 'RBRACE') {
+      if (this.current.type === 'EOF') {
+        throw new ParseError(
+          "Unterminated object literal",
+          this.current,
+          this.source,
+          "Did you forget to close '}'?"
+        );
+      }
 
-    if (this.current.type === 'IDENTIFIER') {
-      const k = this.current;
-      this.eat('IDENTIFIER');
-      key = {
-        type: 'Literal',
-        value: k.value,
-        line: k.line,
-        column: k.column
-      };
-    }
-    else if (this.current.type === 'STRING') {
-      const k = this.current;
-      this.eat('STRING');
-      key = {
-        type: 'Literal',
-        value: k.value,
-        line: k.line,
-        column: k.column
-      };
-    }
-    else {
-      throw new ParseError(
-        'Invalid object key',
-        this.current,
-        this.source
-      );
-    }
+      let key;
 
-    this.eat('COLON');
-    const value = this.expression();
+      if (this.current.type === 'IDENTIFIER') {
+        const k = this.current;
+        this.eat('IDENTIFIER');
+        key = { type: 'Literal', value: k.value, line: k.line, column: k.column };
+      } 
+      else if (this.current.type === 'STRING') {
+        const k = this.current;
+        this.eat('STRING');
+        key = { type: 'Literal', value: k.value, line: k.line, column: k.column };
+      } 
+      else {
+        throw new ParseError(
+          'Invalid object key',
+          this.current,
+          this.source,
+          "Object keys must be identifiers or strings"
+        );
+      }
 
-    props.push({ key, value });
+      if (this.current.type !== 'COLON') {
+        throw new ParseError(
+          "Expected ':' after object key",
+          this.current,
+          this.source
+        );
+      }
 
-    if (this.current.type === 'COMMA') this.eat('COMMA');
-  }
+      this.eat('COLON');
+      const value = this.expression();
+      props.push({ key, value });
 
-  this.eat('RBRACE');
-  return { type: 'ObjectExpression', props, line: startLine, column: startCol };
-}
+      if (this.current.type === 'COMMA') this.eat('COMMA');
+    }
 
+    this.eat('RBRACE');
+    return { type: 'ObjectExpression', props, line: startLine, column: startCol };
+  }
 
   throw new ParseError(
     `Unexpected token '${t.type}'`,
@@ -12523,7 +13548,6 @@ arrowFunction(params) {
   );
 }
 
-
 }
 
 module.exports = Parser;
@@ -12706,7 +13730,7 @@ const Lexer = __nccwpck_require__(211);
 const Parser = __nccwpck_require__(222);
 const Evaluator = __nccwpck_require__(112);
 
-const VERSION = '1.1.11';
+const VERSION = '1.1.13';
 
 const COLOR = {
     reset: '\x1b[0m',