@phuetz/code-buddy 0.1.0 → 0.1.2

package/dist/scripting/runtime.js

@@ -1,12 +1,22 @@
 /**
- * Buddy Script Runtime
+ * Unified Script Runtime
  *
- * Executes parsed AST nodes
+ * Based on FCS runtime (class/test/assert/dict/lambda/interpolation/pipeline/ternary/index)
+ * with Buddy Script additions:
+ * - Async/await native support
+ * - ForCStyle statement execution
+ * - AwaitExpression handling
+ * - Export statement handling
+ * - Timeout enforcement per-statement
+ * - ScriptResult with testResults tracking
+ *
+ * Extensions: .bs (primary), .fcs (backward-compatible alias)
  */
-import { DEFAULT_SCRIPT_CONFIG, } from './types.js';
+import { TokenType, DEFAULT_SCRIPT_CONFIG, } from './types.js';
 import { createBuiltins } from './builtins.js';
-// Special return value for control flow
-class ReturnValue {
+import { createGrokBindings } from './codebuddy-bindings.js';
+// Control flow signals
+class ReturnSignal {
     value;
     constructor(value) {
         this.value = value;
@@ -16,26 +26,36 @@ class BreakSignal {
 }
 class ContinueSignal {
 }
-export class Runtime {
+export class FCSRuntime {
     config;
     globalContext;
     output = [];
     startTime = 0;
+    testResults = [];
     constructor(config = {}) {
         this.config = { ...DEFAULT_SCRIPT_CONFIG, ...config };
         this.globalContext = {
             variables: new Map(),
             functions: new Map(),
         };
-        // Initialize builtins
         this.initializeBuiltins();
     }
     initializeBuiltins() {
-        const builtins = createBuiltins(this.config, (msg) => {
+        const printFn = (msg) => {
             this.output.push(msg);
-        });
-        for (const [name, fn] of Object.entries(builtins)) {
-            this.globalContext.functions.set(name, fn);
+        };
+        // Load unified builtins (merged FCS + BS)
+        const builtins = createBuiltins(this.config, printFn);
+        for (const [name, value] of Object.entries(builtins)) {
+            this.globalContext.variables.set(name, value);
+            if (typeof value === 'function') {
+                this.globalContext.functions.set(name, value);
+            }
+        }
+        // Load codebuddy bindings (grok.*, tool.*, context.*, agent.*, mcp.*, git.*, session.*)
+        const grokBindings = createGrokBindings(this.config, printFn);
+        for (const [name, value] of Object.entries(grokBindings)) {
+            this.globalContext.variables.set(name, value);
         }
         // Inject user variables
         if (this.config.variables) {
@@ -47,124 +67,360 @@ export class Runtime {
     async execute(program) {
         this.startTime = Date.now();
         this.output = [];
+        this.testResults = [];
         let returnValue = null;
+        let error;
         try {
-            for (const statement of program.body) {
-                const result = await this.executeStatement(statement, this.globalContext);
-                if (result instanceof ReturnValue) {
+            for (const statement of (program.statements || program.body || [])) {
+                const result = await this.executeNode(statement, this.globalContext);
+                if (result instanceof ReturnSignal) {
                     returnValue = result.value;
                     break;
                 }
             }
         }
-        catch (error) {
-            if (error instanceof ReturnValue) {
-                returnValue = error.value;
+        catch (err) {
+            if (err instanceof ReturnSignal) {
+                returnValue = err.value;
             }
             else {
-                throw error;
+                error = err instanceof Error ? err.message : String(err);
             }
         }
         return {
+            success: !error,
             output: this.output,
+            error,
             returnValue,
             duration: Date.now() - this.startTime,
+            testResults: this.testResults.length > 0 ? this.testResults : undefined,
         };
     }
-    async executeStatement(stmt, ctx) {
+    // Normalize old Buddy Script AST nodes to FCS format
+    normalizeNode(node) {
+        const n = node;
+        // Map old BS type names to FCS type names
+        const typeMap = {
+            'VariableDeclaration': 'VarDeclaration',
+            'BlockStatement': 'Block',
+            'IfStatement': 'If',
+            'WhileStatement': 'While',
+            'ForInStatement': 'For',
+            'ReturnStatement': 'Return',
+            'BreakStatement': 'Break',
+            'ContinueStatement': 'Continue',
+            'TryStatement': 'Try',
+            'ThrowStatement': 'Throw',
+            'ExpressionStatement': 'ExpressionStmt',
+            'BinaryExpression': 'Binary',
+            'UnaryExpression': 'Unary',
+            'LogicalExpression': 'Binary',
+            'AssignmentExpression': 'Assignment',
+            'CallExpression': 'Call',
+            'MemberExpression': 'Member',
+            'ArrayExpression': 'Array',
+            'ObjectExpression': 'Dict',
+            'ConditionalExpression': 'Ternary',
+            'ArrowFunctionExpression': 'Lambda',
+            'ArrowFunction': 'Lambda',
+            'AwaitExpression': 'Await',
+        };
+        if (n.type === 'ForStatement') {
+            // Detect C-style vs for-in
+            n.type = (n.init !== undefined || n.test !== undefined || n.update !== undefined) ? 'ForCStyle' : 'For';
+        }
+        else if (typeMap[n.type]) {
+            n.type = typeMap[n.type];
+        }
+        // Map old BS field names to FCS field names
+        if (n.type === 'VarDeclaration' && n.init !== undefined && n.initializer === undefined) {
+            n.initializer = n.init;
+            if (n.kind)
+                n.isConst = n.kind === 'const';
+        }
+        if (n.type === 'Block' && n.body && !n.statements) {
+            n.statements = n.body;
+        }
+        if (n.type === 'If') {
+            if (n.test && !n.condition)
+                n.condition = n.test;
+            if (n.consequent && !n.thenBranch)
+                n.thenBranch = n.consequent;
+            if (n.alternate !== undefined && n.elseBranch === undefined)
+                n.elseBranch = n.alternate;
+            if (n.body && !n.thenBranch)
+                n.thenBranch = n.body;
+        }
+        if (n.type === 'While' && n.test && !n.condition) {
+            n.condition = n.test;
+        }
+        // Map For (for-in): old BS uses left/right, FCS uses variable/iterable
+        if (n.type === 'For') {
+            if (n.left && !n.variable)
+                n.variable = typeof n.left === 'object' ? n.left.name : n.left;
+            if (n.right && !n.iterable)
+                n.iterable = n.right;
+        }
+        if (n.type === 'Try') {
+            if (n.block && !n.tryBlock)
+                n.tryBlock = n.block;
+            if (n.handler && !n.catchClauses) {
+                n.catchClauses = [{
+                        variable: n.handler.param || n.handler.variable,
+                        body: n.handler.body || n.handler,
+                    }];
+            }
+            if (n.finalizer && !n.finallyBlock)
+                n.finallyBlock = n.finalizer;
+        }
+        if (n.type === 'Ternary') {
+            if (n.test && !n.condition)
+                n.condition = n.test;
+        }
+        if (n.type === 'Lambda' && n.params && !n.parameters) {
+            n.parameters = n.params.map((p) => typeof p === 'string' ? p : p.name);
+        }
+        if (n.type === 'Return' && n.argument !== undefined && n.value === undefined) {
+            n.value = n.argument;
+        }
+        if (n.type === 'Throw' && n.argument !== undefined && n.expression === undefined) {
+            n.expression = n.argument;
+        }
+        // Map old-style operators ('+', '-', etc.) to TokenType names ('Plus', 'Minus', etc.)
+        if ((n.type === 'Binary' || n.type === 'Unary' || n.type === 'Assignment') && n.operator) {
+            const opMap = {
+                '+': 'Plus', '-': 'Minus', '*': 'Multiply', '/': 'Divide', '%': 'Modulo', '**': 'Power',
+                '==': 'Equal', '===': 'Equal', '!=': 'NotEqual', '!==': 'NotEqual', '<': 'Less', '>': 'Greater', '<=': 'LessEqual', '>=': 'GreaterEqual',
+                '&&': 'And', '||': 'Or', '!': 'Not',
+                '=': 'Assign', '+=': 'PlusAssign', '-=': 'MinusAssign', '*=': 'MultiplyAssign', '/=': 'DivideAssign',
+            };
+            if (opMap[n.operator])
+                n.operator = opMap[n.operator];
+        }
+        // Map Unary: old BS uses 'argument', FCS uses 'operand'
+        if (n.type === 'Unary' && n.argument && !n.operand) {
+            n.operand = n.argument;
+        }
+        // Map FunctionDeclaration: old BS uses 'params', FCS uses 'parameters'
+        if (n.type === 'FunctionDeclaration' && n.params && !n.parameters) {
+            n.parameters = n.params.map((p) => {
+                if (typeof p === 'string')
+                    return { name: p };
+                return { name: p.name, defaultValue: p.default || p.defaultValue };
+            });
+        }
+        // Map Assignment fields: old BS uses left/right, FCS uses target/value
+        if (n.type === 'Assignment') {
+            if (n.left && !n.target)
+                n.target = n.left;
+            if (n.right !== undefined && n.value === undefined)
+                n.value = n.right;
+        }
+        // Call: callee and arguments are the same in both formats
+        // Map old 'object'/'property' to FCS 'object'/'member' for MemberExpression
+        if (n.type === 'Member' && n.property !== undefined && n.member === undefined) {
+            // Old BS property can be an AstNode (e.g., {type: 'Identifier', name: 'foo'}) or a string
+            n.member = typeof n.property === 'object' ? (n.property.name || n.property.value) : n.property;
+        }
+        // Map 'elements' to 'elements' (same for arrays)
+        // Map 'properties' to 'elements' Map for objects/dicts
+        if (n.type === 'Dict' && n.properties && !(n.elements instanceof Map)) {
+            const map = new Map();
+            for (const p of n.properties) {
+                const key = typeof p.key === 'object' ? (p.key.name || p.key.value) : p.key;
+                map.set(String(key), p.value);
+            }
+            n.elements = map;
+        }
+        return n;
+    }
+    async executeNode(node, ctx) {
         // Check timeout
         if (Date.now() - this.startTime > this.config.timeout) {
-            throw new Error(`Script execution timed out after ${this.config.timeout}ms. Consider breaking the script into smaller parts or increasing the timeout limit.`);
-        }
-        switch (stmt.type) {
-            case 'VariableDeclaration':
-                return this.executeVariableDeclaration(stmt, ctx);
+            throw new Error(`Script timeout after ${this.config.timeout}ms`);
+        }
+        // Normalize old BS AST format
+        node = this.normalizeNode(node);
+        switch (node.type) {
+            // Declarations
+            case 'VarDeclaration':
+                return this.executeVarDeclaration(node, ctx);
             case 'FunctionDeclaration':
-                return this.executeFunctionDeclaration(stmt, ctx);
-            case 'ExpressionStatement':
-                return this.evaluateExpression(stmt.expression, ctx);
-            case 'IfStatement':
-                return this.executeIfStatement(stmt, ctx);
-            case 'WhileStatement':
-                return this.executeWhileStatement(stmt, ctx);
-            case 'ForStatement':
-                return this.executeForStatement(stmt, ctx);
-            case 'ForInStatement':
-                return this.executeForInStatement(stmt, ctx);
-            case 'ReturnStatement':
-                return this.executeReturnStatement(stmt, ctx);
-            case 'TryStatement':
-                return this.executeTryStatement(stmt, ctx);
-            case 'ThrowStatement':
-                return this.executeThrowStatement(stmt, ctx);
-            case 'BreakStatement':
+                return this.executeFunctionDeclaration(node, ctx);
+            case 'ClassDeclaration':
+                return this.executeClassDeclaration(node, ctx);
+            case 'TestDeclaration':
+                return this.executeTestDeclaration(node, ctx);
+            // Statements
+            case 'Block':
+                return this.executeBlock(node, ctx);
+            case 'ExpressionStmt':
+                return this.evaluate(node.expression, ctx);
+            case 'If':
+                return this.executeIfStatement(node, ctx);
+            case 'While':
+                return this.executeWhileStatement(node, ctx);
+            case 'For':
+                return this.executeForStatement(node, ctx);
+            case 'ForCStyle':
+                return this.executeForCStyleStatement(node, ctx);
+            case 'Return':
+                return this.executeReturnStatement(node, ctx);
+            case 'Break':
                 return new BreakSignal();
-            case 'ContinueStatement':
+            case 'Continue':
                 return new ContinueSignal();
-            case 'BlockStatement':
-                return this.executeBlock(stmt, ctx);
-            case 'ImportStatement':
-                // Imports are handled at initialization
-                return null;
+            case 'Try':
+                return this.executeTryStatement(node, ctx);
+            case 'Throw':
+                return this.executeThrowStatement(node, ctx);
+            case 'Import':
+                return this.executeImportStatement(node, ctx);
+            case 'Export':
+                return this.executeExportStatement(node, ctx);
+            case 'Assert':
+                return this.executeAssertStatement(node, ctx);
+            // Expressions (delegated to evaluate)
             default:
-                throw new Error(`Unsupported statement type "${stmt.type}". This may be a syntax error or an unsupported feature.`);
+                return this.evaluate(node, ctx);
         }
     }
-    async executeVariableDeclaration(stmt, ctx) {
-        const value = stmt.init ? await this.evaluateExpression(stmt.init, ctx) : null;
-        ctx.variables.set(stmt.name, value);
+    // ============================================
+    // Statement Execution
+    // ============================================
+    async executeVarDeclaration(node, ctx) {
+        const value = node.initializer
+            ? await this.evaluate(node.initializer, ctx)
+            : null;
+        ctx.variables.set(node.name, value);
         return null;
     }
-    async executeFunctionDeclaration(stmt, ctx) {
+    async executeFunctionDeclaration(node, ctx) {
         const fn = async (...args) => {
             const localCtx = {
                 variables: new Map(),
                 functions: new Map(ctx.functions),
                 parent: ctx,
             };
-            // Bind parameters
-            for (let i = 0; i < stmt.params.length; i++) {
-                const param = stmt.params[i];
-                const value = args[i] !== undefined ? args[i] : (param.defaultValue ? await this.evaluateExpression(param.defaultValue, ctx) : null);
+            // Bind parameters (with named args support)
+            const lastArg = args.length > 0 ? args[args.length - 1] : null;
+            const hasNamedArgs = lastArg !== null && typeof lastArg === 'object' && lastArg !== null && '__namedArgs' in lastArg;
+            const namedArgs = hasNamedArgs
+                ? args.pop().__namedArgs
+                : {};
+            for (let i = 0; i < node.parameters.length; i++) {
+                const param = node.parameters[i];
+                let value;
+                if (namedArgs[param.name] !== undefined) {
+                    value = namedArgs[param.name];
+                }
+                else if (args[i] !== undefined) {
+                    value = args[i];
+                }
+                else if (param.defaultValue) {
+                    value = await this.evaluate(param.defaultValue, ctx);
+                }
+                else {
+                    value = null;
+                }
                 localCtx.variables.set(param.name, value);
             }
             try {
-                const result = await this.executeBlock(stmt.body, localCtx);
-                if (result instanceof ReturnValue) {
+                const result = await this.executeBlock(node.body, localCtx);
+                if (result instanceof ReturnSignal) {
                     return result.value;
                 }
                 return null;
             }
-            catch (error) {
-                if (error instanceof ReturnValue) {
-                    return error.value;
+            catch (err) {
+                if (err instanceof ReturnSignal) {
+                    return err.value;
                 }
-                throw error;
+                throw err;
             }
         };
-        ctx.functions.set(stmt.name, fn);
-        ctx.variables.set(stmt.name, fn);
+        ctx.functions.set(node.name, fn);
+        ctx.variables.set(node.name, fn);
         return null;
     }
-    async executeIfStatement(stmt, ctx) {
-        const condition = await this.evaluateExpression(stmt.condition, ctx);
-        if (this.isTruthy(condition)) {
-            return this.executeBlock(stmt.consequent, ctx);
-        }
-        else if (stmt.alternate) {
-            if (stmt.alternate.type === 'IfStatement') {
-                return this.executeIfStatement(stmt.alternate, ctx);
+    async executeClassDeclaration(node, ctx) {
+        const classConstructor = async (...args) => {
+            const instance = {};
+            for (const member of node.members) {
+                if (member.type === 'VarDeclaration') {
+                    const varDecl = member;
+                    instance[varDecl.name] = varDecl.initializer
+                        ? await this.evaluate(varDecl.initializer, ctx)
+                        : null;
+                }
+                else if (member.type === 'FunctionDeclaration') {
+                    const fnDecl = member;
+                    instance[fnDecl.name] = async (...methodArgs) => {
+                        const methodCtx = {
+                            variables: new Map([['this', instance]]),
+                            functions: new Map(ctx.functions),
+                            parent: ctx,
+                        };
+                        for (let i = 0; i < fnDecl.parameters.length; i++) {
+                            methodCtx.variables.set(fnDecl.parameters[i].name, methodArgs[i]);
+                        }
+                        const result = await this.executeBlock(fnDecl.body, methodCtx);
+                        if (result instanceof ReturnSignal) {
+                            return result.value;
+                        }
+                        return null;
+                    };
+                }
             }
-            else {
-                return this.executeBlock(stmt.alternate, ctx);
+            if (instance.constructor && typeof instance.constructor === 'function') {
+                await instance.constructor(...args);
             }
+            return instance;
+        };
+        ctx.variables.set(node.name, classConstructor);
+        return null;
+    }
+    async executeTestDeclaration(node, ctx) {
+        if (!this.config.verbose) {
+            return null;
+        }
+        try {
+            await this.executeBlock(node.body, ctx);
+            this.testResults.push({ name: node.name, passed: true });
+            this.output.push(`✓ ${node.name}`);
+        }
+        catch (err) {
+            const errorMsg = err instanceof Error ? err.message : String(err);
+            this.testResults.push({ name: node.name, passed: false, error: errorMsg });
+            this.output.push(`✗ ${node.name}: ${errorMsg}`);
+        }
+        return null;
+    }
+    async executeBlock(node, ctx) {
+        for (const stmt of (node.statements || node.body || [])) {
+            const result = await this.executeNode(stmt, ctx);
+            if (result instanceof ReturnSignal ||
+                result instanceof BreakSignal ||
+                result instanceof ContinueSignal) {
+                return result;
+            }
+        }
+        return null;
+    }
+    async executeIfStatement(node, ctx) {
+        const condition = await this.evaluate(node.condition, ctx);
+        if (this.isTruthy(condition)) {
+            return this.executeNode(node.thenBranch, ctx);
+        }
+        else if (node.elseBranch) {
+            return this.executeNode(node.elseBranch, ctx);
         }
         return null;
     }
-    async executeWhileStatement(stmt, ctx) {
-        while (this.isTruthy(await this.evaluateExpression(stmt.condition, ctx))) {
-            const result = await this.executeBlock(stmt.body, ctx);
-            if (result instanceof ReturnValue)
+    async executeWhileStatement(node, ctx) {
+        while (this.isTruthy(await this.evaluate(node.condition, ctx))) {
+            const result = await this.executeNode(node.body, ctx);
+            if (result instanceof ReturnSignal)
                 return result;
             if (result instanceof BreakSignal)
                 break;
@@ -173,330 +429,386 @@ export class Runtime {
         }
         return null;
     }
-    async executeForStatement(stmt, ctx) {
-        // Create local context for loop-scoped variables (like the init var)
-        // Use empty map - only loop variables go here, parent lookup for outer vars
+    async executeForStatement(node, ctx) {
+        const iterable = await this.evaluate(node.iterable, ctx);
+        if (!Array.isArray(iterable) && typeof iterable !== 'object') {
+            throw new Error('for-in requires an iterable (array or object)');
+        }
+        const items = Array.isArray(iterable)
+            ? iterable
+            : Object.entries(iterable);
         const localCtx = {
             variables: new Map(),
             functions: ctx.functions,
             parent: ctx,
         };
-        // Execute init
-        if (stmt.init) {
-            if (stmt.init.type === 'VariableDeclaration') {
-                await this.executeVariableDeclaration(stmt.init, localCtx);
-            }
-            else {
-                await this.evaluateExpression(stmt.init, localCtx);
-            }
-        }
-        // Loop while test is true
-        while (stmt.test === null || this.isTruthy(await this.evaluateExpression(stmt.test, localCtx))) {
-            const result = await this.executeBlock(stmt.body, localCtx);
-            if (result instanceof ReturnValue)
+        for (const item of items) {
+            localCtx.variables.set(node.variable, item);
+            const result = await this.executeNode(node.body, localCtx);
+            if (result instanceof ReturnSignal)
                 return result;
             if (result instanceof BreakSignal)
                 break;
-            if (result instanceof ContinueSignal) {
-                // Still run the update on continue
-                if (stmt.update) {
-                    await this.evaluateExpression(stmt.update, localCtx);
-                }
+            if (result instanceof ContinueSignal)
                 continue;
-            }
-            // Execute update
-            if (stmt.update) {
-                await this.evaluateExpression(stmt.update, localCtx);
-            }
         }
         return null;
     }
-    async executeForInStatement(stmt, ctx) {
-        const iterable = await this.evaluateExpression(stmt.iterable, ctx);
-        if (!Array.isArray(iterable) && typeof iterable !== 'object') {
-            throw new Error('for-in loop requires an array or object to iterate over. Got: ' + (typeof iterable));
-        }
-        const items = Array.isArray(iterable) ? iterable : Object.entries(iterable);
-        // Create local context with only the loop variable - parent lookup for outer vars
+    async executeForCStyleStatement(node, ctx) {
         const localCtx = {
             variables: new Map(),
             functions: ctx.functions,
             parent: ctx,
         };
-        for (const item of items) {
-            localCtx.variables.set(stmt.variable, item);
-            const result = await this.executeBlock(stmt.body, localCtx);
-            if (result instanceof ReturnValue)
+        // Execute init (normalize in case of old BS format)
+        if (node.init) {
+            const initNode = this.normalizeNode(node.init);
+            if (initNode.type === 'VarDeclaration') {
+                await this.executeVarDeclaration(initNode, localCtx);
+            }
+            else {
+                await this.evaluate(initNode, localCtx);
+            }
+        }
+        // Loop while test is true
+        while (node.test === null || this.isTruthy(await this.evaluate(node.test, localCtx))) {
+            const result = await this.executeNode(node.body, localCtx);
+            if (result instanceof ReturnSignal)
                 return result;
             if (result instanceof BreakSignal)
                 break;
-            if (result instanceof ContinueSignal)
+            if (result instanceof ContinueSignal) {
+                if (node.update) {
+                    await this.evaluate(node.update, localCtx);
+                }
                 continue;
+            }
+            if (node.update) {
+                await this.evaluate(node.update, localCtx);
+            }
         }
         return null;
     }
-    async executeReturnStatement(stmt, ctx) {
-        const value = stmt.argument ? await this.evaluateExpression(stmt.argument, ctx) : null;
-        return new ReturnValue(value);
+    async executeReturnStatement(node, ctx) {
+        const value = node.value ? await this.evaluate(node.value, ctx) : null;
+        return new ReturnSignal(value);
     }
-    async executeTryStatement(stmt, ctx) {
+    async executeTryStatement(node, ctx) {
         try {
-            return await this.executeBlock(stmt.block, ctx);
+            return await this.executeBlock(node.tryBlock, ctx);
         }
-        catch (error) {
-            if (stmt.handler) {
+        catch (err) {
+            for (const clause of node.catchClauses) {
                 const localCtx = {
                     variables: new Map(ctx.variables),
                     functions: ctx.functions,
                     parent: ctx,
                 };
-                const errorValue = error instanceof Error ? {
-                    message: error.message,
-                    stack: error.stack,
-                } : error;
-                localCtx.variables.set(stmt.handler.param, errorValue);
-                return this.executeBlock(stmt.handler.body, localCtx);
+                if (clause.variable) {
+                    const errorValue = err instanceof Error
+                        ? { message: err.message, stack: err.stack }
+                        : err;
+                    localCtx.variables.set(clause.variable, errorValue);
+                }
+                return this.executeBlock(clause.body, localCtx);
+            }
+            throw err;
+        }
+        finally {
+            if (node.finallyBlock) {
+                await this.executeBlock(node.finallyBlock, ctx);
             }
-            throw error;
         }
     }
-    async executeThrowStatement(stmt, ctx) {
-        const value = await this.evaluateExpression(stmt.argument, ctx);
+    async executeThrowStatement(node, ctx) {
+        const value = await this.evaluate(node.expression, ctx);
         if (typeof value === 'string') {
             throw new Error(value);
         }
         throw value;
     }
-    async executeBlock(block, ctx) {
-        // Use the same context - don't create a new scope for blocks
-        // New variables declared inside will still be added to this context
-        // but assignments to existing variables will propagate up via setVariable
-        for (const stmt of block.body) {
-            const result = await this.executeStatement(stmt, ctx);
-            if (result instanceof ReturnValue || result instanceof BreakSignal || result instanceof ContinueSignal) {
-                return result;
-            }
+    async executeImportStatement(_node, _ctx) {
+        // Imports are handled at initialization or by module system
+        return null;
+    }
+    async executeExportStatement(node, ctx) {
+        // Execute the declaration normally - exports don't change runtime behavior
+        return this.executeNode(node.declaration, ctx);
+    }
+    async executeAssertStatement(node, ctx) {
+        const condition = await this.evaluate(node.condition, ctx);
+        if (!this.isTruthy(condition)) {
+            const message = node.message || 'Assertion failed';
+            throw new Error(message);
         }
         return null;
     }
     // ============================================
     // Expression Evaluation
     // ============================================
-    async evaluateExpression(expr, ctx) {
-        switch (expr.type) {
+    async evaluate(node, ctx) {
+        node = this.normalizeNode(node);
+        switch (node.type) {
             case 'Literal':
-                return expr.value;
+                return node.value;
             case 'Identifier':
-                return this.lookupVariable(expr.name, ctx);
-            case 'BinaryExpression':
-                return this.evaluateBinaryExpression(expr, ctx);
-            case 'UnaryExpression':
-                return this.evaluateUnaryExpression(expr, ctx);
-            case 'LogicalExpression':
-                return this.evaluateLogicalExpression(expr, ctx);
-            case 'AssignmentExpression':
-                return this.evaluateAssignmentExpression(expr, ctx);
-            case 'CallExpression':
-                return this.evaluateCallExpression(expr, ctx);
-            case 'MemberExpression':
-                return this.evaluateMemberExpression(expr, ctx);
-            case 'ArrayExpression':
-                return this.evaluateArrayExpression(expr, ctx);
-            case 'ObjectExpression':
-                return this.evaluateObjectExpression(expr, ctx);
-            case 'ConditionalExpression':
-                return this.evaluateConditionalExpression(expr, ctx);
-            case 'AwaitExpression':
-                return this.evaluateExpression(expr.argument, ctx);
-            case 'ArrowFunction':
-                return this.createArrowFunction(expr, ctx);
+                return this.lookupVariable(node.name, ctx);
+            case 'Binary':
+                return this.evaluateBinary(node, ctx);
+            case 'Unary':
+                return this.evaluateUnary(node, ctx);
+            case 'Assignment':
+                return this.evaluateAssignment(node, ctx);
+            case 'Call':
+                return this.evaluateCall(node, ctx);
+            case 'Member':
+                return this.evaluateMember(node, ctx);
+            case 'Index':
+                return this.evaluateIndex(node, ctx);
+            case 'Array':
+                return this.evaluateArray(node, ctx);
+            case 'Dict':
+                return this.evaluateDict(node, ctx);
+            case 'Lambda':
+                return this.evaluateLambda(node, ctx);
+            case 'Interpolation':
+                return this.evaluateInterpolation(node, ctx);
+            case 'Ternary':
+                return this.evaluateTernary(node, ctx);
+            case 'Await':
+                // Await just evaluates the argument (our runtime is already async)
+                return this.evaluate(node.argument, ctx);
             default:
-                throw new Error(`Unsupported expression type "${expr.type}". Check syntax or upgrade to a newer version.`);
+                throw new Error(`Unknown expression type: ${node.type}`);
         }
     }
     lookupVariable(name, ctx) {
-        if (ctx.variables.has(name)) {
-            return ctx.variables.get(name);
+        // Walk up scope chain checking variables first
+        let current = ctx;
+        while (current) {
+            if (current.variables.has(name)) {
+                return current.variables.get(name);
+            }
+            current = current.parent;
         }
+        // Then check functions (builtins)
         if (ctx.functions.has(name)) {
             return ctx.functions.get(name);
         }
-        if (ctx.parent) {
-            return this.lookupVariable(name, ctx.parent);
+        throw new Error(`Undefined variable: ${name}`);
+    }
+    setVariable(name, value, ctx) {
+        let current = ctx;
+        while (current) {
+            if (current.variables.has(name)) {
+                current.variables.set(name, value);
+                return;
+            }
+            current = current.parent;
         }
-        throw new Error(`Variable "${name}" is not defined. Check the variable name or define it before use.`);
+        ctx.variables.set(name, value);
     }
-    async evaluateBinaryExpression(expr, ctx) {
-        const left = await this.evaluateExpression(expr.left, ctx);
-        const right = await this.evaluateExpression(expr.right, ctx);
-        switch (expr.operator) {
-            case '+':
+    async evaluateBinary(node, ctx) {
+        const left = await this.evaluate(node.left, ctx);
+        const right = await this.evaluate(node.right, ctx);
+        switch (node.operator) {
+            case TokenType.Plus:
                 if (typeof left === 'string' || typeof right === 'string') {
                     return String(left) + String(right);
                 }
                 return left + right;
-            case '-': return left - right;
-            case '*':
-                // Support string repetition: "x" * 3 = "xxx"
+            case TokenType.Minus:
+                return left - right;
+            case TokenType.Multiply:
                 if (typeof left === 'string' && typeof right === 'number') {
                     return left.repeat(right);
                 }
                 return left * right;
-            case '/': return left / right;
-            case '%': return left % right;
-            case '**': return Math.pow(left, right);
-            case '==':
-            case '===': return left === right;
-            case '!=':
-            case '!==': return left !== right;
-            case '<': return left < right;
-            case '<=': return left <= right;
-            case '>': return left > right;
-            case '>=': return left >= right;
+            case TokenType.Divide:
+                return left / right;
+            case TokenType.Modulo:
+                return left % right;
+            case TokenType.Power:
+                return Math.pow(left, right);
+            case TokenType.Equal:
+                return left === right;
+            case TokenType.NotEqual:
+                return left !== right;
+            case TokenType.Less:
+                return left < right;
+            case TokenType.LessEqual:
+                return left <= right;
+            case TokenType.Greater:
+                return left > right;
+            case TokenType.GreaterEqual:
+                return left >= right;
+            case TokenType.And:
+                return this.isTruthy(left) && this.isTruthy(right);
+            case TokenType.Or:
+                return this.isTruthy(left) || this.isTruthy(right);
             default:
-                throw new Error(`Unsupported binary operator "${expr.operator}". Valid operators: +, -, *, /, %, **, ==, !=, <, <=, >, >=`);
+                throw new Error(`Unknown binary operator: ${node.operator}`);
         }
     }
-    async evaluateUnaryExpression(expr, ctx) {
-        const argument = await this.evaluateExpression(expr.argument, ctx);
-        switch (expr.operator) {
-            case '-': return -argument;
-            case '!': return !this.isTruthy(argument);
+    async evaluateUnary(node, ctx) {
+        const operand = await this.evaluate(node.operand, ctx);
+        switch (node.operator) {
+            case TokenType.Minus:
+                return -operand;
+            case TokenType.Not:
+                return !this.isTruthy(operand);
             default:
-                throw new Error(`Unsupported unary operator "${expr.operator}". Valid operators: -, !`);
-        }
-    }
-    async evaluateLogicalExpression(expr, ctx) {
-        const left = await this.evaluateExpression(expr.left, ctx);
-        if (expr.operator === '&&') {
-            if (!this.isTruthy(left))
-                return left;
-            return this.evaluateExpression(expr.right, ctx);
-        }
-        else {
-            if (this.isTruthy(left))
-                return left;
-            return this.evaluateExpression(expr.right, ctx);
+                throw new Error(`Unknown unary operator: ${node.operator}`);
         }
     }
-    async evaluateAssignmentExpression(expr, ctx) {
-        let value = await this.evaluateExpression(expr.right, ctx);
-        if (expr.operator === '+=') {
-            const current = await this.evaluateExpression(expr.left, ctx);
-            if (typeof current === 'string' || typeof value === 'string') {
-                value = String(current) + String(value);
-            }
-            else {
-                value = current + value;
+    async evaluateAssignment(node, ctx) {
+        let value = await this.evaluate(node.value, ctx);
+        if (node.operator !== TokenType.Assign) {
+            const current = await this.evaluate(node.target, ctx);
+            switch (node.operator) {
+                case TokenType.PlusAssign:
+                    if (typeof current === 'string' || typeof value === 'string') {
+                        value = String(current) + String(value);
+                    }
+                    else {
+                        value = current + value;
+                    }
+                    break;
+                case TokenType.MinusAssign:
+                    value = current - value;
+                    break;
+                case TokenType.MultiplyAssign:
+                    value = current * value;
+                    break;
+                case TokenType.DivideAssign:
+                    value = current / value;
+                    break;
             }
         }
-        else if (expr.operator === '-=') {
-            const current = await this.evaluateExpression(expr.left, ctx);
-            value = current - value;
+        if (node.target.type === 'Identifier') {
+            this.setVariable(node.target.name, value, ctx);
         }
-        if (expr.left.type === 'Identifier') {
-            this.setVariable(expr.left.name, value, ctx);
+        else if (node.target.type === 'Member') {
+            const member = node.target;
+            const object = await this.evaluate(member.object, ctx);
+            object[member.member] = value;
         }
-        else if (expr.left.type === 'MemberExpression') {
-            const member = expr.left;
-            const object = await this.evaluateExpression(member.object, ctx);
-            const property = member.computed
-                ? await this.evaluateExpression(member.property, ctx)
-                : member.property.name;
-            object[property] = value;
+        else if (node.target.type === 'Index') {
+            const index = node.target;
+            const object = await this.evaluate(index.object, ctx);
+            const key = await this.evaluate(index.index, ctx);
+            object[key] = value;
         }
         return value;
     }
-    setVariable(name, value, ctx) {
-        // Find where the variable is defined
-        let current = ctx;
-        while (current) {
-            if (current.variables.has(name)) {
-                current.variables.set(name, value);
-                return;
-            }
-            current = current.parent;
-        }
-        // If not found, create in current context
-        ctx.variables.set(name, value);
-    }
-    async evaluateCallExpression(expr, ctx) {
-        const callee = await this.evaluateExpression(expr.callee, ctx);
+    async evaluateCall(node, ctx) {
+        const callee = await this.evaluate(node.callee, ctx);
         if (typeof callee !== 'function') {
-            throw new Error(`Cannot call ${JSON.stringify(callee)}: it is not a function. Check if the function name is correct.`);
+            throw new Error(`${JSON.stringify(callee)} is not a function`);
         }
         const args = [];
-        for (const arg of expr.arguments) {
-            args.push(await this.evaluateExpression(arg, ctx));
+        for (const arg of node.arguments) {
+            args.push(await this.evaluate(arg, ctx));
+        }
+        // Handle named arguments
+        if (node.namedArgs && Object.keys(node.namedArgs).length > 0) {
+            const namedValues = {};
+            for (const [name, expr] of Object.entries(node.namedArgs)) {
+                namedValues[name] = await this.evaluate(expr, ctx);
+            }
+            args.push({ __namedArgs: namedValues });
         }
-        return callee(...args);
+        const result = callee(...args);
+        return result instanceof Promise ? await result : result;
     }
-    async evaluateMemberExpression(expr, ctx) {
-        const object = await this.evaluateExpression(expr.object, ctx);
+    async evaluateMember(node, ctx) {
+        const object = await this.evaluate(node.object, ctx);
         if (object === null || object === undefined) {
-            throw new Error('Cannot read property of null or undefined. Ensure the object exists before accessing its properties.');
+            throw new Error('Cannot read property of null or undefined');
         }
-        const property = expr.computed
-            ? await this.evaluateExpression(expr.property, ctx)
-            : expr.property.name;
         const obj = object;
-        const value = obj[property];
-        // Bind methods
+        const value = obj[node.member];
         if (typeof value === 'function') {
             return value.bind(obj);
         }
         return value;
     }
-    async evaluateArrayExpression(expr, ctx) {
-        const elements = [];
-        for (const element of expr.elements) {
-            elements.push(await this.evaluateExpression(element, ctx));
+    async evaluateIndex(node, ctx) {
+        const object = await this.evaluate(node.object, ctx);
+        const index = await this.evaluate(node.index, ctx);
+        if (object === null || object === undefined) {
+            throw new Error('Cannot index null or undefined');
         }
-        return elements;
+        return object[index];
     }
-    async evaluateObjectExpression(expr, ctx) {
-        const obj = {};
-        for (const prop of expr.properties) {
-            const key = typeof prop.key === 'string'
-                ? prop.key
-                : await this.evaluateExpression(prop.key, ctx);
-            obj[key] = await this.evaluateExpression(prop.value, ctx);
+    async evaluateArray(node, ctx) {
+        const elements = [];
+        for (const element of node.elements) {
+            elements.push(await this.evaluate(element, ctx));
         }
-        return obj;
+        return elements;
     }
-    async evaluateConditionalExpression(expr, ctx) {
-        const test = await this.evaluateExpression(expr.test, ctx);
-        if (this.isTruthy(test)) {
-            return this.evaluateExpression(expr.consequent, ctx);
+    async evaluateDict(node, ctx) {
+        const dict = {};
+        for (const [key, valueNode] of node.elements) {
+            dict[key] = await this.evaluate(valueNode, ctx);
         }
-        return this.evaluateExpression(expr.alternate, ctx);
+        return dict;
     }
-    createArrowFunction(expr, ctx) {
-        const arrow = expr;
+    evaluateLambda(node, ctx) {
         return async (...args) => {
             const localCtx = {
-                variables: new Map(ctx.variables),
+                variables: new Map(),
                 functions: ctx.functions,
                 parent: ctx,
             };
-            for (let i = 0; i < arrow.params.length; i++) {
-                localCtx.variables.set(arrow.params[i].name, args[i]);
+            for (let i = 0; i < node.parameters.length; i++) {
+                localCtx.variables.set(node.parameters[i], args[i]);
             }
-            if (arrow.body.type === 'BlockStatement') {
-                const result = await this.executeBlock(arrow.body, localCtx);
-                if (result instanceof ReturnValue) {
+            if (node.body.type === 'Block') {
+                const result = await this.executeBlock(node.body, localCtx);
+                if (result instanceof ReturnSignal) {
                     return result.value;
                 }
                 return null;
             }
-            return this.evaluateExpression(arrow.body, localCtx);
+            return this.evaluate(node.body, localCtx);
         };
     }
+    async evaluateInterpolation(node, ctx) {
+        let result = '';
+        for (const part of node.parts) {
+            const value = await this.evaluate(part, ctx);
+            result += String(value);
+        }
+        return result;
+    }
+    async evaluateTernary(node, ctx) {
+        const condition = await this.evaluate(node.condition, ctx);
+        if (this.isTruthy(condition)) {
+            return this.evaluate(node.consequent, ctx);
+        }
+        return this.evaluate(node.alternate, ctx);
+    }
+    // ============================================
+    // Helpers
+    // ============================================
     isTruthy(value) {
         if (value === null || value === undefined || value === false || value === 0 || value === '') {
             return false;
         }
         return true;
     }
+    getTestResults() {
+        return this.testResults;
+    }
+    getOutput() {
+        return this.output;
+    }
+}
+/** @deprecated Use FCSRuntime instead */
+export const Runtime = FCSRuntime;
+export function createRuntime(config = {}) {
+    return new FCSRuntime(config);
 }
 //# sourceMappingURL=runtime.js.map