starlight-cli 1.1.0 → 1.1.2

package/dist/index.js

@@ -1388,13 +1388,25 @@ class Environment {
     return false;
   }
 
-  get(name, node, source) {
+ get(name, node, source) {
   if (name in this.store) return this.store[name];
   if (this.parent) return this.parent.get(name, node, source);
-  throw new RuntimeError(`Undefined variable: ${name}`, node, source);
+
+  // Only suggest for top-level variable/function names
+  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);
 }
 
 
+
   set(name, value) {
     if (name in this.store) { this.store[name] = value; return value; }
     if (this.parent && this.parent.has(name)) { return this.parent.set(name, value); }
@@ -1414,57 +1426,87 @@ class Evaluator {
     this.global = new Environment();
     this.setupBuiltins();
   }
+suggest(name, env) {
+  // Collect all variable/function names from the environment chain
+  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) {
+    // simple edit distance approximation
+    const dist = Math.abs(item.length - name.length) +
+      [...name].filter((c, i) => c !== item[i]).length;
+
+    if (dist < bestScore && dist <= 2) { // max distance 2
+      bestScore = dist;
+      best = item;
+    }
+  }
+
+  return best;
+}
+
 formatValue(value, seen = new Set()) {
-  // Circular reference handling
+  const color = __nccwpck_require__(55);
+
+  // Handle circular references
   if (typeof value === 'object' && value !== null) {
-    if (seen.has(value)) return '[Circular]';
+    if (seen.has(value)) return color.red('[Circular]');
     seen.add(value);
   }
 
   // Python-style null / undefined
-  if (value === null) return 'None';
-  if (value === undefined) return 'undefined';
+  if (value === null) return color.yellow('None');
+  if (value === undefined) return color.yellow('undefined');
 
   const t = typeof value;
 
   // Strings (no quotes)
-  if (t === 'string') return value;
+  if (t === 'string') return color.cyan(value);
 
   // Numbers
-  if (t === 'number') return String(value);
+  if (t === 'number') return color.green(String(value));
 
-  // Booleans (Python-style)
-  if (t === 'boolean') return value ? 'True' : 'False';
+  // Booleans
+  if (t === 'boolean') return color.yellow(value ? 'true' : 'false');
 
   // Native JS functions
   if (t === 'function') {
-    return value.name
-      ? `<function ${value.name}>`
-      : '<function>';
+    return color.magenta(value.name ? `<function ${value.name}>` : '<function>');
   }
 
   // Arrays
   if (Array.isArray(value)) {
-    return '[' + value.map(v => this.formatValue(v, seen)).join(', ') + ']';
+    const items = value.map(v => this.formatValue(v, seen));
+    return color.white('[ ' + items.join(', ') + ' ]');
   }
 
   // Objects (including user-defined functions)
   if (t === 'object') {
-    // Detect user-defined functions (AST-based)
     if (value.params && value.body) {
-      return value.name
-        ? `<function ${value.name}>`
-        : '<function>';
+      return color.magenta(value.name ? `<function ${value.name}>` : '<function>');
     }
 
     const entries = Object.entries(value).map(
-      ([k, v]) => `${k}: ${this.formatValue(v, seen)}`
+      ([k, v]) => color.magenta(`${k}: `) + this.formatValue(v, seen)
     );
-    return '{ ' + entries.join(', ') + ' }';
+    return color.magenta('{ ') + entries.join(color.magenta(', ')) + color.magenta(' }');
   }
 
   // Fallback
-  return String(value);
+  try {
+    return String(value);
+  } catch {
+    return color.red('[Unprintable]');
+  }
 }
 
 
@@ -1795,23 +1837,23 @@ async evalAssignment(node, env) {
   const left = node.left;
 
   if (left.type === 'Identifier') return env.set(left.name, rightVal);
-  if (left.type === 'MemberExpression') {
-  const obj = await this.evaluate(left.object, env);
-  if (obj == null) throw new RuntimeError('Cannot assign to null or undefined', node, this.source);
-  obj[left.property] = rightVal;
-  return rightVal;
-}
-if (left.type === 'IndexExpression') {
-  const obj = await this.evaluate(left.object, env);
-  const idx = await this.evaluate(left.indexer, env);
-  if (obj == null) throw new RuntimeError('Cannot assign to null or undefined', node, this.source);
-  obj[idx] = rightVal;
-  return rightVal;
-}
 
+  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;
+  }
 
- throw new RuntimeError('Invalid assignment target', node, this.source);
+  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);
 }
 
 async evalCompoundAssignment(node, env) {
@@ -1819,13 +1861,13 @@ async evalCompoundAssignment(node, env) {
   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);
-  else if (left.type === 'IndexExpression') current = await this.evalIndex(left, env);
+  else if (left.type === 'MemberExpression') current = await this.evalMember(left, env) ?? 0;
+  else if (left.type === 'IndexExpression') current = await this.evalIndex(left, env) ?? 0;
   else throw new RuntimeError('Invalid compound assignment target', node, this.source);
 
-
   const rhs = await this.evaluate(node.right, env);
   let computed;
+
   switch (node.operator) {
     case 'PLUSEQ': computed = current + rhs; break;
     case 'MINUSEQ': computed = current - rhs; break;
@@ -1833,16 +1875,18 @@ async evalCompoundAssignment(node, env) {
     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') 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);
+  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;
 }
 
+
 async evalSldeploy(node, env) {
   const val = await this.evaluate(node.expr, env);
   console.log(this.formatValue(val));
@@ -1850,6 +1894,7 @@ async evalSldeploy(node, env) {
 }
 
 
+
 async evalAsk(node, env) {
   const prompt = await this.evaluate(node.prompt, env);
 
@@ -1956,11 +2001,8 @@ async evalWhile(node, env) {
   }
   return null;
 }
-
 async evalFor(node, env) {
-  // -------------------------------
   // Python-style: for x in iterable (with optional 'let')
-  // -------------------------------
   if (node.type === 'ForInStatement') {
     const iterable = await this.evaluate(node.iterable, env);
 
@@ -1968,11 +2010,10 @@ async evalFor(node, env) {
       throw new RuntimeError('Cannot iterate over non-iterable', node, this.source);
     }
 
-    const loopVar = node.variable; // STRING from parser
-
+    const loopVar = node.variable; // string name of the loop variable
     const createLoopEnv = () => node.letKeyword ? new Environment(env) : env;
 
-    // Arrays
+    // Arrays: iterate over elements
     if (Array.isArray(iterable)) {
       for (const value of iterable) {
         const loopEnv = createLoopEnv();
@@ -1987,7 +2028,7 @@ async evalFor(node, env) {
         }
       }
     }
-    // Objects (keys)
+    // Objects: iterate over keys
     else {
       for (const key of Object.keys(iterable)) {
         const loopEnv = createLoopEnv();
@@ -2006,9 +2047,7 @@ async evalFor(node, env) {
     return null;
   }
 
-  // -------------------------------
-  // C-style for loop
-  // -------------------------------
+  // C-style for loop (classic JS style)
   const local = new Environment(env);
 
   if (node.init) await this.evaluate(node.init, local);
@@ -2030,6 +2069,7 @@ async evalFor(node, env) {
 
   return null;
 }
+
 evalFunctionDeclaration(node, env) {
   if (!node.name || typeof node.name !== 'string') {
     throw new RuntimeError('Function declaration requires a valid name', node, this.source);
@@ -2092,18 +2132,22 @@ 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('Indexing null or undefined', node, this.source);
+  if (obj == null) throw new RuntimeError('Cannot index null or undefined', node, this.source);
 
-  if (Array.isArray(obj) && (idx < 0 || idx >= obj.length)) {
-    throw new RuntimeError('Array index out of bounds', node, this.source);
+  // Array access: return undefined if out of bounds
+  if (Array.isArray(obj)) {
+    if (idx < 0 || idx >= obj.length) return undefined;
+    return obj[idx];
   }
-  if (typeof obj === 'object' && !(idx in obj)) {
-    throw new RuntimeError(`Property '${idx}' does not exist`, node, this.source);
+
+  // Object access: return undefined if property missing
+  if (typeof obj === 'object') {
+    return obj[idx]; // undefined if missing
   }
 
-  return obj[idx];
+  // Fallback for non-object non-array
+  return undefined;
 }
-
 async evalObject(node, env) {
   const out = {};
   for (const p of node.props) {
@@ -2112,19 +2156,22 @@ async evalObject(node, env) {
     }
     const key = await this.evaluate(p.key, env);
     const value = await this.evaluate(p.value, env);
-    out[key] = value;
+    out[key] = value; // dynamic property assignment
   }
   return out;
 }
 
 
+
 async evalMember(node, env) {
   const obj = await this.evaluate(node.object, env);
- if (obj == null) throw new RuntimeError('Member access of null or undefined', node, this.source);
-if (!(node.property in obj)) throw new RuntimeError(`Property '${node.property}' does not exist`, node, this.source);
+
+  if (obj == null) throw new RuntimeError('Member access of null or undefined', node, this.source);
+
   return obj[node.property];
 }
 
+
 async evalUpdate(node, env) {
   const arg = node.argument;
   const getCurrent = async () => {
@@ -2211,22 +2258,7 @@ class Lexer {
   peek() {
     return this.pos + 1 < this.input.length ? this.input[this.pos + 1] : null;
   }
-suggest(word, list) {
-    let best = null;
-    let bestScore = Infinity;
 
-    for (const item of list) {
-      const dist =
-        Math.abs(item.length - word.length) +
-        [...word].filter((c, i) => c !== item[i]).length;
-
-      if (dist < bestScore && dist <= 2) {
-        bestScore = dist;
-        best = item;
-      }
-    }
-    return best;
-  }
   error(msg) {
   throw new LexerError(
     msg,
@@ -2289,27 +2321,12 @@ suggest(word, list) {
       this.advance();
     }
 
-
 if (this.keywords.includes(result)) {
-  return {
-    type: result.toUpperCase(),
-    value: result,
-    line: startLine,
-    column: startCol
-  };
+  return { type: result.toUpperCase(), value: result, line: startLine, column: startCol };
 }
 
-const suggestion = this.suggest(result, this.keywords);
-if (suggestion) {
-  this.error(`Unknown identifier "${result}". Did you mean "${suggestion}"?`);
-}
+return { type: 'IDENTIFIER', value: result, line: startLine, column: startCol };
 
-return {
-  type: 'IDENTIFIER',
-  value: result,
-  line: startLine,
-  column: startCol
-};
 
   }
 
@@ -3296,6 +3313,53 @@ module.exports = require("path");
 "use strict";
 module.exports = require("readline");
 
+/***/ }),
+
+/***/ 55:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __nccwpck_require__) => {
+
+"use strict";
+__nccwpck_require__.r(__webpack_exports__);
+/* harmony export */ __nccwpck_require__.d(__webpack_exports__, {
+/* harmony export */   blue: () => (/* binding */ blue),
+/* harmony export */   brightBlue: () => (/* binding */ brightBlue),
+/* harmony export */   brightCyan: () => (/* binding */ brightCyan),
+/* harmony export */   brightGreen: () => (/* binding */ brightGreen),
+/* harmony export */   brightMagenta: () => (/* binding */ brightMagenta),
+/* harmony export */   brightRed: () => (/* binding */ brightRed),
+/* harmony export */   brightWhite: () => (/* binding */ brightWhite),
+/* harmony export */   brightYellow: () => (/* binding */ brightYellow),
+/* harmony export */   cyan: () => (/* binding */ cyan),
+/* harmony export */   gray: () => (/* binding */ gray),
+/* harmony export */   green: () => (/* binding */ green),
+/* harmony export */   magenta: () => (/* binding */ magenta),
+/* harmony export */   red: () => (/* binding */ red),
+/* harmony export */   white: () => (/* binding */ white),
+/* harmony export */   yellow: () => (/* binding */ yellow)
+/* harmony export */ });
+const RESET = "\x1b[0m";
+
+function wrap(code, text) {
+  return code + String(text) + RESET;
+}
+
+const red = text => wrap("\x1b[31m", text);
+const green = text => wrap("\x1b[32m", text);
+const yellow = text => wrap("\x1b[33m", text);
+const blue = text => wrap("\x1b[34m", text);
+const magenta = text => wrap("\x1b[35m", text);
+const cyan = text => wrap("\x1b[36m", text);
+const white = text => wrap("\x1b[37m", text);
+const gray = text => wrap("\x1b[90m", text);
+const brightRed = text => wrap("\x1b[91m", text);
+const brightGreen = text => wrap("\x1b[92m", text);
+const brightYellow = text => wrap("\x1b[93m", text);
+const brightBlue = text => wrap("\x1b[94m", text);
+const brightMagenta = text => wrap("\x1b[95m", text);
+const brightCyan = text => wrap("\x1b[96m", text);
+const brightWhite = text => wrap("\x1b[97m", text);
+
+
 /***/ })
 
 /******/ 	});
@@ -3331,6 +3395,34 @@ module.exports = require("readline");
 /******/ 	}
 /******/ 	
 /************************************************************************/
+/******/ 	/* webpack/runtime/define property getters */
+/******/ 	(() => {
+/******/ 		// define getter functions for harmony exports
+/******/ 		__nccwpck_require__.d = (exports, definition) => {
+/******/ 			for(var key in definition) {
+/******/ 				if(__nccwpck_require__.o(definition, key) && !__nccwpck_require__.o(exports, key)) {
+/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 				}
+/******/ 			}
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
+/******/ 	(() => {
+/******/ 		__nccwpck_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/make namespace object */
+/******/ 	(() => {
+/******/ 		// define __esModule on exports
+/******/ 		__nccwpck_require__.r = (exports) => {
+/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 			}
+/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 		};
+/******/ 	})();
+/******/ 	
 /******/ 	/* webpack/runtime/compat */
 /******/ 	
 /******/ 	if (typeof __nccwpck_require__ !== 'undefined') __nccwpck_require__.ab = __dirname + "/";
@@ -3348,7 +3440,7 @@ const Lexer = __nccwpck_require__(211);
 const Parser = __nccwpck_require__(222);
 const Evaluator = __nccwpck_require__(112);
 
-const VERSION = '1.1.0';
+const VERSION = '1.1.2';
 
 const COLOR = {
     reset: '\x1b[0m',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "starlight-cli",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "description": "Starlight Programming Language CLI",
   "bin": {
     "starlight": "index.js"
@@ -13,7 +13,8 @@
   "license": "MIT",
   "dependencies": {
     "blessed": "^0.1.81",
-    "readline-sync": "^1.4.10"
+    "readline-sync": "^1.4.10",
+    "starlight-color": "^1.0.4"
   },
   "devDependencies": {
     "@vercel/ncc": "^0.38.4"

package/src/evaluator.js

@@ -45,13 +45,25 @@ class Environment {
     return false;
   }
 
-  get(name, node, source) {
+ get(name, node, source) {
   if (name in this.store) return this.store[name];
   if (this.parent) return this.parent.get(name, node, source);
-  throw new RuntimeError(`Undefined variable: ${name}`, node, source);
+
+  // Only suggest for top-level variable/function names
+  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);
 }
 
 
+
   set(name, value) {
     if (name in this.store) { this.store[name] = value; return value; }
     if (this.parent && this.parent.has(name)) { return this.parent.set(name, value); }
@@ -71,57 +83,87 @@ class Evaluator {
     this.global = new Environment();
     this.setupBuiltins();
   }
+suggest(name, env) {
+  // Collect all variable/function names from the environment chain
+  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) {
+    // simple edit distance approximation
+    const dist = Math.abs(item.length - name.length) +
+      [...name].filter((c, i) => c !== item[i]).length;
+
+    if (dist < bestScore && dist <= 2) { // max distance 2
+      bestScore = dist;
+      best = item;
+    }
+  }
+
+  return best;
+}
+
 formatValue(value, seen = new Set()) {
-  // Circular reference handling
+  const color = require('starlight-color');
+
+  // Handle circular references
   if (typeof value === 'object' && value !== null) {
-    if (seen.has(value)) return '[Circular]';
+    if (seen.has(value)) return color.red('[Circular]');
     seen.add(value);
   }
 
   // Python-style null / undefined
-  if (value === null) return 'None';
-  if (value === undefined) return 'undefined';
+  if (value === null) return color.yellow('None');
+  if (value === undefined) return color.yellow('undefined');
 
   const t = typeof value;
 
   // Strings (no quotes)
-  if (t === 'string') return value;
+  if (t === 'string') return color.cyan(value);
 
   // Numbers
-  if (t === 'number') return String(value);
+  if (t === 'number') return color.green(String(value));
 
-  // Booleans (Python-style)
-  if (t === 'boolean') return value ? 'True' : 'False';
+  // Booleans
+  if (t === 'boolean') return color.yellow(value ? 'true' : 'false');
 
   // Native JS functions
   if (t === 'function') {
-    return value.name
-      ? `<function ${value.name}>`
-      : '<function>';
+    return color.magenta(value.name ? `<function ${value.name}>` : '<function>');
   }
 
   // Arrays
   if (Array.isArray(value)) {
-    return '[' + value.map(v => this.formatValue(v, seen)).join(', ') + ']';
+    const items = value.map(v => this.formatValue(v, seen));
+    return color.white('[ ' + items.join(', ') + ' ]');
   }
 
   // Objects (including user-defined functions)
   if (t === 'object') {
-    // Detect user-defined functions (AST-based)
     if (value.params && value.body) {
-      return value.name
-        ? `<function ${value.name}>`
-        : '<function>';
+      return color.magenta(value.name ? `<function ${value.name}>` : '<function>');
     }
 
     const entries = Object.entries(value).map(
-      ([k, v]) => `${k}: ${this.formatValue(v, seen)}`
+      ([k, v]) => color.magenta(`${k}: `) + this.formatValue(v, seen)
     );
-    return '{ ' + entries.join(', ') + ' }';
+    return color.magenta('{ ') + entries.join(color.magenta(', ')) + color.magenta(' }');
   }
 
   // Fallback
-  return String(value);
+  try {
+    return String(value);
+  } catch {
+    return color.red('[Unprintable]');
+  }
 }
 
 
@@ -452,23 +494,23 @@ async evalAssignment(node, env) {
   const left = node.left;
 
   if (left.type === 'Identifier') return env.set(left.name, rightVal);
-  if (left.type === 'MemberExpression') {
-  const obj = await this.evaluate(left.object, env);
-  if (obj == null) throw new RuntimeError('Cannot assign to null or undefined', node, this.source);
-  obj[left.property] = rightVal;
-  return rightVal;
-}
-if (left.type === 'IndexExpression') {
-  const obj = await this.evaluate(left.object, env);
-  const idx = await this.evaluate(left.indexer, env);
-  if (obj == null) throw new RuntimeError('Cannot assign to null or undefined', node, this.source);
-  obj[idx] = rightVal;
-  return rightVal;
-}
 
+  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;
+  }
 
- throw new RuntimeError('Invalid assignment target', node, this.source);
+  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);
 }
 
 async evalCompoundAssignment(node, env) {
@@ -476,13 +518,13 @@ async evalCompoundAssignment(node, env) {
   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);
-  else if (left.type === 'IndexExpression') current = await this.evalIndex(left, env);
+  else if (left.type === 'MemberExpression') current = await this.evalMember(left, env) ?? 0;
+  else if (left.type === 'IndexExpression') current = await this.evalIndex(left, env) ?? 0;
   else throw new RuntimeError('Invalid compound assignment target', node, this.source);
 
-
   const rhs = await this.evaluate(node.right, env);
   let computed;
+
   switch (node.operator) {
     case 'PLUSEQ': computed = current + rhs; break;
     case 'MINUSEQ': computed = current - rhs; break;
@@ -490,16 +532,18 @@ async evalCompoundAssignment(node, env) {
     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') 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);
+  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;
 }
 
+
 async evalSldeploy(node, env) {
   const val = await this.evaluate(node.expr, env);
   console.log(this.formatValue(val));
@@ -507,6 +551,7 @@ async evalSldeploy(node, env) {
 }
 
 
+
 async evalAsk(node, env) {
   const prompt = await this.evaluate(node.prompt, env);
 
@@ -613,11 +658,8 @@ async evalWhile(node, env) {
   }
   return null;
 }
-
 async evalFor(node, env) {
-  // -------------------------------
   // Python-style: for x in iterable (with optional 'let')
-  // -------------------------------
   if (node.type === 'ForInStatement') {
     const iterable = await this.evaluate(node.iterable, env);
 
@@ -625,11 +667,10 @@ async evalFor(node, env) {
       throw new RuntimeError('Cannot iterate over non-iterable', node, this.source);
     }
 
-    const loopVar = node.variable; // STRING from parser
-
+    const loopVar = node.variable; // string name of the loop variable
     const createLoopEnv = () => node.letKeyword ? new Environment(env) : env;
 
-    // Arrays
+    // Arrays: iterate over elements
     if (Array.isArray(iterable)) {
       for (const value of iterable) {
         const loopEnv = createLoopEnv();
@@ -644,7 +685,7 @@ async evalFor(node, env) {
         }
       }
     }
-    // Objects (keys)
+    // Objects: iterate over keys
     else {
       for (const key of Object.keys(iterable)) {
         const loopEnv = createLoopEnv();
@@ -663,9 +704,7 @@ async evalFor(node, env) {
     return null;
   }
 
-  // -------------------------------
-  // C-style for loop
-  // -------------------------------
+  // C-style for loop (classic JS style)
   const local = new Environment(env);
 
   if (node.init) await this.evaluate(node.init, local);
@@ -687,6 +726,7 @@ async evalFor(node, env) {
 
   return null;
 }
+
 evalFunctionDeclaration(node, env) {
   if (!node.name || typeof node.name !== 'string') {
     throw new RuntimeError('Function declaration requires a valid name', node, this.source);
@@ -749,18 +789,22 @@ 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('Indexing null or undefined', node, this.source);
+  if (obj == null) throw new RuntimeError('Cannot index null or undefined', node, this.source);
 
-  if (Array.isArray(obj) && (idx < 0 || idx >= obj.length)) {
-    throw new RuntimeError('Array index out of bounds', node, this.source);
+  // Array access: return undefined if out of bounds
+  if (Array.isArray(obj)) {
+    if (idx < 0 || idx >= obj.length) return undefined;
+    return obj[idx];
   }
-  if (typeof obj === 'object' && !(idx in obj)) {
-    throw new RuntimeError(`Property '${idx}' does not exist`, node, this.source);
+
+  // Object access: return undefined if property missing
+  if (typeof obj === 'object') {
+    return obj[idx]; // undefined if missing
   }
 
-  return obj[idx];
+  // Fallback for non-object non-array
+  return undefined;
 }
-
 async evalObject(node, env) {
   const out = {};
   for (const p of node.props) {
@@ -769,19 +813,22 @@ async evalObject(node, env) {
     }
     const key = await this.evaluate(p.key, env);
     const value = await this.evaluate(p.value, env);
-    out[key] = value;
+    out[key] = value; // dynamic property assignment
   }
   return out;
 }
 
 
+
 async evalMember(node, env) {
   const obj = await this.evaluate(node.object, env);
- if (obj == null) throw new RuntimeError('Member access of null or undefined', node, this.source);
-if (!(node.property in obj)) throw new RuntimeError(`Property '${node.property}' does not exist`, node, this.source);
+
+  if (obj == null) throw new RuntimeError('Member access of null or undefined', node, this.source);
+
   return obj[node.property];
 }
 
+
 async evalUpdate(node, env) {
   const arg = node.argument;
   const getCurrent = async () => {

package/src/lexer.js

@@ -47,22 +47,7 @@ class Lexer {
   peek() {
     return this.pos + 1 < this.input.length ? this.input[this.pos + 1] : null;
   }
-suggest(word, list) {
-    let best = null;
-    let bestScore = Infinity;
-
-    for (const item of list) {
-      const dist =
-        Math.abs(item.length - word.length) +
-        [...word].filter((c, i) => c !== item[i]).length;
-
-      if (dist < bestScore && dist <= 2) {
-        bestScore = dist;
-        best = item;
-      }
-    }
-    return best;
-  }
+
   error(msg) {
   throw new LexerError(
     msg,
@@ -125,27 +110,12 @@ suggest(word, list) {
       this.advance();
     }
 
-
 if (this.keywords.includes(result)) {
-  return {
-    type: result.toUpperCase(),
-    value: result,
-    line: startLine,
-    column: startCol
-  };
+  return { type: result.toUpperCase(), value: result, line: startLine, column: startCol };
 }
 
-const suggestion = this.suggest(result, this.keywords);
-if (suggestion) {
-  this.error(`Unknown identifier "${result}". Did you mean "${suggestion}"?`);
-}
+return { type: 'IDENTIFIER', value: result, line: startLine, column: startCol };
 
-return {
-  type: 'IDENTIFIER',
-  value: result,
-  line: startLine,
-  column: startCol
-};
 
   }
 

package/src/starlight.js

@@ -9,7 +9,7 @@ const Lexer = require('./lexer');
 const Parser = require('./parser');
 const Evaluator = require('./evaluator');
 
-const VERSION = '1.1.0';
+const VERSION = '1.1.2';
 
 const COLOR = {
     reset: '\x1b[0m',