@phuetz/code-buddy 0.1.0 → 0.1.1

package/dist/scripting/parser.js

@@ -1,18 +1,27 @@
 /**
- * Buddy Script Parser
+ * Unified Script Parser
  *
- * Parses tokens into an Abstract Syntax Tree (AST)
+ * Based on FCS parser (superset) with Buddy Script additions:
+ * - AwaitExpression in unary parsing
+ * - ForCStyle statement (C-style for loops)
+ * - Export keyword
+ * - Question token for ternary (instead of checking Colon value)
+ * - Arrow functions / lambdas
+ *
+ * Extensions: .bs (primary), .fcs (backward-compatible alias)
  */
-import { TokenType } from './types.js';
+import { TokenType, } from './types.js';
+import { tokenize as lexerTokenize } from './lexer.js';
 import { createLoopGuard, LoopTimeoutError } from '../utils/errors.js';
 /** Maximum recursion depth for recursive descent parsing */
 const MAX_RECURSION_DEPTH = 500;
-export class Parser {
+export class FCSParser {
     tokens;
     current = 0;
     recursionDepth = 0;
     constructor(tokens) {
-        this.tokens = tokens;
+        // Filter out comments
+        this.tokens = tokens.filter(t => t.type !== TokenType.Comment);
     }
     /**
      * Track recursion depth to prevent stack overflow on deeply nested input
@@ -27,37 +36,59 @@ export class Parser {
         this.recursionDepth--;
     }
     parse() {
-        const body = [];
+        const statements = [];
         const guard = createLoopGuard({
             maxIterations: 100000,
-            context: 'BuddyScript program parsing',
+            context: 'program parsing',
         });
         while (!this.isAtEnd()) {
             guard();
-            const stmt = this.declaration();
+            this.skipNewlines();
+            if (this.isAtEnd())
+                break;
+            const stmt = this.parseDeclaration();
             if (stmt) {
-                body.push(stmt);
+                statements.push(stmt);
             }
+            this.skipNewlines();
         }
-        return { type: 'Program', body };
+        return { type: 'Program', statements };
     }
-    declaration() {
-        this.enterRecursion('declaration');
+    // ============================================
+    // Statement Parsing
+    // ============================================
+    parseDeclaration() {
+        this.enterRecursion('parseDeclaration');
         try {
-            if (this.match(TokenType.LET, TokenType.CONST)) {
-                return this.variableDeclaration();
+            // Check for decorators
+            const decoratorGuard = createLoopGuard({
+                maxIterations: 1000,
+                context: 'decorator parsing',
+            });
+            while (this.match(TokenType.Decorator)) {
+                decoratorGuard();
+                // Decorators stored but not used yet
+                void this.previous().value;
+            }
+            if (this.matchKeyword('func', 'function') || this.matchKeyword('async')) {
+                return this.parseFunctionDeclaration();
+            }
+            if (this.matchKeyword('class')) {
+                return this.parseClassDeclaration();
             }
-            if (this.check(TokenType.ASYNC) && this.checkNext(TokenType.FUNCTION)) {
-                this.advance(); // async
-                return this.functionDeclaration(true);
+            if (this.matchKeyword('let', 'const', 'var')) {
+                return this.parseVarDeclaration();
             }
-            if (this.match(TokenType.FUNCTION)) {
-                return this.functionDeclaration(false);
+            if (this.matchKeyword('import')) {
+                return this.parseImportStatement();
             }
-            if (this.match(TokenType.IMPORT)) {
-                return this.importStatement();
+            if (this.matchKeyword('export')) {
+                return this.parseExportStatement();
             }
-            return this.statement();
+            if (this.matchKeyword('test')) {
+                return this.parseTestDeclaration();
+            }
+            return this.parseStatement();
         }
         catch (error) {
             // Re-throw recursion/loop errors without synchronizing
@@ -71,472 +102,597 @@ export class Parser {
             this.exitRecursion();
         }
     }
-    variableDeclaration() {
-        const kind = this.previous().value === 'const' ? 'const' : 'let';
-        const name = this.consume(TokenType.IDENTIFIER, 'Expected variable name').value;
-        let init = null;
-        if (this.match(TokenType.ASSIGN)) {
-            init = this.expression();
-        }
-        this.consumeOptional(TokenType.SEMICOLON);
+    parseStatement() {
+        if (this.matchKeyword('if'))
+            return this.parseIfStatement();
+        if (this.matchKeyword('while'))
+            return this.parseWhileStatement();
+        if (this.matchKeyword('for'))
+            return this.parseForStatement();
+        if (this.matchKeyword('return'))
+            return this.parseReturnStatement();
+        if (this.matchKeyword('break'))
+            return this.parseBreakStatement();
+        if (this.matchKeyword('continue'))
+            return this.parseContinueStatement();
+        if (this.matchKeyword('try'))
+            return this.parseTryStatement();
+        if (this.matchKeyword('throw'))
+            return this.parseThrowStatement();
+        if (this.matchKeyword('assert'))
+            return this.parseAssertStatement();
+        if (this.match(TokenType.LeftBrace))
+            return this.parseBlockStatement();
+        return this.parseExpressionStatement();
+    }
+    parseFunctionDeclaration() {
+        const isAsync = this.previous().value === 'async';
+        if (isAsync) {
+            this.consumeKeyword('func', 'function');
+        }
+        const name = this.consume(TokenType.Identifier, "Expected function name").value;
+        this.consume(TokenType.LeftParen, "Expected '(' after function name");
+        const parameters = this.parseParameters();
+        this.consume(TokenType.RightParen, "Expected ')' after parameters");
+        let returnType;
+        if (this.match(TokenType.Colon)) {
+            returnType = this.consume(TokenType.Identifier, "Expected return type").value;
+        }
+        this.consume(TokenType.LeftBrace, "Expected '{' before function body");
+        const body = this.parseBlockStatement();
         return {
-            type: 'VariableDeclaration',
-            kind,
+            type: 'FunctionDeclaration',
             name,
-            init,
+            parameters,
+            body,
+            isAsync,
+            returnType,
         };
     }
-    functionDeclaration(isAsync) {
-        const name = this.consume(TokenType.IDENTIFIER, 'Expected function name').value;
-        this.consume(TokenType.LPAREN, "Expected '(' after function name");
-        const params = [];
-        if (!this.check(TokenType.RPAREN)) {
+    parseParameters() {
+        const parameters = [];
+        if (!this.check(TokenType.RightParen)) {
             do {
-                const paramName = this.consume(TokenType.IDENTIFIER, 'Expected parameter name').value;
+                const name = this.consume(TokenType.Identifier, "Expected parameter name").value;
+                let type;
                 let defaultValue;
-                if (this.match(TokenType.ASSIGN)) {
-                    defaultValue = this.expression();
+                if (this.match(TokenType.Colon)) {
+                    type = this.consume(TokenType.Identifier, "Expected parameter type").value;
+                }
+                if (this.match(TokenType.Assign)) {
+                    defaultValue = this.parseExpression();
                 }
-                params.push({ name: paramName, defaultValue });
-            } while (this.match(TokenType.COMMA));
+                parameters.push({ name, type, defaultValue });
+            } while (this.match(TokenType.Comma));
         }
-        this.consume(TokenType.RPAREN, "Expected ')' after parameters");
-        this.consume(TokenType.LBRACE, "Expected '{' before function body");
-        const body = this.block();
+        return parameters;
+    }
+    parseVarDeclaration() {
+        const keyword = this.previous().value;
+        const isConst = keyword === 'const';
+        const name = this.consume(TokenType.Identifier, "Expected variable name").value;
+        let varType;
+        if (this.match(TokenType.Colon)) {
+            varType = this.consume(TokenType.Identifier, "Expected type").value;
+        }
+        let initializer = null;
+        if (this.match(TokenType.Assign)) {
+            initializer = this.parseExpression();
+        }
+        else if (isConst) {
+            throw new Error("Const variable must be initialized");
+        }
+        this.consumeStatementEnd();
         return {
-            type: 'FunctionDeclaration',
+            type: 'VarDeclaration',
             name,
-            params,
-            body,
-            async: isAsync,
+            initializer,
+            isConst,
+            varType,
         };
     }
-    importStatement() {
-        const module = this.consume(TokenType.IDENTIFIER, 'Expected module name').value;
-        this.consumeOptional(TokenType.SEMICOLON);
+    parseClassDeclaration() {
+        const name = this.consume(TokenType.Identifier, "Expected class name").value;
+        let baseClass;
+        if (this.match(TokenType.Colon)) {
+            baseClass = this.consume(TokenType.Identifier, "Expected base class name").value;
+        }
+        this.consume(TokenType.LeftBrace, "Expected '{' before class body");
+        const members = [];
+        const guard = createLoopGuard({
+            maxIterations: 10000,
+            context: 'class body parsing',
+        });
+        while (!this.check(TokenType.RightBrace) && !this.isAtEnd()) {
+            guard();
+            this.skipNewlines();
+            if (this.check(TokenType.RightBrace))
+                break;
+            if (this.matchKeyword('func', 'function', 'async')) {
+                members.push(this.parseFunctionDeclaration());
+            }
+            else if (this.matchKeyword('let', 'const', 'var')) {
+                members.push(this.parseVarDeclaration());
+            }
+            else {
+                // Skip unexpected tokens in class body to prevent infinite loop
+                this.advance();
+            }
+            this.skipNewlines();
+        }
+        this.consume(TokenType.RightBrace, "Expected '}' after class body");
         return {
-            type: 'ImportStatement',
-            module,
+            type: 'ClassDeclaration',
+            name,
+            baseClass,
+            members,
         };
     }
-    statement() {
-        if (this.match(TokenType.IF))
-            return this.ifStatement();
-        if (this.match(TokenType.WHILE))
-            return this.whileStatement();
-        if (this.match(TokenType.FOR))
-            return this.forStatement();
-        if (this.match(TokenType.RETURN))
-            return this.returnStatement();
-        if (this.match(TokenType.TRY))
-            return this.tryStatement();
-        if (this.match(TokenType.THROW))
-            return this.throwStatement();
-        if (this.match(TokenType.BREAK))
-            return this.breakStatement();
-        if (this.match(TokenType.CONTINUE))
-            return this.continueStatement();
-        if (this.match(TokenType.LBRACE))
-            return this.block();
-        return this.expressionStatement();
-    }
-    ifStatement() {
-        this.consume(TokenType.LPAREN, "Expected '(' after 'if'");
-        const condition = this.expression();
-        this.consume(TokenType.RPAREN, "Expected ')' after condition");
-        let consequent;
-        if (this.match(TokenType.LBRACE)) {
-            consequent = this.block();
-        }
-        else {
-            consequent = {
-                type: 'BlockStatement',
-                body: [this.statement()],
-            };
-        }
-        let alternate = null;
-        if (this.match(TokenType.ELSE)) {
-            if (this.match(TokenType.IF)) {
-                alternate = this.ifStatement();
-            }
-            else if (this.match(TokenType.LBRACE)) {
-                alternate = this.block();
+    parseIfStatement() {
+        // Optional parentheses
+        const hasParen = this.match(TokenType.LeftParen);
+        const condition = this.parseExpression();
+        if (hasParen) {
+            this.consume(TokenType.RightParen, "Expected ')' after condition");
+        }
+        const thenBranch = this.match(TokenType.LeftBrace)
+            ? this.parseBlockStatement()
+            : this.parseStatement();
+        let elseBranch = null;
+        if (this.matchKeyword('else')) {
+            if (this.matchKeyword('if')) {
+                elseBranch = this.parseIfStatement();
             }
             else {
-                alternate = {
-                    type: 'BlockStatement',
-                    body: [this.statement()],
-                };
+                elseBranch = this.match(TokenType.LeftBrace)
+                    ? this.parseBlockStatement()
+                    : this.parseStatement();
             }
         }
         return {
-            type: 'IfStatement',
+            type: 'If',
             condition,
-            consequent,
-            alternate,
+            thenBranch,
+            elseBranch,
         };
     }
-    whileStatement() {
-        this.consume(TokenType.LPAREN, "Expected '(' after 'while'");
-        const condition = this.expression();
-        this.consume(TokenType.RPAREN, "Expected ')' after condition");
-        this.consume(TokenType.LBRACE, "Expected '{' before while body");
-        const body = this.block();
+    parseWhileStatement() {
+        const hasParen = this.match(TokenType.LeftParen);
+        const condition = this.parseExpression();
+        if (hasParen) {
+            this.consume(TokenType.RightParen, "Expected ')' after condition");
+        }
+        const body = this.match(TokenType.LeftBrace)
+            ? this.parseBlockStatement()
+            : this.parseStatement();
         return {
-            type: 'WhileStatement',
+            type: 'While',
             condition,
             body,
         };
     }
-    forStatement() {
-        // Check if it's a C-style for loop: for (init; test; update) { }
-        if (this.match(TokenType.LPAREN)) {
-            return this.forCStyleStatement();
-        }
-        // Otherwise, for-in loop: for x in iterable { }
-        const variable = this.consume(TokenType.IDENTIFIER, 'Expected variable name').value;
-        this.consume(TokenType.IN, "Expected 'in' in for loop");
-        const iterable = this.expression();
-        this.consume(TokenType.LBRACE, "Expected '{' before for body");
-        const body = this.block();
+    parseForStatement() {
+        // Check for C-style for loop: for (init; test; update) { }
+        if (this.match(TokenType.LeftParen)) {
+            return this.parseForCStyleStatement();
+        }
+        // For-in loop: for x in iterable { }
+        const variable = this.consume(TokenType.Identifier, "Expected variable name").value;
+        this.consumeKeyword('in');
+        const iterable = this.parseExpression();
+        const body = this.match(TokenType.LeftBrace)
+            ? this.parseBlockStatement()
+            : this.parseStatement();
         return {
-            type: 'ForInStatement',
+            type: 'For',
             variable,
             iterable,
             body,
         };
     }
-    forCStyleStatement() {
-        // Parse C-style for: for (init; test; update) { }
+    parseForCStyleStatement() {
         // Parse init
         let init = null;
-        if (!this.check(TokenType.SEMICOLON)) {
-            if (this.match(TokenType.LET) || this.match(TokenType.CONST)) {
-                const kind = this.previous().type === TokenType.LET ? 'let' : 'const';
-                const name = this.consume(TokenType.IDENTIFIER, 'Expected variable name').value;
-                let initValue = null;
-                if (this.match(TokenType.ASSIGN)) {
-                    initValue = this.expression();
-                }
-                init = {
-                    type: 'VariableDeclaration',
-                    kind,
-                    name,
-                    init: initValue,
-                };
+        if (!this.check(TokenType.Semicolon)) {
+            if (this.matchKeyword('let', 'const', 'var')) {
+                init = this.parseVarDeclaration();
             }
             else {
-                init = this.expression();
+                init = this.parseExpression();
+                this.consume(TokenType.Semicolon, "Expected ';' after for init");
             }
         }
-        this.consume(TokenType.SEMICOLON, "Expected ';' after for init");
+        else {
+            this.advance(); // skip ;
+        }
+        // If parseVarDeclaration already consumed the semicolon, skip
         // Parse test
         let test = null;
-        if (!this.check(TokenType.SEMICOLON)) {
-            test = this.expression();
+        if (!this.check(TokenType.Semicolon)) {
+            test = this.parseExpression();
         }
-        this.consume(TokenType.SEMICOLON, "Expected ';' after for condition");
+        this.consume(TokenType.Semicolon, "Expected ';' after for condition");
         // Parse update
         let update = null;
-        if (!this.check(TokenType.RPAREN)) {
-            update = this.expression();
+        if (!this.check(TokenType.RightParen)) {
+            update = this.parseExpression();
         }
-        this.consume(TokenType.RPAREN, "Expected ')' after for clauses");
+        this.consume(TokenType.RightParen, "Expected ')' after for clauses");
         // Parse body
-        this.consume(TokenType.LBRACE, "Expected '{' before for body");
-        const body = this.block();
+        const body = this.match(TokenType.LeftBrace)
+            ? this.parseBlockStatement()
+            : this.parseStatement();
         return {
-            type: 'ForStatement',
+            type: 'ForCStyle',
             init,
             test,
             update,
             body,
         };
     }
-    returnStatement() {
-        let argument = null;
-        if (!this.check(TokenType.SEMICOLON) && !this.check(TokenType.RBRACE) && !this.check(TokenType.EOF)) {
-            argument = this.expression();
+    parseBlockStatement() {
+        const statements = [];
+        const guard = createLoopGuard({
+            maxIterations: 100000,
+            context: 'block statement parsing',
+        });
+        while (!this.check(TokenType.RightBrace) && !this.isAtEnd()) {
+            guard();
+            this.skipNewlines();
+            if (this.check(TokenType.RightBrace))
+                break;
+            const stmt = this.parseDeclaration();
+            if (stmt) {
+                statements.push(stmt);
+            }
+            this.skipNewlines();
+        }
+        this.consume(TokenType.RightBrace, "Expected '}' after block");
+        return { type: 'Block', statements };
+    }
+    parseExpressionStatement() {
+        const expression = this.parseExpression();
+        this.consumeStatementEnd();
+        return { type: 'ExpressionStmt', expression };
+    }
+    parseReturnStatement() {
+        let value = null;
+        if (!this.check(TokenType.Newline) && !this.check(TokenType.Semicolon) && !this.check(TokenType.RightBrace)) {
+            value = this.parseExpression();
+        }
+        this.consumeStatementEnd();
+        return { type: 'Return', value };
+    }
+    parseBreakStatement() {
+        this.consumeStatementEnd();
+        return { type: 'Break' };
+    }
+    parseContinueStatement() {
+        this.consumeStatementEnd();
+        return { type: 'Continue' };
+    }
+    parseTryStatement() {
+        this.consume(TokenType.LeftBrace, "Expected '{' after 'try'");
+        const tryBlock = this.parseBlockStatement();
+        const catchClauses = [];
+        const catchGuard = createLoopGuard({
+            maxIterations: 1000,
+            context: 'catch clause parsing',
+        });
+        while (this.matchKeyword('catch')) {
+            catchGuard();
+            let variable;
+            let type;
+            if (this.match(TokenType.LeftParen)) {
+                if (this.match(TokenType.Identifier)) {
+                    variable = this.previous().value;
+                    if (this.match(TokenType.Colon)) {
+                        type = this.consume(TokenType.Identifier, "Expected exception type").value;
+                    }
+                }
+                this.consume(TokenType.RightParen, "Expected ')' after catch parameters");
+            }
+            this.consume(TokenType.LeftBrace, "Expected '{' after catch");
+            const body = this.parseBlockStatement();
+            catchClauses.push({ variable, type, body });
+        }
+        let finallyBlock = null;
+        if (this.matchKeyword('finally')) {
+            this.consume(TokenType.LeftBrace, "Expected '{' after 'finally'");
+            finallyBlock = this.parseBlockStatement();
         }
-        this.consumeOptional(TokenType.SEMICOLON);
         return {
-            type: 'ReturnStatement',
-            argument,
+            type: 'Try',
+            tryBlock,
+            catchClauses,
+            finallyBlock,
         };
     }
-    tryStatement() {
-        this.consume(TokenType.LBRACE, "Expected '{' after 'try'");
-        const block = this.block();
-        let handler = null;
-        if (this.match(TokenType.CATCH)) {
-            this.consume(TokenType.LPAREN, "Expected '(' after 'catch'");
-            const param = this.consume(TokenType.IDENTIFIER, 'Expected error parameter').value;
-            this.consume(TokenType.RPAREN, "Expected ')' after catch parameter");
-            this.consume(TokenType.LBRACE, "Expected '{' before catch body");
-            const catchBody = this.block();
-            handler = { param, body: catchBody };
+    parseThrowStatement() {
+        const expression = this.parseExpression();
+        this.consumeStatementEnd();
+        return { type: 'Throw', expression };
+    }
+    parseImportStatement() {
+        const names = [];
+        let module = '';
+        let alias;
+        if (this.match(TokenType.LeftBrace)) {
+            // import { name1, name2 } from "module"
+            do {
+                names.push(this.consume(TokenType.Identifier, "Expected import name").value);
+            } while (this.match(TokenType.Comma));
+            this.consume(TokenType.RightBrace, "Expected '}' after import names");
+            this.consumeKeyword('from');
+            module = this.consume(TokenType.String, "Expected module name").value;
+        }
+        else if (this.match(TokenType.Multiply)) {
+            // import * as alias from "module"
+            this.consumeKeyword('as');
+            alias = this.consume(TokenType.Identifier, "Expected alias name").value;
+            this.consumeKeyword('from');
+            module = this.consume(TokenType.String, "Expected module name").value;
+        }
+        else if (this.check(TokenType.String)) {
+            // import "module"
+            module = this.consume(TokenType.String, "Expected module name").value;
+        }
+        else if (this.check(TokenType.Identifier)) {
+            // import name OR import name from "module"
+            const firstIdent = this.consume(TokenType.Identifier, "Expected import name").value;
+            if (this.checkKeyword('from')) {
+                names.push(firstIdent);
+                this.consumeKeyword('from');
+                module = this.consume(TokenType.String, "Expected module name").value;
+            }
+            else {
+                // Simple import like: import fc
+                module = firstIdent;
+            }
         }
+        this.consumeStatementEnd();
         return {
-            type: 'TryStatement',
-            block,
-            handler,
+            type: 'Import',
+            module,
+            names,
+            alias,
         };
     }
-    throwStatement() {
-        const argument = this.expression();
-        this.consumeOptional(TokenType.SEMICOLON);
+    parseExportStatement() {
+        // export let/const/function/class
+        const declaration = this.parseDeclaration();
+        if (!declaration) {
+            throw new Error("Expected declaration after 'export'");
+        }
         return {
-            type: 'ThrowStatement',
-            argument,
+            type: 'Export',
+            declaration,
         };
     }
-    breakStatement() {
-        this.consumeOptional(TokenType.SEMICOLON);
-        return { type: 'BreakStatement' };
-    }
-    continueStatement() {
-        this.consumeOptional(TokenType.SEMICOLON);
-        return { type: 'ContinueStatement' };
-    }
-    block() {
-        const statements = [];
-        const guard = createLoopGuard({
-            maxIterations: 100000,
-            context: 'BuddyScript block parsing',
-        });
-        while (!this.check(TokenType.RBRACE) && !this.isAtEnd()) {
-            guard();
-            const decl = this.declaration();
-            if (decl)
-                statements.push(decl);
+    parseTestDeclaration() {
+        const name = this.consume(TokenType.String, "Expected test name as string").value;
+        const tags = [];
+        if (this.match(TokenType.LeftBracket)) {
+            do {
+                if (this.match(TokenType.String)) {
+                    tags.push(this.previous().value);
+                }
+            } while (this.match(TokenType.Comma));
+            this.consume(TokenType.RightBracket, "Expected ']' after tags");
         }
-        this.consume(TokenType.RBRACE, "Expected '}' after block");
+        this.consume(TokenType.LeftBrace, "Expected '{' before test body");
+        const body = this.parseBlockStatement();
         return {
-            type: 'BlockStatement',
-            body: statements,
+            type: 'TestDeclaration',
+            name,
+            body,
+            tags,
         };
     }
-    expressionStatement() {
-        const expression = this.expression();
-        this.consumeOptional(TokenType.SEMICOLON);
+    parseAssertStatement() {
+        const condition = this.parseExpression();
+        let message;
+        if (this.match(TokenType.Comma)) {
+            if (this.match(TokenType.String)) {
+                message = this.previous().value;
+            }
+        }
+        this.consumeStatementEnd();
         return {
-            type: 'ExpressionStatement',
-            expression,
+            type: 'Assert',
+            condition,
+            message,
         };
     }
     // ============================================
-    // Expression Parsing (Precedence Climbing)
+    // Expression Parsing
     // ============================================
-    expression() {
-        return this.assignment();
-    }
-    assignment() {
-        const expr = this.ternary();
-        if (this.match(TokenType.ASSIGN, TokenType.PLUS_ASSIGN, TokenType.MINUS_ASSIGN)) {
-            const operator = this.previous().value;
-            const value = this.assignment();
-            if (expr.type === 'Identifier' || expr.type === 'MemberExpression') {
-                return {
-                    type: 'AssignmentExpression',
-                    operator,
-                    left: expr,
-                    right: value,
-                };
-            }
-            throw new Error('Invalid assignment target');
+    parseExpression() {
+        return this.parseAssignment();
+    }
+    parseAssignment() {
+        const expr = this.parseTernary();
+        if (this.match(TokenType.Assign, TokenType.PlusAssign, TokenType.MinusAssign, TokenType.MultiplyAssign, TokenType.DivideAssign)) {
+            const operator = this.previous().type;
+            const value = this.parseAssignment();
+            return {
+                type: 'Assignment',
+                target: expr,
+                operator,
+                value,
+            };
         }
         return expr;
     }
-    ternary() {
-        let expr = this.or();
-        if (this.match(TokenType.QUESTION)) {
-            const consequent = this.expression();
-            this.consume(TokenType.COLON, "Expected ':' in ternary expression");
-            const alternate = this.ternary();
+    parseTernary() {
+        let expr = this.parsePipeline();
+        // Use dedicated Question token
+        if (this.match(TokenType.Question)) {
+            const consequent = this.parseExpression();
+            this.consume(TokenType.Colon, "Expected ':' in ternary expression");
+            const alternate = this.parseTernary();
             return {
-                type: 'ConditionalExpression',
-                test: expr,
+                type: 'Ternary',
+                condition: expr,
                 consequent,
                 alternate,
             };
         }
         return expr;
     }
-    or() {
-        let expr = this.and();
+    parsePipeline() {
+        let expr = this.parseLogicalOr();
         const guard = createLoopGuard({
             maxIterations: 10000,
-            context: 'BuddyScript OR expression parsing',
+            context: 'pipeline expression parsing',
         });
-        while (this.match(TokenType.OR)) {
+        while (this.match(TokenType.Pipeline)) {
             guard();
-            const right = this.and();
-            expr = {
-                type: 'LogicalExpression',
-                operator: '||',
-                left: expr,
-                right,
-            };
+            const right = this.parseLogicalOr();
+            // Transform pipeline: expr |> func => func(expr)
+            if (right.type === 'Call') {
+                const call = right;
+                call.arguments.unshift(expr);
+                expr = call;
+            }
+            else if (right.type === 'Identifier') {
+                expr = {
+                    type: 'Call',
+                    callee: right,
+                    arguments: [expr],
+                };
+            }
+            else {
+                throw new Error("Invalid pipeline target");
+            }
         }
         return expr;
     }
-    and() {
-        let expr = this.equality();
+    parseLogicalOr() {
+        let expr = this.parseLogicalAnd();
         const guard = createLoopGuard({
             maxIterations: 10000,
-            context: 'BuddyScript AND expression parsing',
+            context: 'logical OR expression parsing',
         });
-        while (this.match(TokenType.AND)) {
+        while (this.match(TokenType.Or)) {
             guard();
-            const right = this.equality();
-            expr = {
-                type: 'LogicalExpression',
-                operator: '&&',
-                left: expr,
-                right,
-            };
+            const operator = this.previous().type;
+            const right = this.parseLogicalAnd();
+            expr = { type: 'Binary', left: expr, operator, right };
         }
         return expr;
     }
-    equality() {
-        let expr = this.comparison();
+    parseLogicalAnd() {
+        let expr = this.parseEquality();
         const guard = createLoopGuard({
             maxIterations: 10000,
-            context: 'BuddyScript equality expression parsing',
+            context: 'logical AND expression parsing',
         });
-        while (this.match(TokenType.EQUALS, TokenType.NOT_EQUALS)) {
+        while (this.match(TokenType.And)) {
             guard();
-            const operator = this.previous().value;
-            const right = this.comparison();
-            expr = {
-                type: 'BinaryExpression',
-                operator,
-                left: expr,
-                right,
-            };
+            const operator = this.previous().type;
+            const right = this.parseEquality();
+            expr = { type: 'Binary', left: expr, operator, right };
         }
         return expr;
     }
-    comparison() {
-        let expr = this.term();
+    parseEquality() {
+        let expr = this.parseComparison();
         const guard = createLoopGuard({
             maxIterations: 10000,
-            context: 'BuddyScript comparison expression parsing',
+            context: 'equality expression parsing',
         });
-        while (this.match(TokenType.LESS_THAN, TokenType.LESS_EQUAL, TokenType.GREATER_THAN, TokenType.GREATER_EQUAL)) {
+        while (this.match(TokenType.Equal, TokenType.NotEqual)) {
             guard();
-            const operator = this.previous().value;
-            const right = this.term();
-            expr = {
-                type: 'BinaryExpression',
-                operator,
-                left: expr,
-                right,
-            };
+            const operator = this.previous().type;
+            const right = this.parseComparison();
+            expr = { type: 'Binary', left: expr, operator, right };
         }
         return expr;
     }
-    term() {
-        let expr = this.factor();
+    parseComparison() {
+        let expr = this.parseAddition();
         const guard = createLoopGuard({
             maxIterations: 10000,
-            context: 'BuddyScript term expression parsing',
+            context: 'comparison expression parsing',
         });
-        while (this.match(TokenType.PLUS, TokenType.MINUS)) {
+        while (this.match(TokenType.Less, TokenType.Greater, TokenType.LessEqual, TokenType.GreaterEqual)) {
             guard();
-            const operator = this.previous().value;
-            const right = this.factor();
-            expr = {
-                type: 'BinaryExpression',
-                operator,
-                left: expr,
-                right,
-            };
+            const operator = this.previous().type;
+            const right = this.parseAddition();
+            expr = { type: 'Binary', left: expr, operator, right };
         }
         return expr;
     }
-    factor() {
-        let expr = this.power();
+    parseAddition() {
+        let expr = this.parseMultiplication();
         const guard = createLoopGuard({
             maxIterations: 10000,
-            context: 'BuddyScript factor expression parsing',
+            context: 'addition expression parsing',
         });
-        while (this.match(TokenType.MULTIPLY, TokenType.DIVIDE, TokenType.MODULO)) {
+        while (this.match(TokenType.Plus, TokenType.Minus)) {
             guard();
-            const operator = this.previous().value;
-            const right = this.power();
-            expr = {
-                type: 'BinaryExpression',
-                operator,
-                left: expr,
-                right,
-            };
+            const operator = this.previous().type;
+            const right = this.parseMultiplication();
+            expr = { type: 'Binary', left: expr, operator, right };
         }
         return expr;
     }
-    power() {
-        let expr = this.unary();
-        if (this.match(TokenType.POWER)) {
-            const right = this.power(); // Right associative
-            expr = {
-                type: 'BinaryExpression',
-                operator: '**',
-                left: expr,
-                right,
-            };
+    parseMultiplication() {
+        let expr = this.parsePower();
+        const guard = createLoopGuard({
+            maxIterations: 10000,
+            context: 'multiplication expression parsing',
+        });
+        while (this.match(TokenType.Multiply, TokenType.Divide, TokenType.Modulo)) {
+            guard();
+            const operator = this.previous().type;
+            const right = this.parsePower();
+            expr = { type: 'Binary', left: expr, operator, right };
         }
         return expr;
     }
-    unary() {
-        if (this.match(TokenType.NOT, TokenType.MINUS)) {
-            const operator = this.previous().value;
-            const right = this.unary();
-            return {
-                type: 'UnaryExpression',
-                operator,
-                argument: right,
-                prefix: true,
-            };
+    parsePower() {
+        let expr = this.parseUnary();
+        if (this.match(TokenType.Power)) {
+            const right = this.parsePower(); // Right associative
+            expr = { type: 'Binary', left: expr, operator: TokenType.Power, right };
         }
-        if (this.match(TokenType.AWAIT)) {
-            const argument = this.unary();
-            return {
-                type: 'AwaitExpression',
-                argument,
-            };
+        return expr;
+    }
+    parseUnary() {
+        if (this.match(TokenType.Not, TokenType.Minus)) {
+            const operator = this.previous().type;
+            const operand = this.parseUnary();
+            return { type: 'Unary', operator, operand };
         }
-        return this.call();
+        // Await expression (from Buddy Script)
+        if (this.matchKeyword('await')) {
+            const argument = this.parseUnary();
+            return { type: 'Await', argument };
+        }
+        return this.parsePostfix();
     }
-    call() {
-        let expr = this.primary();
-        // Guard against infinite loops in call/member parsing (deeply nested chains)
+    parsePostfix() {
+        let expr = this.parsePrimary();
+        // Guard against infinite loops in postfix parsing
         const guard = createLoopGuard({
             maxIterations: 10000,
-            context: 'BuddyScript call expression parsing',
+            context: 'postfix expression parsing',
         });
         while (true) {
             guard();
-            if (this.match(TokenType.LPAREN)) {
-                expr = this.finishCall(expr);
+            if (this.match(TokenType.LeftParen)) {
+                expr = this.parseCall(expr);
             }
-            else if (this.match(TokenType.DOT)) {
-                const name = this.consume(TokenType.IDENTIFIER, 'Expected property name').value;
-                expr = {
-                    type: 'MemberExpression',
-                    object: expr,
-                    property: { type: 'Identifier', name },
-                    computed: false,
-                };
+            else if (this.match(TokenType.LeftBracket)) {
+                const index = this.parseExpression();
+                this.consume(TokenType.RightBracket, "Expected ']' after index");
+                expr = { type: 'Index', object: expr, index };
             }
-            else if (this.match(TokenType.LBRACKET)) {
-                const property = this.expression();
-                this.consume(TokenType.RBRACKET, "Expected ']' after index");
-                expr = {
-                    type: 'MemberExpression',
-                    object: expr,
-                    property,
-                    computed: true,
-                };
+            else if (this.match(TokenType.Dot)) {
+                const member = this.consume(TokenType.Identifier, "Expected member name").value;
+                expr = { type: 'Member', object: expr, member, computed: false };
             }
             else {
                 break;
@@ -544,139 +700,185 @@ export class Parser {
         }
         return expr;
     }
-    finishCall(callee) {
+    parseCall(callee) {
         const args = [];
-        if (!this.check(TokenType.RPAREN)) {
+        const namedArgs = {};
+        if (!this.check(TokenType.RightParen)) {
             do {
-                // Handle named arguments: name: value
-                if (this.check(TokenType.IDENTIFIER) && this.checkNext(TokenType.COLON)) {
+                // Check for named argument: name: value
+                if (this.check(TokenType.Identifier) && this.checkNext(TokenType.Colon)) {
                     const name = this.advance().value;
                     this.advance(); // :
-                    const value = this.expression();
-                    args.push({
-                        type: 'ObjectExpression',
-                        properties: [{ key: name, value, computed: false }],
-                    });
+                    namedArgs[name] = this.parseExpression();
                 }
                 else {
-                    args.push(this.expression());
+                    args.push(this.parseExpression());
                 }
-            } while (this.match(TokenType.COMMA));
+            } while (this.match(TokenType.Comma));
         }
-        this.consume(TokenType.RPAREN, "Expected ')' after arguments");
-        return {
-            type: 'CallExpression',
+        this.consume(TokenType.RightParen, "Expected ')' after arguments");
+        const result = {
+            type: 'Call',
             callee,
             arguments: args,
         };
+        if (Object.keys(namedArgs).length > 0) {
+            result.namedArgs = namedArgs;
+        }
+        return result;
     }
-    primary() {
-        if (this.match(TokenType.NUMBER, TokenType.STRING, TokenType.BOOLEAN, TokenType.NULL)) {
+    parsePrimary() {
+        if (this.match(TokenType.Boolean)) {
             return {
                 type: 'Literal',
-                value: this.previous().value,
+                value: this.previous().value === 'true',
+                tokenType: TokenType.Boolean,
             };
         }
-        if (this.match(TokenType.IDENTIFIER)) {
-            return {
-                type: 'Identifier',
-                name: this.previous().value,
-            };
+        if (this.match(TokenType.Null)) {
+            return { type: 'Literal', value: null, tokenType: TokenType.Null };
         }
-        if (this.match(TokenType.LBRACKET)) {
-            return this.arrayExpression();
+        if (this.match(TokenType.Number)) {
+            const value = this.previous().value;
+            const num = value.includes('.') ? parseFloat(value) : parseInt(value, 10);
+            return { type: 'Literal', value: num, tokenType: TokenType.Number };
         }
-        if (this.match(TokenType.LBRACE)) {
-            return this.objectExpression();
-        }
-        if (this.match(TokenType.LPAREN)) {
-            // Could be grouping or arrow function
-            const expr = this.expression();
-            this.consume(TokenType.RPAREN, "Expected ')' after expression");
-            if (this.match(TokenType.ARROW)) {
-                return this.arrowFunction([expr]);
+        if (this.match(TokenType.String)) {
+            const value = this.previous().value;
+            // Check for interpolation
+            if (value.includes('${')) {
+                return this.parseStringInterpolation(value);
+            }
+            return { type: 'Literal', value, tokenType: TokenType.String };
+        }
+        if (this.match(TokenType.Identifier)) {
+            return { type: 'Identifier', name: this.previous().value };
+        }
+        if (this.match(TokenType.LeftParen)) {
+            // Check for lambda / arrow function
+            if (this.check(TokenType.Identifier) || this.check(TokenType.RightParen)) {
+                const checkpoint = this.current;
+                const parameters = [];
+                if (!this.check(TokenType.RightParen)) {
+                    do {
+                        if (this.match(TokenType.Identifier)) {
+                            parameters.push(this.previous().value);
+                        }
+                        else {
+                            this.current = checkpoint;
+                            break;
+                        }
+                    } while (this.match(TokenType.Comma));
+                }
+                if (this.current !== checkpoint && this.match(TokenType.RightParen) && this.match(TokenType.Arrow)) {
+                    const body = this.match(TokenType.LeftBrace)
+                        ? this.parseBlockStatement()
+                        : this.parseExpression();
+                    return { type: 'Lambda', parameters, body };
+                }
+                this.current = checkpoint;
             }
+            const expr = this.parseExpression();
+            this.consume(TokenType.RightParen, "Expected ')' after expression");
             return expr;
         }
-        throw new Error(`Unexpected token: ${this.peek().type} at line ${this.peek().line}`);
+        if (this.match(TokenType.LeftBracket)) {
+            return this.parseArrayLiteral();
+        }
+        if (this.match(TokenType.LeftBrace)) {
+            return this.parseDictLiteral();
+        }
+        throw new Error(`Unexpected token: ${this.peek().type} (${this.peek().value}) at line ${this.peek().line}`);
     }
-    arrayExpression() {
+    parseStringInterpolation(value) {
+        const parts = [];
+        let current = 0;
+        const guard = createLoopGuard({
+            maxIterations: 10000,
+            context: 'string interpolation parsing',
+        });
+        while (current < value.length) {
+            guard();
+            const start = value.indexOf('${', current);
+            if (start === -1) {
+                if (current < value.length) {
+                    parts.push({
+                        type: 'Literal',
+                        value: value.substring(current),
+                        tokenType: TokenType.String,
+                    });
+                }
+                break;
+            }
+            if (start > current) {
+                parts.push({
+                    type: 'Literal',
+                    value: value.substring(current, start),
+                    tokenType: TokenType.String,
+                });
+            }
+            const end = value.indexOf('}', start + 2);
+            if (end === -1) {
+                throw new Error("Unterminated string interpolation");
+            }
+            const exprCode = value.substring(start + 2, end);
+            const tokens = lexerTokenize(exprCode);
+            const parser = new FCSParser(tokens);
+            parts.push(parser.parseExpression());
+            current = end + 1;
+        }
+        return { type: 'Interpolation', parts };
+    }
+    parseArrayLiteral() {
         const elements = [];
-        if (!this.check(TokenType.RBRACKET)) {
+        if (!this.check(TokenType.RightBracket)) {
             do {
-                elements.push(this.expression());
-            } while (this.match(TokenType.COMMA));
+                elements.push(this.parseExpression());
+            } while (this.match(TokenType.Comma));
         }
-        this.consume(TokenType.RBRACKET, "Expected ']' after array");
-        return {
-            type: 'ArrayExpression',
-            elements,
-        };
+        this.consume(TokenType.RightBracket, "Expected ']' after array elements");
+        return { type: 'Array', elements };
     }
-    objectExpression() {
-        const properties = [];
-        if (!this.check(TokenType.RBRACE)) {
+    parseDictLiteral() {
+        const elements = new Map();
+        if (!this.check(TokenType.RightBrace)) {
             do {
                 let key;
-                let computed = false;
-                if (this.match(TokenType.LBRACKET)) {
-                    key = this.expression();
-                    this.consume(TokenType.RBRACKET, "Expected ']' after computed property");
-                    computed = true;
+                if (this.match(TokenType.String)) {
+                    key = this.previous().value;
                 }
-                else if (this.check(TokenType.STRING)) {
-                    key = this.advance().value;
+                else if (this.match(TokenType.Identifier)) {
+                    key = this.previous().value;
                 }
                 else {
-                    key = this.consume(TokenType.IDENTIFIER, 'Expected property name').value;
+                    throw new Error("Expected string or identifier for dict key");
                 }
-                this.consume(TokenType.COLON, "Expected ':' after property name");
-                const value = this.expression();
-                properties.push({ key, value, computed });
-            } while (this.match(TokenType.COMMA));
-        }
-        this.consume(TokenType.RBRACE, "Expected '}' after object");
-        return {
-            type: 'ObjectExpression',
-            properties,
-        };
-    }
-    arrowFunction(params) {
-        const paramNodes = params.map(p => {
-            if (p.type !== 'Identifier') {
-                throw new Error('Arrow function parameters must be identifiers');
-            }
-            return { name: p.name };
-        });
-        let body;
-        if (this.match(TokenType.LBRACE)) {
-            body = this.block();
+                this.consume(TokenType.Colon, "Expected ':' after dict key");
+                const value = this.parseExpression();
+                elements.set(key, value);
+            } while (this.match(TokenType.Comma));
         }
-        else {
-            body = this.expression();
-        }
-        return {
-            type: 'ArrowFunction',
-            params: paramNodes,
-            body,
-            async: false,
-        };
+        this.consume(TokenType.RightBrace, "Expected '}' after dict elements");
+        return { type: 'Dict', elements };
     }
     // ============================================
-    // Utility Methods
+    // Helper Methods
     // ============================================
-    match(...types) {
-        for (const type of types) {
-            if (this.check(type)) {
-                this.advance();
-                return true;
-            }
-        }
-        return false;
+    isAtEnd() {
+        return this.peek().type === TokenType.EOF;
+    }
+    peek() {
+        return this.tokens[Math.min(this.current, this.tokens.length - 1)];
+    }
+    previous() {
+        return this.tokens[this.current - 1];
+    }
+    advance() {
+        if (!this.isAtEnd())
+            this.current++;
+        return this.previous();
     }
     check(type) {
-        if (this.isAtEnd())
-            return false;
         return this.peek().type === type;
     }
     checkNext(type) {
@@ -684,58 +886,83 @@ export class Parser {
             return false;
         return this.tokens[this.current + 1].type === type;
     }
-    advance() {
-        if (!this.isAtEnd())
-            this.current++;
-        return this.previous();
-    }
-    isAtEnd() {
-        return this.peek().type === TokenType.EOF;
+    checkKeyword(...keywords) {
+        if (this.peek().type !== TokenType.Keyword)
+            return false;
+        return keywords.includes(this.peek().value);
     }
-    peek() {
-        return this.tokens[this.current];
+    match(...types) {
+        for (const type of types) {
+            if (this.check(type)) {
+                this.advance();
+                return true;
+            }
+        }
+        return false;
     }
-    previous() {
-        return this.tokens[this.current - 1];
+    matchKeyword(...keywords) {
+        if (this.checkKeyword(...keywords)) {
+            this.advance();
+            return true;
+        }
+        return false;
     }
     consume(type, message) {
         if (this.check(type))
             return this.advance();
-        throw new Error(`${message}. Got ${this.peek().type} at line ${this.peek().line}`);
+        throw new Error(`${message} at line ${this.peek().line}, got ${this.peek().type}`);
     }
-    consumeOptional(type) {
-        if (this.check(type)) {
+    consumeKeyword(...keywords) {
+        if (this.checkKeyword(...keywords)) {
             this.advance();
-            return true;
         }
-        return false;
+        else {
+            throw new Error(`Expected one of [${keywords.join(', ')}] at line ${this.peek().line}`);
+        }
+    }
+    consumeStatementEnd() {
+        if (this.match(TokenType.Semicolon) || this.match(TokenType.Newline)) {
+            return;
+        }
+        if (this.isAtEnd())
+            return;
+        // Allow implicit semicolon before certain tokens
+        if (this.check(TokenType.RightBrace) || this.checkKeyword('else')) {
+            return;
+        }
+    }
+    skipNewlines() {
+        const guard = createLoopGuard({
+            maxIterations: 100000,
+            context: 'newline skipping',
+        });
+        while (this.match(TokenType.Newline)) {
+            guard();
+            // Skip
+        }
     }
     synchronize() {
         this.advance();
         const guard = createLoopGuard({
             maxIterations: 100000,
-            context: 'BuddyScript error synchronization',
+            context: 'error synchronization',
         });
         while (!this.isAtEnd()) {
             guard();
-            if (this.previous().type === TokenType.SEMICOLON)
+            if (this.previous().type === TokenType.Semicolon)
+                return;
+            if (this.previous().type === TokenType.Newline)
+                return;
+            if (this.checkKeyword('if', 'for', 'while', 'let', 'const', 'func', 'function', 'class', 'return')) {
                 return;
-            switch (this.peek().type) {
-                case TokenType.FUNCTION:
-                case TokenType.LET:
-                case TokenType.CONST:
-                case TokenType.IF:
-                case TokenType.WHILE:
-                case TokenType.FOR:
-                case TokenType.RETURN:
-                case TokenType.TRY:
-                    return;
             }
             this.advance();
         }
     }
 }
+/** @deprecated Use FCSParser instead */
+export const Parser = FCSParser;
 export function parse(tokens) {
-    return new Parser(tokens).parse();
+    return new FCSParser(tokens).parse();
 }
 //# sourceMappingURL=parser.js.map