structscript 1.2.0

package/README.md

@@ -0,0 +1,157 @@
+# StructScript
+
+> A clean, readable scripting language that reads like English.
+
+```
+  ╔══════════════════════════════╗
+  ║  StructScript v1.2.0         ║
+  ║  The structured scripting    ║
+  ║  language for everyone       ║
+  ╚══════════════════════════════╝
+```
+
+## Install
+
+```bash
+npm install -g structscript
+```
+
+## Usage
+
+```bash
+# Run a .ss file
+structscript main.ss
+
+# Interactive REPL
+structscript repl
+
+# Short alias
+ss main.ss
+
+# Check syntax
+structscript check main.ss
+
+# Show execution time
+structscript main.ss --time
+```
+
+## The Language
+
+StructScript uses Python-style indentation and reads like English:
+
+```
+// Variables
+let name = "Alex"
+let age = 24
+const PI = 3.14159
+
+// String interpolation
+say "Hello, {name}! You are {age} years old."
+
+// Conditionals
+if age >= 18:
+  say "Adult"
+else if age >= 13:
+  say "Teenager"
+else:
+  say "Child"
+
+// Loops
+count i from 1 to 10:
+  say i
+
+repeat 3 times:
+  say "Hello!"
+
+for each item in ["a", "b", "c"]:
+  say item
+
+// Functions
+define greet(name, msg = "Hello"):
+  say "{msg}, {name}!"
+
+greet("World")
+greet("Alex", "Welcome")
+
+// Classes
+class Animal:
+  name = "Unknown"
+  sound = "..."
+
+  define init(n, s):
+    set self.name = n
+    set self.sound = s
+
+  define speak():
+    say "{self.name} says {self.sound}!"
+
+let dog = Animal()
+dog.init("Rex", "Woof")
+dog.speak()
+
+// Error handling
+try:
+  error("Something went wrong")
+catch e:
+  say "Caught: {e}"
+finally:
+  say "Done."
+
+// Lists
+let nums = [5, 3, 8, 1, 9]
+say sort(nums)
+say sum(nums)
+say "Max: {max(1, 5, 9)}"
+```
+
+## Features
+
+| Feature             | Syntax                          |
+|---------------------|---------------------------------|
+| Variables           | `let x = 10`                    |
+| Constants           | `const PI = 3.14`               |
+| Reassign            | `set x = 20` / `set x += 5`    |
+| String interpolation| `"Hello, {name}!"`              |
+| Functions           | `define add(a, b): return a+b`  |
+| Classes             | `class Foo:` with `self`        |
+| Structs             | `struct Point: x=0 y=0`        |
+| Conditionals        | `if / else if / else`           |
+| Count loop          | `count i from 1 to 10`          |
+| While loop          | `while x < 100:`                |
+| For each            | `for each item in list:`        |
+| Repeat              | `repeat 5 times:`               |
+| Error handling      | `try / catch / finally`         |
+| Break / continue    | `break` / `continue`            |
+
+## Built-in Functions
+
+**Math:** `abs` `sqrt` `floor` `ceil` `round` `max` `min` `pow` `sin` `cos` `random` `randint`
+
+**Strings:** `upper` `lower` `trim` `length` `contains` `replace` `split` `startsWith` `endsWith` `slice` `format`
+
+**Lists:** `push` `pop` `sort` `reverse` `join` `range` `unique` `sum` `avg` `map` `filter` `reduce` `flatten` `zip`
+
+**Types:** `str` `num` `bool` `type` `isNothing`
+
+## Use as a Library
+
+```js
+const { Interpreter } = require('structscript');
+
+const interp = new Interpreter({
+  output: msg => console.log(msg),
+});
+
+interp.run(`
+  let name = "World"
+  say "Hello, {name}!"
+`);
+```
+
+## Playground
+
+Try StructScript in your browser at [structscript.dev](https://structscript.dev)
+
+## License
+
+MIT

package/bin/structscript.js

@@ -0,0 +1,260 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+const { Interpreter, SSError } = require('../lib/interpreter');
+
+// ── Colours ────────────────────────────────────────────────
+const C = {
+  reset:  '\x1b[0m',
+  bold:   '\x1b[1m',
+  dim:    '\x1b[2m',
+  teal:   '\x1b[36m',
+  lime:   '\x1b[92m',
+  red:    '\x1b[91m',
+  yellow: '\x1b[93m',
+  white:  '\x1b[97m',
+  grey:   '\x1b[90m',
+};
+const t = (color, str) => color + str + C.reset;
+
+// ── Banner ─────────────────────────────────────────────────
+const BANNER = `
+${t(C.teal, '  ╔══════════════════════════════╗')}
+${t(C.teal, '  ║')} ${t(C.bold+C.white, 'Struct')}${t(C.bold+C.lime, 'Script')} ${t(C.grey, 'v1.2.0')}          ${t(C.teal, '║')}
+${t(C.teal, '  ║')} ${t(C.grey, 'The structured scripting')}       ${t(C.teal, '║')}
+${t(C.teal, '  ║')} ${t(C.grey, 'language for everyone')}          ${t(C.teal, '║')}
+${t(C.teal, '  ╚══════════════════════════════╝')}
+`;
+
+// ── Help ───────────────────────────────────────────────────
+const HELP = `
+${BANNER}
+${t(C.bold, 'USAGE')}
+  ${t(C.lime, 'structscript')} ${t(C.teal, '<file.ss>')}           Run a .ss file
+  ${t(C.lime, 'structscript')} ${t(C.teal, 'repl')}                Start interactive REPL
+  ${t(C.lime, 'structscript')} ${t(C.teal, 'run <file.ss>')}       Run a .ss file (explicit)
+  ${t(C.lime, 'structscript')} ${t(C.teal, 'check <file.ss>')}     Check syntax without running
+  ${t(C.lime, 'structscript')} ${t(C.teal, 'version')}             Show version info
+  ${t(C.lime, 'structscript')} ${t(C.teal, 'help')}                Show this help
+
+${t(C.bold, 'OPTIONS')}
+  ${t(C.teal, '--time')}                      Show execution time
+  ${t(C.teal, '--no-color')}                  Disable colour output
+
+${t(C.bold, 'EXAMPLES')}
+  ${t(C.grey, '$ structscript main.ss')}
+  ${t(C.grey, '$ structscript repl')}
+  ${t(C.grey, '$ ss main.ss --time')}
+
+${t(C.bold, 'FILE EXTENSION')}
+  StructScript files use the ${t(C.lime, '.ss')} extension
+`;
+
+// ── Args ───────────────────────────────────────────────────
+const args   = process.argv.slice(2);
+const flags  = new Set(args.filter(a => a.startsWith('--')));
+const params = args.filter(a => !a.startsWith('--'));
+const noColor = flags.has('--no-color');
+const showTime = flags.has('--time');
+
+if (noColor) Object.keys(C).forEach(k => C[k] = '');
+
+const cmd = params[0];
+
+// ── Dispatch ───────────────────────────────────────────────
+if (!cmd || cmd === 'help' || cmd === '--help' || cmd === '-h') {
+  console.log(HELP);
+  process.exit(0);
+}
+
+if (cmd === 'version' || cmd === '--version' || cmd === '-v') {
+  console.log(t(C.bold+C.white, 'Struct') + t(C.bold+C.lime, 'Script') + t(C.grey, ' v1.2.0'));
+  process.exit(0);
+}
+
+if (cmd === 'repl') {
+  startREPL();
+} else if (cmd === 'run') {
+  const file = params[1];
+  if (!file) { console.error(t(C.red, 'Error: specify a file to run')); process.exit(1); }
+  runFile(file);
+} else if (cmd === 'check') {
+  const file = params[1];
+  if (!file) { console.error(t(C.red, 'Error: specify a file to check')); process.exit(1); }
+  checkFile(file);
+} else if (cmd.endsWith('.ss') || cmd.endsWith('.txt')) {
+  runFile(cmd);
+} else {
+  console.error(t(C.red, `Unknown command: "${cmd}"`));
+  console.error(t(C.grey, 'Run `structscript help` for usage.'));
+  process.exit(1);
+}
+
+// ── Run File ───────────────────────────────────────────────
+function runFile(filePath) {
+  const resolved = path.resolve(filePath);
+  if (!fs.existsSync(resolved)) {
+    console.error(t(C.red, `Error: File not found: ${filePath}`));
+    process.exit(1);
+  }
+
+  let source;
+  try {
+    source = fs.readFileSync(resolved, 'utf8');
+  } catch (e) {
+    console.error(t(C.red, `Error reading file: ${e.message}`));
+    process.exit(1);
+  }
+
+  const t0 = Date.now();
+  const interp = new Interpreter({
+    output: msg => console.log(msg),
+    warn:   msg => console.warn(t(C.yellow, '⚠ ' + msg)),
+  });
+
+  try {
+    interp.run(source);
+    if (showTime) {
+      const elapsed = Date.now() - t0;
+      console.error(t(C.grey, `\n⏱  ${elapsed}ms`));
+    }
+  } catch (e) {
+    printError(e, source, filePath);
+    process.exit(1);
+  }
+}
+
+// ── Check Syntax ───────────────────────────────────────────
+function checkFile(filePath) {
+  const resolved = path.resolve(filePath);
+  if (!fs.existsSync(resolved)) {
+    console.error(t(C.red, `Error: File not found: ${filePath}`));
+    process.exit(1);
+  }
+  const source = fs.readFileSync(resolved, 'utf8');
+  // Basic syntax checks
+  const lines = source.split('\n');
+  let ok = true;
+  lines.forEach((line, i) => {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('//')) return;
+    // Check indentation is spaces
+    const indent = line.match(/^(\t+)/);
+    if (indent) {
+      console.warn(t(C.yellow, `  Line ${i+1}: Tab indentation found — use spaces`));
+      ok = false;
+    }
+  });
+  if (ok) {
+    console.log(t(C.lime, `✓ ${path.basename(filePath)} looks good`));
+  } else {
+    console.log(t(C.yellow, `⚠ Issues found in ${path.basename(filePath)}`));
+    process.exit(1);
+  }
+}
+
+// ── Error Printer ──────────────────────────────────────────
+function printError(e, source, filePath) {
+  const lines = source.split('\n');
+  console.error('');
+  console.error(t(C.red+C.bold, '  ● StructScript Error'));
+  console.error(t(C.red, `  ${e.message}`));
+
+  if (e.ssLine !== undefined) {
+    const lineNum = e.ssLine + 1;
+    const snippet = lines[e.ssLine] || '';
+    console.error('');
+    console.error(t(C.grey, `  ${path.basename(filePath)}:${lineNum}`));
+    console.error('');
+    // Context lines
+    for (let i = Math.max(0, e.ssLine - 2); i <= Math.min(lines.length - 1, e.ssLine + 1); i++) {
+      const isErr = i === e.ssLine;
+      const lineLabel = t(isErr ? C.red : C.grey, `  ${String(i+1).padStart(4)} │ `);
+      const lineText  = isErr ? t(C.white, lines[i]) : t(C.grey, lines[i]);
+      console.error(lineLabel + lineText);
+      if (isErr) {
+        const indentCount = lines[i].match(/^\s*/)[0].length;
+        console.error(t(C.red, '       │ ' + ' '.repeat(indentCount) + '^ here'));
+      }
+    }
+  }
+  console.error('');
+}
+
+// ── REPL ───────────────────────────────────────────────────
+function startREPL() {
+  const readline = require('readline');
+
+  console.log(BANNER);
+  console.log(t(C.grey, '  Type StructScript code and press Enter to run.'));
+  console.log(t(C.grey, '  Type .exit to quit, .clear to reset, .help for commands.\n'));
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: t(C.teal, 'ss') + t(C.grey, ' › '),
+  });
+
+  let interp = new Interpreter({
+    output: msg => console.log(t(C.lime, '  ') + msg),
+    warn:   msg => console.warn(t(C.yellow, '  ⚠ ' + msg)),
+  });
+
+  let multilineBuffer = [];
+  let inBlock = false;
+
+  rl.prompt();
+
+  rl.on('line', input => {
+    const line = input;
+    const trimmed = line.trim();
+
+    // REPL commands
+    if (!inBlock) {
+      if (trimmed === '.exit' || trimmed === '.quit') { console.log(t(C.grey, '\n  Goodbye!\n')); process.exit(0); }
+      if (trimmed === '.clear' || trimmed === '.reset') {
+        interp = new Interpreter({ output: msg => console.log(t(C.lime, '  ') + msg), warn: msg => console.warn(t(C.yellow, '  ⚠ ' + msg)) });
+        console.log(t(C.grey, '  Environment cleared.')); rl.prompt(); return;
+      }
+      if (trimmed === '.help') {
+        console.log(t(C.grey, '  Commands: .exit  .clear  .help'));
+        console.log(t(C.grey, '  End a block with an empty line.'));
+        rl.prompt(); return;
+      }
+    }
+
+    // Collect multi-line blocks
+    if (trimmed.endsWith(':') && !trimmed.startsWith('//')) inBlock = true;
+    if (inBlock) {
+      multilineBuffer.push(line);
+      if (trimmed === '' && multilineBuffer.length > 1) {
+        // Execute block
+        const code = multilineBuffer.join('\n');
+        multilineBuffer = [];
+        inBlock = false;
+        executeREPL(interp, code);
+      } else {
+        process.stdout.write(t(C.grey, '  ... ')); return;
+      }
+    } else if (trimmed) {
+      executeREPL(interp, line);
+    }
+
+    rl.prompt();
+  });
+
+  rl.on('close', () => { console.log(t(C.grey, '\n  Goodbye!\n')); process.exit(0); });
+}
+
+function executeREPL(interp, code) {
+  try {
+    interp.run(code);
+  } catch (e) {
+    console.error(t(C.red, `  ● ${e.message}`));
+    if (e.ssLine !== undefined && e.snippet) {
+      console.error(t(C.grey, `    → ${e.snippet.trim()}`));
+    }
+  }
+}

package/examples/classes.ss

@@ -0,0 +1,30 @@
+// classes.ss — Classes with methods
+
+class Animal:
+  name = "Unknown"
+  sound = "..."
+
+  define init(n, s):
+    set self.name = n
+    set self.sound = s
+
+  define speak():
+    say "{self.name} says {self.sound}!"
+
+class Counter:
+  value = 0
+
+  define increment(by = 1):
+    set self.value = self.value + by
+
+  define get():
+    return self.value
+
+let dog = Animal()
+dog.init("Rex", "Woof")
+dog.speak()
+
+let c = Counter()
+c.increment()
+c.increment(5)
+say "Counter: {c.get()}"

package/examples/fibonacci.ss

@@ -0,0 +1,10 @@
+// fibonacci.ss — Fibonacci sequence
+
+define fib(n):
+  if n <= 1:
+    return n
+  return fib(n - 1) + fib(n - 2)
+
+say "First 12 Fibonacci numbers:"
+count i from 0 to 11:
+  say "  fib({i}) = {fib(i)}"

package/examples/hello.ss

@@ -0,0 +1,8 @@
+// hello.ss — Your first StructScript program
+
+let name = "World"
+say "Hello, {name}!"
+say "Welcome to StructScript v1.2"
+
+const VERSION = 1.2
+say "Running StructScript v{VERSION}"

package/lib/interpreter.js

@@ -0,0 +1,720 @@
+'use strict';
+
+// ============================================================
+// STRUCTSCRIPT INTERPRETER v1.2
+// ============================================================
+
+class SSError extends Error {
+  constructor(msg, line, snippet) {
+    super(msg);
+    this.name = 'StructScriptError';
+    this.ssLine = line;
+    this.snippet = snippet;
+  }
+}
+
+class ReturnSignal { constructor(v) { this.value = v; } }
+class BreakSignal {}
+class ContinueSignal {}
+
+class Environment {
+  constructor(parent = null) {
+    this.vars = {};
+    this.consts = new Set();
+    this.parent = parent;
+  }
+  get(name) {
+    if (name in this.vars) return this.vars[name];
+    if (this.parent) return this.parent.get(name);
+    throw new SSError(`Undefined variable: "${name}"`);
+  }
+  set(name, value) {
+    if (name in this.vars) {
+      if (this.consts.has(name)) throw new SSError(`Cannot reassign constant "${name}"`);
+      this.vars[name] = value; return;
+    }
+    if (this.parent && this.parent.has(name)) { this.parent.set(name, value); return; }
+    this.vars[name] = value;
+  }
+  has(name) { return name in this.vars || (this.parent ? this.parent.has(name) : false); }
+  define(name, value, isConst = false) {
+    this.vars[name] = value;
+    if (isConst) this.consts.add(name);
+  }
+}
+
+class Interpreter {
+  constructor(options = {}) {
+    this.outputFn = options.output || (msg => process.stdout.write(String(msg) + '\n'));
+    this.warnFn   = options.warn   || (msg => process.stderr.write('Warning: ' + String(msg) + '\n'));
+    this.globals = new Environment();
+    this.structs = {};
+    this.callDepth = 0;
+    this.sourceLines = [];
+    this._registerBuiltins();
+  }
+
+  _registerBuiltins() {
+    const G = this.globals;
+
+    // I/O
+    G.define('say',   a => { this.outputFn(this._str(a[0])); return null; });
+    G.define('print', a => { this.outputFn(a.map(x => this._str(x)).join(' ')); return null; });
+    G.define('warn',  a => { this.warnFn(this._str(a[0])); return null; });
+
+    // Math
+    G.define('abs',     a => Math.abs(a[0]));
+    G.define('sqrt',    a => Math.sqrt(a[0]));
+    G.define('floor',   a => Math.floor(a[0]));
+    G.define('ceil',    a => Math.ceil(a[0]));
+    G.define('round',   a => Math.round(a[0]));
+    G.define('max',     a => Math.max(...a));
+    G.define('min',     a => Math.min(...a));
+    G.define('pow',     a => Math.pow(a[0], a[1]));
+    G.define('log',     a => Math.log(a[0]));
+    G.define('log10',   a => Math.log10(a[0]));
+    G.define('log2',    a => Math.log2(a[0]));
+    G.define('sin',     a => Math.sin(a[0]));
+    G.define('cos',     a => Math.cos(a[0]));
+    G.define('tan',     a => Math.tan(a[0]));
+    G.define('random',  a => Math.random());
+    G.define('randint', a => Math.floor(Math.random() * (a[1] - a[0] + 1)) + a[0]);
+    G.define('pi',      0); // constant, overwritten below
+    this.globals.define('PI', Math.PI, true);
+    this.globals.define('E',  Math.E,  true);
+
+    // Type conversion
+    G.define('str',    a => String(a[0] ?? ''));
+    G.define('num',    a => { const n = Number(a[0]); if (isNaN(n)) throw new SSError(`Cannot convert "${a[0]}" to number`); return n; });
+    G.define('bool',   a => Boolean(a[0]));
+    G.define('type',   a => { if (Array.isArray(a[0])) return 'list'; if (a[0] === null || a[0] === undefined) return 'nothing'; return typeof a[0]; });
+    G.define('isNothing', a => a[0] === null || a[0] === undefined);
+    G.define('isNumber',  a => typeof a[0] === 'number');
+    G.define('isString',  a => typeof a[0] === 'string');
+    G.define('isList',    a => Array.isArray(a[0]));
+
+    // String
+    G.define('upper',      a => String(a[0]).toUpperCase());
+    G.define('lower',      a => String(a[0]).toLowerCase());
+    G.define('trim',       a => String(a[0]).trim());
+    G.define('trimStart',  a => String(a[0]).trimStart());
+    G.define('trimEnd',    a => String(a[0]).trimEnd());
+    G.define('length',     a => Array.isArray(a[0]) ? a[0].length : String(a[0]).length);
+    G.define('contains',   a => String(a[0]).includes(String(a[1])));
+    G.define('startsWith', a => String(a[0]).startsWith(String(a[1])));
+    G.define('endsWith',   a => String(a[0]).endsWith(String(a[1])));
+    G.define('replace',    a => String(a[0]).split(String(a[1])).join(String(a[2])));
+    G.define('replaceAll', a => String(a[0]).split(String(a[1])).join(String(a[2])));
+    G.define('split',      a => String(a[0]).split(String(a[1])));
+    G.define('indexOf',    a => Array.isArray(a[0]) ? a[0].indexOf(a[1]) : String(a[0]).indexOf(String(a[1])));
+    G.define('lastIndexOf',a => Array.isArray(a[0]) ? a[0].lastIndexOf(a[1]) : String(a[0]).lastIndexOf(String(a[1])));
+    G.define('slice',      a => { const s = a[0]; const from = a[1] ?? 0; const to = a[2]; return Array.isArray(s) ? s.slice(from, to) : String(s).slice(from, to); });
+    G.define('char',       a => String.fromCharCode(a[0]));
+    G.define('charCode',   a => String(a[0]).charCodeAt(0));
+    G.define('repeat',     a => String(a[0]).repeat(a[1]));
+    G.define('padStart',   a => String(a[0]).padStart(a[1], a[2] ?? ' '));
+    G.define('padEnd',     a => String(a[0]).padEnd(a[1], a[2] ?? ' '));
+    G.define('format',     a => { let s = String(a[0]); for (let i = 1; i < a.length; i++) s = s.replace('{}', this._str(a[i])); return s; });
+
+    // List
+    G.define('push',    a => { if (!Array.isArray(a[0])) throw new SSError('push() requires a list'); a[0].push(a[1]); return null; });
+    G.define('pop',     a => { if (!Array.isArray(a[0])) throw new SSError('pop() requires a list'); return a[0].pop() ?? null; });
+    G.define('shift',   a => { if (!Array.isArray(a[0])) return null; return a[0].shift() ?? null; });
+    G.define('unshift', a => { if (Array.isArray(a[0])) a[0].unshift(a[1]); return null; });
+    G.define('join',    a => { if (!Array.isArray(a[0])) throw new SSError('join() requires a list'); return a[0].map(x => this._str(x)).join(a[1] ?? ''); });
+    G.define('sort',    a => { if (!Array.isArray(a[0])) throw new SSError('sort() requires a list'); return [...a[0]].sort((x, y) => x < y ? -1 : x > y ? 1 : 0); });
+    G.define('sortBy',  a => { if (!Array.isArray(a[0])) throw new SSError('sortBy() requires a list'); const fn = a[1]; return [...a[0]].sort((x, y) => { const ax = fn([x]); const ay = fn([y]); return ax < ay ? -1 : ax > ay ? 1 : 0; }); });
+    G.define('reverse', a => { if (!Array.isArray(a[0])) throw new SSError('reverse() requires a list'); return [...a[0]].reverse(); });
+    G.define('range',   a => { const from = a[1] !== undefined ? a[0] : 0; const to = a[1] !== undefined ? a[1] : a[0]; const step = a[2] ?? 1; const r = []; for (let i = from; i < to; i += step) r.push(i); return r; });
+    G.define('flatten', a => Array.isArray(a[0]) ? a[0].flat() : [a[0]]);
+    G.define('unique',  a => [...new Set(a[0])]);
+    G.define('sum',     a => Array.isArray(a[0]) ? a[0].reduce((acc, v) => acc + v, 0) : 0);
+    G.define('avg',     a => Array.isArray(a[0]) && a[0].length ? a[0].reduce((acc, v) => acc + v, 0) / a[0].length : 0);
+    G.define('map',     a => { if (!Array.isArray(a[0])) throw new SSError('map() requires a list'); const fn = a[1]; return a[0].map(item => { const r = fn([item], null); return r instanceof ReturnSignal ? r.value : r; }); });
+    G.define('filter',  a => { if (!Array.isArray(a[0])) throw new SSError('filter() requires a list'); const fn = a[1]; return a[0].filter(item => { const r = fn([item], null); return r instanceof ReturnSignal ? r.value : r; }); });
+    G.define('reduce',  a => { if (!Array.isArray(a[0])) throw new SSError('reduce() requires a list'); const fn = a[1]; let acc = a[2]; return a[0].reduce((ac, item) => { const r = fn([ac, item], null); return r instanceof ReturnSignal ? r.value : r; }, acc); });
+    G.define('includes',a => Array.isArray(a[0]) ? a[0].includes(a[1]) : String(a[0]).includes(String(a[1])));
+    G.define('count',   a => Array.isArray(a[0]) ? a[0].filter(x => x === a[1]).length : 0);
+    G.define('zip',     a => { const la = a[0], lb = a[1]; const len = Math.min(la.length, lb.length); return Array.from({length: len}, (_, i) => [la[i], lb[i]]); });
+
+    // Utility
+    G.define('assert',  a => { if (!a[0]) throw new SSError('Assertion failed' + (a[1] ? ': ' + a[1] : '')); return null; });
+    G.define('error',   a => { throw new SSError(String(a[0] ?? 'Runtime error')); });
+    G.define('exit',    a => { process.exit(a[0] ?? 0); });
+  }
+
+  run(source) {
+    this.sourceLines = source.split('\n');
+    this._execBlock(this.sourceLines, 0, this.sourceLines.length, this.globals);
+  }
+
+  _indent(line) {
+    let i = 0;
+    while (i < line.length && line[i] === ' ') i++;
+    return i;
+  }
+
+  _findBlock(lines, startLine, baseIndent) {
+    const block = []; let i = startLine;
+    while (i < lines.length) {
+      const line = lines[i], t = line.trim();
+      if (!t || t.startsWith('//')) { i++; continue; }
+      if (this._indent(line) <= baseIndent) break;
+      block.push(i); i++;
+    }
+    return { block, next: i };
+  }
+
+  _execBlock(lines, start, end, env) {
+    let i = start;
+    while (i < end) {
+      const raw = lines[i], t = raw.trim();
+      if (!t || t.startsWith('//')) { i++; continue; }
+      const indent = this._indent(raw);
+      const result = this._execLine(t, lines, i, indent, env);
+      if (result instanceof ReturnSignal || result instanceof BreakSignal || result instanceof ContinueSignal) return result;
+      if (result && result._skip) { i = result._skip; continue; }
+      i++;
+    }
+  }
+
+  _execLine(line, allLines, lineIdx, indent, env) {
+    try { return this._exec(line, allLines, lineIdx, indent, env); }
+    catch (e) {
+      if (e instanceof SSError) { if (e.ssLine === undefined) e.ssLine = lineIdx; if (!e.snippet) e.snippet = allLines[lineIdx]; throw e; }
+      throw new SSError(e.message, lineIdx, allLines[lineIdx]);
+    }
+  }
+
+  _exec(line, allLines, lineIdx, indent, env) {
+    // say shorthand
+    if (line.startsWith('say ')) { const v = this._eval(line.slice(4).trim(), env); this.outputFn(this._str(v)); return null; }
+
+    // let / const
+    if (line.startsWith('let ') || line.startsWith('const ')) {
+      const isConst = line.startsWith('const ');
+      const rest = line.slice(isConst ? 6 : 4);
+      const eq = rest.indexOf('='); if (eq === -1) throw new SSError(`Missing = in declaration`);
+      const name = rest.slice(0, eq).trim();
+      const val = this._eval(rest.slice(eq + 1).trim(), env);
+      env.define(name, val, isConst); return null;
+    }
+
+    // set (with compound assignment)
+    if (line.startsWith('set ')) {
+      const rest = line.slice(4);
+      const compM = rest.match(/^([a-zA-Z_][\w.]*|\w+\[.+?\])\s*(\+|-|\*|\/|%|\*\*|\/\/)=\s*(.+)$/);
+      if (compM) {
+        const [, target, op, valExpr] = compM;
+        const cur = this._getTarget(target, env);
+        const val = this._eval(valExpr.trim(), env);
+        this._setTarget(target, this._applyOp(cur, op, val), env); return null;
+      }
+      const eq = rest.indexOf('='); if (eq === -1) throw new SSError(`Missing = in set`);
+      const target = rest.slice(0, eq).trim(), val = this._eval(rest.slice(eq + 1).trim(), env);
+      this._setTarget(target, val, env); return null;
+    }
+
+    // define function
+    if (line.startsWith('define ')) {
+      const sig = line.slice(7).trim().replace(/:$/, '');
+      const po = sig.indexOf('('), pc = sig.lastIndexOf(')');
+      const fname = sig.slice(0, po).trim();
+      const rawParams = sig.slice(po + 1, pc).trim();
+      const params = rawParams ? rawParams.split(',').map(p => p.trim()).filter(Boolean) : [];
+      const defaults = {};
+      params.forEach((p, i) => { const eq = p.indexOf('='); if (eq !== -1) { defaults[p.slice(0, eq).trim()] = this._eval(p.slice(eq + 1).trim(), env); params[i] = p.slice(0, eq).trim(); } });
+      const { block, next } = this._findBlock(allLines, lineIdx + 1, indent);
+      env.define(fname, (args, callEnv) => {
+        if (this.callDepth > 500) throw new SSError('Stack overflow: too many nested calls');
+        this.callDepth++;
+        const fnEnv = new Environment(env);
+        params.forEach((p, i) => fnEnv.define(p, args[i] !== undefined ? args[i] : (defaults[p] !== undefined ? defaults[p] : null)));
+        const blockLines = block.map(b => allLines[b]);
+        const res = this._execBlock(blockLines, 0, blockLines.length, fnEnv);
+        this.callDepth--;
+        if (res instanceof ReturnSignal) return res.value;
+        return null;
+      });
+      return { _skip: next };
+    }
+
+    // struct
+    if (line.startsWith('struct ')) {
+      const name = line.slice(7).trim().replace(/:$/, '');
+      const { block, next } = this._findBlock(allLines, lineIdx + 1, indent);
+      const defs = {};
+      block.forEach(bi => { const t = allLines[bi].trim(); if (!t || t.startsWith('//')) return; const eq = t.indexOf('='); if (eq !== -1) { defs[t.slice(0, eq).trim()] = this._eval(t.slice(eq + 1).trim(), this.globals); } });
+      this.structs[name] = defs;
+      env.define(name, args => {
+        const inst = { __struct: name };
+        Object.entries(defs).forEach(([k, v]) => { inst[k] = Array.isArray(v) ? [...v] : v; });
+        return inst;
+      });
+      return { _skip: next };
+    }
+
+    // class
+    if (line.startsWith('class ')) {
+      const name = line.slice(6).trim().replace(/:$/, '');
+      const { block, next } = this._findBlock(allLines, lineIdx + 1, indent);
+      const fields = {}, methods = {};
+      let i2 = 0;
+      const bLines = block.map(b => allLines[b]);
+      while (i2 < bLines.length) {
+        const t = bLines[i2].trim();
+        if (!t || t.startsWith('//')) { i2++; continue; }
+        const bIndent = this._indent(bLines[i2]);
+        if (t.startsWith('define ')) {
+          const sig = t.slice(7).replace(/:$/, '');
+          const po = sig.indexOf('('), pc = sig.lastIndexOf(')');
+          const mname = sig.slice(0, po).trim();
+          const rawP = sig.slice(po + 1, pc).trim();
+          const params = rawP ? rawP.split(',').map(p => p.trim()).filter(Boolean) : [];
+          const defs2 = {};
+          params.forEach((p, pi) => { const eq = p.indexOf('='); if (eq !== -1) { defs2[p.slice(0, eq).trim()] = this._eval(p.slice(eq + 1).trim(), env); params[pi] = p.slice(0, eq).trim(); } });
+          const { block: mb, next: mn } = this._findBlock(bLines, i2 + 1, bIndent);
+          methods[mname] = { params, defaults: defs2, body: mb.map(b => bLines[b]) };
+          i2 = mn;
+        } else {
+          const eq = t.indexOf('=');
+          if (eq !== -1) fields[t.slice(0, eq).trim()] = this._eval(t.slice(eq + 1).trim(), this.globals);
+          i2++;
+        }
+      }
+      const classEnv = env;
+      const interpRef = this;
+      env.define(name, args => {
+        const inst = { __struct: name, __class: name };
+        Object.entries(fields).forEach(([k, v]) => { inst[k] = Array.isArray(v) ? [...v] : (typeof v === 'object' && v ? Object.assign({}, v) : v); });
+        Object.entries(methods).forEach(([mname, m]) => {
+          inst[mname] = callArgs => {
+            if (interpRef.callDepth > 500) throw new SSError('Stack overflow');
+            interpRef.callDepth++;
+            const fnEnv = new Environment(classEnv);
+            fnEnv.define('self', inst);
+            fnEnv.define('this', inst);
+            m.params.forEach((p, i) => fnEnv.define(p, callArgs[i] !== undefined ? callArgs[i] : (m.defaults[p] !== undefined ? m.defaults[p] : null)));
+            const res = interpRef._execBlock(m.body, 0, m.body.length, fnEnv);
+            interpRef.callDepth--;
+            if (res instanceof ReturnSignal) return res.value;
+            return null;
+          };
+        });
+        if (inst.init) inst.init(args);
+        return inst;
+      });
+      return { _skip: next };
+    }
+
+    // return / break / continue
+    if (line === 'return') return new ReturnSignal(null);
+    if (line.startsWith('return ')) return new ReturnSignal(this._eval(line.slice(7).trim(), env));
+    if (line === 'break') return new BreakSignal();
+    if (line === 'continue') return new ContinueSignal();
+
+    // try/catch/finally
+    if (line === 'try:') {
+      const { block: tryBlock, next: tryNext } = this._findBlock(allLines, lineIdx + 1, indent);
+      let catchVar = null, catchBlock = [], finallyBlock = [], cur = tryNext;
+      if (cur < allLines.length) {
+        const ct = allLines[cur].trim();
+        if (ct.startsWith('catch')) {
+          const m = ct.match(/^catch\s+(\w+):?$/); catchVar = m ? m[1] : '_err';
+          const { block: cb, next: cn } = this._findBlock(allLines, cur + 1, this._indent(allLines[cur]));
+          catchBlock = cb; cur = cn;
+        }
+      }
+      if (cur < allLines.length && allLines[cur].trim() === 'finally:') {
+        const { block: fb, next: fn } = this._findBlock(allLines, cur + 1, this._indent(allLines[cur]));
+        finallyBlock = fb; cur = fn;
+      }
+      let result = null;
+      try {
+        const bLines = tryBlock.map(b => allLines[b]);
+        result = this._execBlock(bLines, 0, bLines.length, new Environment(env));
+      } catch (e) {
+        if (catchBlock.length) {
+          const cEnv = new Environment(env);
+          if (catchVar) cEnv.define(catchVar, e.message || String(e));
+          const cLines = catchBlock.map(b => allLines[b]);
+          result = this._execBlock(cLines, 0, cLines.length, cEnv);
+        }
+      } finally {
+        if (finallyBlock.length) {
+          const fLines = finallyBlock.map(b => allLines[b]);
+          this._execBlock(fLines, 0, fLines.length, new Environment(env));
+        }
+      }
+      return { _skip: cur };
+    }
+
+    // if / else if / else
+    if (line.startsWith('if ') && line.endsWith(':')) return this._handleIf(line, allLines, lineIdx, indent, env);
+    if (line.startsWith('else if ') || line === 'else:') return null;
+
+    // while
+    if (line.startsWith('while ') && line.endsWith(':')) {
+      const cond = line.slice(6, -1).trim();
+      const { block, next } = this._findBlock(allLines, lineIdx + 1, indent);
+      let iters = 0;
+      while (this._truthy(this._eval(cond, env))) {
+        if (++iters > 100000) throw new SSError('Infinite loop detected (>100000 iterations)');
+        const bLines = block.map(b => allLines[b]);
+        const res = this._execBlock(bLines, 0, bLines.length, new Environment(env));
+        if (res instanceof BreakSignal) break;
+        if (res instanceof ReturnSignal) return res;
+      }
+      return { _skip: next };
+    }
+
+    // repeat N times
+    if (line.startsWith('repeat ')) {
+      const m = line.match(/^repeat (.+?) times:?$/);
+      if (m) {
+        const count = Math.floor(Number(this._eval(m[1].trim(), env)));
+        if (isNaN(count)) throw new SSError(`repeat count must be a number`);
+        const { block, next } = this._findBlock(allLines, lineIdx + 1, indent);
+        for (let i = 0; i < count; i++) {
+          const bLines = block.map(b => allLines[b]);
+          const res = this._execBlock(bLines, 0, bLines.length, new Environment(env));
+          if (res instanceof BreakSignal) break;
+          if (res instanceof ReturnSignal) return res;
+        }
+        return { _skip: next };
+      }
+    }
+
+    // count i from X to Y (step Z)
+    if (line.startsWith('count ')) {
+      const m = line.match(/^count (\w+) from (.+?) to (.+?)(?:\s+step\s+(.+?))?:?$/);
+      if (m) {
+        const varName = m[1];
+        const from = Number(this._eval(m[2].trim(), env));
+        const to = Number(this._eval(m[3].trim(), env));
+        const step = m[4] ? Number(this._eval(m[4].trim(), env)) : (from <= to ? 1 : -1);
+        const { block, next } = this._findBlock(allLines, lineIdx + 1, indent);
+        for (let i = from; step > 0 ? i <= to : i >= to; i += step) {
+          const loopEnv = new Environment(env); loopEnv.define(varName, i);
+          const bLines = block.map(b => allLines[b]);
+          const res = this._execBlock(bLines, 0, bLines.length, loopEnv);
+          if (res instanceof BreakSignal) break;
+          if (res instanceof ReturnSignal) return res;
+        }
+        return { _skip: next };
+      }
+    }
+
+    // for each item in list
+    if (line.startsWith('for each ')) {
+      const m = line.match(/^for each (\w+) in (.+?):?$/);
+      if (m) {
+        const varName = m[1], listVal = this._eval(m[2].trim(), env);
+        if (!Array.isArray(listVal) && typeof listVal !== 'string') throw new SSError(`"${m[2].trim()}" is not iterable`);
+        const { block, next } = this._findBlock(allLines, lineIdx + 1, indent);
+        for (const item of listVal) {
+          const loopEnv = new Environment(env); loopEnv.define(varName, item);
+          const bLines = block.map(b => allLines[b]);
+          const res = this._execBlock(bLines, 0, bLines.length, loopEnv);
+          if (res instanceof BreakSignal) break;
+          if (res instanceof ReturnSignal) return res;
+        }
+        return { _skip: next };
+      }
+    }
+
+    // bare expression
+    this._eval(line, env);
+    return null;
+  }
+
+  _handleIf(line, allLines, lineIdx, indent, env) {
+    const cond = line.slice(3, -1).trim();
+    const { block, next } = this._findBlock(allLines, lineIdx + 1, indent);
+    if (this._truthy(this._eval(cond, env))) {
+      const bLines = block.map(b => allLines[b]);
+      const res = this._execBlock(bLines, 0, bLines.length, new Environment(env));
+      if (res instanceof ReturnSignal || res instanceof BreakSignal) return res;
+      let skip = next;
+      while (skip < allLines.length) {
+        const t = allLines[skip].trim();
+        if (t.startsWith('else')) { const { next: n2 } = this._findBlock(allLines, skip + 1, this._indent(allLines[skip])); skip = n2; } else break;
+      }
+      return { _skip: skip };
+    } else {
+      let cur = next;
+      while (cur < allLines.length) {
+        const t = allLines[cur].trim();
+        const ci = this._indent(allLines[cur]);
+        if (t.startsWith('else if ') && t.endsWith(':')) {
+          const cond2 = t.slice(8, -1).trim();
+          const { block: b2, next: n2 } = this._findBlock(allLines, cur + 1, ci);
+          if (this._truthy(this._eval(cond2, env))) {
+            const bLines = b2.map(b => allLines[b]);
+            const res = this._execBlock(bLines, 0, bLines.length, new Environment(env));
+            if (res instanceof ReturnSignal || res instanceof BreakSignal) return res;
+            let skip2 = n2;
+            while (skip2 < allLines.length) { const tt = allLines[skip2].trim(); if (tt.startsWith('else')) { const { next: n3 } = this._findBlock(allLines, skip2 + 1, this._indent(allLines[skip2])); skip2 = n3; } else break; }
+            return { _skip: skip2 };
+          }
+          cur = n2;
+        } else if (t === 'else:') {
+          const { block: b3, next: n3 } = this._findBlock(allLines, cur + 1, ci);
+          const bLines = b3.map(b => allLines[b]);
+          const res = this._execBlock(bLines, 0, bLines.length, new Environment(env));
+          if (res instanceof ReturnSignal || res instanceof BreakSignal) return res;
+          return { _skip: n3 };
+        } else break;
+      }
+      return { _skip: cur };
+    }
+  }
+
+  _getTarget(target, env) {
+    if (target.includes('.')) { const parts = target.split('.'); let obj = env.get(parts[0]); for (let i = 1; i < parts.length - 1; i++) obj = obj[parts[i]]; return obj[parts[parts.length - 1]]; }
+    if (target.includes('[')) { const m = target.match(/^(\w+)\[(.+)\]$/); if (m) { const arr = env.get(m[1]); return arr[this._eval(m[2], env)]; } }
+    return env.get(target);
+  }
+
+  _setTarget(target, value, env) {
+    if (target.includes('.')) { const parts = target.split('.'); let obj = env.get(parts[0]); for (let i = 1; i < parts.length - 1; i++) obj = obj[parts[i]]; obj[parts[parts.length - 1]] = value; return; }
+    if (target.includes('[')) { const m = target.match(/^(\w+)\[(.+)\]$/); if (m) { const arr = env.get(m[1]); arr[this._eval(m[2], env)] = value; return; } }
+    env.set(target, value);
+  }
+
+  _applyOp(a, op, b) {
+    switch (op) {
+      case '+': return a + b; case '-': return a - b;
+      case '*': return a * b; case '/': return a / b;
+      case '%': return a % b; case '**': return Math.pow(a, b);
+      case '//': return Math.floor(a / b);
+    }
+  }
+
+  _truthy(v) { return v !== null && v !== undefined && v !== false && v !== 0 && v !== ''; }
+
+  _eval(expr, env) {
+    expr = expr.trim();
+    if (!expr) return null;
+    if (expr === 'true') return true;
+    if (expr === 'false') return false;
+    if (expr === 'null' || expr === 'nothing') return null;
+
+    // String literal
+    if ((expr[0] === '"' && expr[expr.length - 1] === '"') || (expr[0] === "'" && expr[expr.length - 1] === "'"))
+      return this._parseString(expr.slice(1, -1), env);
+
+    // Number
+    if (/^-?\d+(\.\d+)?$/.test(expr)) return Number(expr);
+
+    // List
+    if (expr[0] === '[' && expr[expr.length - 1] === ']') {
+      const inner = expr.slice(1, -1).trim();
+      if (!inner) return [];
+      return this._splitArgs(inner).map(a => this._eval(a, env));
+    }
+
+    // Parens
+    if (expr[0] === '(' && expr[expr.length - 1] === ')') return this._eval(expr.slice(1, -1), env);
+
+    // Ternary
+    const ternIdx = this._findOp(expr, ' if ');
+    if (ternIdx !== -1) {
+      const elseIdx = this._findOp(expr, ' else ');
+      if (elseIdx > ternIdx) {
+        const val = expr.slice(0, ternIdx).trim();
+        const cond = expr.slice(ternIdx + 4, elseIdx).trim();
+        const alt = expr.slice(elseIdx + 6).trim();
+        return this._truthy(this._eval(cond, env)) ? this._eval(val, env) : this._eval(alt, env);
+      }
+    }
+
+    // Logical
+    for (const op of [' or ', ' and ']) {
+      const i = this._findOp(expr, op);
+      if (i !== -1) {
+        if (op === ' or ')  return this._truthy(this._eval(expr.slice(0, i), env)) || this._truthy(this._eval(expr.slice(i + 4), env));
+        if (op === ' and ') return this._truthy(this._eval(expr.slice(0, i), env)) && this._truthy(this._eval(expr.slice(i + 5), env));
+      }
+    }
+    if (expr.startsWith('not ')) return !this._truthy(this._eval(expr.slice(4), env));
+
+    // Comparison
+    for (const op of ['>=', '<=', '!=', '==', '>', '<']) {
+      const i = this._findOp(expr, op);
+      if (i !== -1) {
+        const l = this._eval(expr.slice(0, i).trim(), env), r = this._eval(expr.slice(i + op.length).trim(), env);
+        switch (op) { case '==': return l == r; case '!=': return l != r; case '>': return l > r; case '<': return l < r; case '>=': return l >= r; case '<=': return l <= r; }
+      }
+    }
+
+    // Arithmetic
+    const addI = this._findOp(expr, '+');
+    if (addI !== -1) return this._eval(expr.slice(0, addI).trim(), env) + this._eval(expr.slice(addI + 1).trim(), env);
+    const subI = this._findBinaryMinus(expr);
+    if (subI !== -1) return this._eval(expr.slice(0, subI).trim(), env) - this._eval(expr.slice(subI + 1).trim(), env);
+    const modI = this._findOp(expr, '%');
+    if (modI !== -1) return this._eval(expr.slice(0, modI).trim(), env) % this._eval(expr.slice(modI + 1).trim(), env);
+    const powI = this._findOp(expr, '**');
+    if (powI !== -1) return Math.pow(this._eval(expr.slice(0, powI).trim(), env), this._eval(expr.slice(powI + 2).trim(), env));
+    const fdivI = this._findOp(expr, '//');
+    if (fdivI !== -1) return Math.floor(this._eval(expr.slice(0, fdivI).trim(), env) / this._eval(expr.slice(fdivI + 2).trim(), env));
+    const mulI = this._findOp(expr, '*');
+    if (mulI !== -1) return this._eval(expr.slice(0, mulI).trim(), env) * this._eval(expr.slice(mulI + 1).trim(), env);
+    const divI = this._findOp(expr, '/');
+    if (divI !== -1) return this._eval(expr.slice(0, divI).trim(), env) / this._eval(expr.slice(divI + 1).trim(), env);
+    if (expr[0] === '-') return -this._eval(expr.slice(1), env);
+
+    // Method call: obj.method(args) — obj must be identifier or index expression
+    const methodM = expr.match(/^([a-zA-Z_]\w*(?:\[.+?\])?(?:\.[a-zA-Z_]\w*(?:\[.+?\])?)*)\.([a-zA-Z_]\w*)\((.*)\)$/s);
+    if (methodM) {
+      const [, objExpr, mname, argsRaw] = methodM;
+      const obj = this._eval(objExpr, env);
+      const args = argsRaw.trim() ? this._splitArgs(argsRaw).map(a => this._eval(a.trim(), env)) : [];
+      if (typeof obj === 'object' && obj !== null && typeof obj[mname] === 'function') return obj[mname](args);
+      if (typeof obj === 'string') {
+        if (mname === 'upper') return obj.toUpperCase();
+        if (mname === 'lower') return obj.toLowerCase();
+        if (mname === 'trim') return obj.trim();
+        if (mname === 'length') return obj.length;
+        if (mname === 'split') return obj.split(args[0] ?? '');
+        if (mname === 'contains') return obj.includes(String(args[0]));
+        if (mname === 'replace') return obj.split(String(args[0])).join(String(args[1]));
+        if (mname === 'startsWith') return obj.startsWith(String(args[0]));
+        if (mname === 'endsWith') return obj.endsWith(String(args[0]));
+      }
+      if (Array.isArray(obj)) {
+        if (mname === 'push') { obj.push(args[0]); return null; }
+        if (mname === 'pop') return obj.pop() ?? null;
+        if (mname === 'length') return obj.length;
+        if (mname === 'sort') return [...obj].sort();
+        if (mname === 'reverse') return [...obj].reverse();
+        if (mname === 'join') return obj.map(x => this._str(x)).join(args[0] ?? '');
+        if (mname === 'contains') return obj.includes(args[0]);
+      }
+      throw new SSError(`"${mname}" is not a method of ${this._str(obj)}`);
+    }
+
+    // Function call
+    const callM = expr.match(/^([a-zA-Z_][\w]*)\((.*)\)$/s);
+    if (callM) {
+      const fname = callM[1], argsRaw = callM[2].trim();
+      const args = argsRaw ? this._splitArgs(argsRaw).map(a => this._eval(a.trim(), env)) : [];
+      const fn = env.get(fname);
+      if (typeof fn !== 'function') throw new SSError(`"${fname}" is not a function`);
+      this.callDepth++;
+      if (this.callDepth > 500) { this.callDepth--; throw new SSError('Stack overflow'); }
+      const res = fn(args, env);
+      this.callDepth--;
+      return res;
+    }
+
+    // Index access
+    const bracketM = expr.match(/^(.+?)\[(.+)\]$/);
+    if (bracketM) {
+      const obj = this._eval(bracketM[1].trim(), env);
+      const idx = this._eval(bracketM[2].trim(), env);
+      if (Array.isArray(obj) || typeof obj === 'string') return obj[idx] ?? null;
+      if (typeof obj === 'object' && obj !== null) return obj[idx] ?? null;
+      return null;
+    }
+
+    // Dot access
+    if (expr.includes('.') && !/^\d/.test(expr)) {
+      const dot = expr.lastIndexOf('.');
+      const obj = this._eval(expr.slice(0, dot), env);
+      const key = expr.slice(dot + 1);
+      if (typeof obj === 'object' && obj !== null) return obj[key] ?? null;
+      return null;
+    }
+
+    // Variable
+    return env.get(expr);
+  }
+
+  _parseString(s, env) {
+    s = s.replace(/\\n/g, '\n').replace(/\\t/g, '\t').replace(/\\\\/g, '\\').replace(/\\"/g, '"').replace(/\\'/g, "'");
+    if (!env) return s;
+    // Find all {expr} blocks, handling nested parens/brackets
+    let result = '';
+    let i = 0;
+    while (i < s.length) {
+      if (s[i] === '{') {
+        let depth = 1, j = i + 1;
+        while (j < s.length && depth > 0) {
+          if (s[j] === '{') depth++;
+          else if (s[j] === '}') depth--;
+          j++;
+        }
+        const expr = s.slice(i + 1, j - 1);
+        try { result += this._str(this._eval(expr.trim(), env)); }
+        catch (e) { result += '{' + expr + '}'; }
+        i = j;
+      } else {
+        result += s[i++];
+      }
+    }
+    return result;
+  }
+
+  _findOp(expr, op) {
+    let depth = 0, inStr = false, sc = '';
+    for (let i = 0; i < expr.length; i++) {
+      const c = expr[i];
+      if (inStr) { if (c === sc) inStr = false; continue; }
+      if (c === '"' || c === "'") { inStr = true; sc = c; continue; }
+      if (c === '(' || c === '[') depth++;
+      else if (c === ')' || c === ']') depth--;
+      else if (depth === 0 && expr.slice(i, i + op.length) === op) return i;
+    }
+    return -1;
+  }
+
+  _findBinaryMinus(expr) {
+    let depth = 0, inStr = false, sc = '';
+    for (let i = expr.length - 1; i > 0; i--) {
+      const c = expr[i];
+      if (c === '"' || c === "'") inStr = !inStr;
+      if (inStr) continue;
+      if (c === ')' || c === ']') depth++;
+      else if (c === '(' || c === '[') depth--;
+      else if (depth === 0 && c === '-') {
+        // Look backwards past spaces
+        let prev = i - 1;
+        while (prev >= 0 && expr[prev] === ' ') prev--;
+        if (prev >= 0 && /[\w\d\)"'\]]/.test(expr[prev])) return i;
+      }
+    }
+    return -1;
+  }
+
+  _splitArgs(str) {
+    const args = []; let depth = 0, inStr = false, sc = '', cur = '';
+    for (let i = 0; i < str.length; i++) {
+      const c = str[i];
+      if (inStr) { cur += c; if (c === sc) inStr = false; continue; }
+      if (c === '"' || c === "'") { inStr = true; sc = c; cur += c; continue; }
+      if (c === '(' || c === '[') { depth++; cur += c; continue; }
+      if (c === ')' || c === ']') { depth--; cur += c; continue; }
+      if (c === ',' && depth === 0) { args.push(cur.trim()); cur = ''; continue; }
+      cur += c;
+    }
+    if (cur.trim()) args.push(cur.trim());
+    return args;
+  }
+
+  _str(val) {
+    if (val === null || val === undefined) return 'nothing';
+    if (val === true) return 'true';
+    if (val === false) return 'false';
+    if (Array.isArray(val)) return '[' + val.map(v => this._str(v)).join(', ') + ']';
+    if (typeof val === 'object') {
+      const n = val.__struct || 'object';
+      const fields = Object.entries(val).filter(([k]) => !k.startsWith('__') && typeof val[k] !== 'function').map(([k, v]) => `${k}: ${this._str(v)}`).join(', ');
+      return `${n}{ ${fields} }`;
+    }
+    return String(val);
+  }
+}
+
+module.exports = { Interpreter, SSError, Environment };

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "structscript",
+  "version": "1.2.0",
+  "description": "The StructScript programming language — clean, readable scripting for everyone",
+  "keywords": ["structscript", "language", "interpreter", "scripting", "programming-language"],
+  "author": "StructScript",
+  "license": "MIT",
+  "main": "lib/interpreter.js",
+  "bin": {
+    "structscript": "./bin/structscript.js",
+    "ss": "./bin/structscript.js"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/structscript/structscript"
+  },
+  "homepage": "https://structscript.dev",
+  "scripts": {
+    "test": "node test/run.js"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "examples/",
+    "README.md"
+  ]
+}