english-lang 0.1.0

package/dist/src/parser/Parser.js

@@ -0,0 +1,1165 @@
+"use strict";
+// ============================================================
+// Parser.ts — Recursive-descent parser for the English language
+//
+// Consumes the token stream from Lexer.ts and produces a typed
+// AST (see ASTNodes.ts).  Handles:
+//   Phase 1: screen, state, events, actions, layout, if/otherwise
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Parser = void 0;
+// ─────────────────────────────────────────────────────────────
+class Parser {
+    constructor(tokens) {
+        this.pos = 0;
+        this.tokens = tokens;
+    }
+    // ── Public entry point ────────────────────────────────────
+    parse() {
+        const screens = [];
+        const types = [];
+        const components = [];
+        while (!this.check('EOF')) {
+            this.skipNewlines();
+            if (this.check('EOF'))
+                break;
+            const word = this.peekWord();
+            if (word === 'screen') {
+                screens.push(this.parseScreenDecl());
+            }
+            else if (word === 'noun' || word === 'type') {
+                types.push(this.parseTypeDecl());
+            }
+            else if (word === 'component') {
+                components.push(this.parseComponentDecl());
+            }
+            else if (word === 'app' || word === 'shared') {
+                // Skip top-level app / shared state for Phase 1
+                this.skipBlock();
+            }
+            else if (word === 'style') {
+                this.skipBlock();
+            }
+            else {
+                throw this.error(`Expected top-level declaration (screen, type, component), got "${this.peek().value}"`);
+            }
+        }
+        return { kind: 'Program', screens, types, components };
+    }
+    // ── Screen ────────────────────────────────────────────────
+    parseScreenDecl() {
+        const line = this.peek().line;
+        this.expectWord('screen');
+        const name = this.expectWord();
+        this.expect('COLON');
+        this.expect('NEWLINE');
+        this.expect('INDENT');
+        let title = null;
+        const state = [];
+        const events = [];
+        const actions = [];
+        let layout = [];
+        while (!this.check('DEDENT') && !this.check('EOF')) {
+            this.skipNewlines();
+            if (this.check('DEDENT') || this.check('EOF'))
+                break;
+            const word = this.peekWord();
+            if (word === 'title') {
+                this.consumeWord();
+                this.expectWord('is');
+                title = this.expect('STRING').value;
+                this.expectNewline();
+            }
+            else if (word === 'state') {
+                this.consumeWord();
+                this.expect('COLON');
+                this.expect('NEWLINE');
+                this.expect('INDENT');
+                while (!this.check('DEDENT') && !this.check('EOF')) {
+                    this.skipNewlines();
+                    if (this.check('DEDENT'))
+                        break;
+                    state.push(this.parseStateField());
+                }
+                this.expect('DEDENT');
+            }
+            else if (word === 'persistent') {
+                // persistent state: block — Phase 3
+                this.skipBlock();
+            }
+            else if (word === 'computed') {
+                // computed: block — Phase 3
+                this.skipBlock();
+            }
+            else if (word === 'when') {
+                events.push(this.parseEventHandler());
+            }
+            else if (word === 'to') {
+                actions.push(this.parseActionDef());
+            }
+            else if (word === 'layout') {
+                this.consumeWord();
+                this.expect('COLON');
+                this.expect('NEWLINE');
+                this.expect('INDENT');
+                layout = this.parseLayoutNodes();
+                this.expect('DEDENT');
+            }
+            else {
+                throw this.error(`Unexpected keyword "${word}" in screen body`);
+            }
+        }
+        this.expect('DEDENT');
+        return { kind: 'ScreenDecl', name, title, state, events, actions, layout, line };
+    }
+    // ── State field ───────────────────────────────────────────
+    //
+    //   name is "value"
+    //   name is 0
+    //   name is true
+    //   name is a list of Product
+    //   name is an empty list
+    parseStateField() {
+        const line = this.peek().line;
+        const name = this.expectWord();
+        this.expectWord('is');
+        // "a list of Type" or "an empty list"
+        if (this.peekWord() === 'a' || this.peekWord() === 'an') {
+            const article = this.consumeWord();
+            if (this.peekWord() === 'list') {
+                this.consumeWord();
+                this.expectWord('of');
+                const typeName = this.expectWord();
+                this.expectNewline();
+                return {
+                    kind: 'StateField', name,
+                    typeHint: { kind: 'ListType', itemType: typeName },
+                    defaultValue: { kind: 'EmptyListLiteral' },
+                    persistent: false, storageKey: null, line
+                };
+            }
+            if (article === 'an' && this.peekWord() === 'empty') {
+                this.consumeWord();
+                this.expectWord('list');
+                this.expectNewline();
+                return {
+                    kind: 'StateField', name,
+                    typeHint: { kind: 'ListType', itemType: 'any' },
+                    defaultValue: { kind: 'EmptyListLiteral' },
+                    persistent: false, storageKey: null, line
+                };
+            }
+            throw this.error(`Expected "list of Type" or "empty list" after "${article}"`);
+        }
+        const defaultValue = this.parseExpr();
+        this.expectNewline();
+        return {
+            kind: 'StateField', name,
+            typeHint: null,
+            defaultValue,
+            persistent: false, storageKey: null, line
+        };
+    }
+    // ── Event handlers ────────────────────────────────────────
+    //
+    //   when screen opens:
+    //   when screen closes:
+    //   when "Button" is pressed:
+    //   when "field" changes:
+    parseEventHandler() {
+        const line = this.peek().line;
+        this.expectWord('when');
+        let trigger;
+        if (this.peekWord() === 'screen') {
+            this.consumeWord();
+            if (this.peekWord() === 'opens') {
+                this.consumeWord();
+                trigger = { kind: 'ScreenOpens' };
+            }
+            else if (this.peekWord() === 'closes') {
+                this.consumeWord();
+                trigger = { kind: 'ScreenCloses' };
+            }
+            else {
+                throw this.error('Expected "opens" or "closes" after "screen"');
+            }
+        }
+        else if (this.peekWord() === 'pulled') {
+            this.consumeWord();
+            this.expectWord('to');
+            this.expectWord('refresh');
+            trigger = { kind: 'PulledToRefresh' };
+        }
+        else if (this.peekWord() === 'item') {
+            this.consumeWord();
+            this.expectWord('is');
+            this.expectWord('tapped');
+            trigger = { kind: 'ItemTapped' };
+        }
+        else if (this.check('STRING')) {
+            const label = this.advance().value;
+            this.expectWord('is');
+            const action = this.expectWord(); // "pressed" or "changes"
+            if (action === 'pressed') {
+                trigger = { kind: 'ButtonPressed', label };
+            }
+            else if (action === 'changes') {
+                trigger = { kind: 'ValueChanges', name: label };
+            }
+            else {
+                throw this.error(`Expected "pressed" or "changes", got "${action}"`);
+            }
+        }
+        else {
+            throw this.error(`Unrecognised event trigger at "${this.peek().value}"`);
+        }
+        this.expect('COLON');
+        this.expect('NEWLINE');
+        this.expect('INDENT');
+        const body = this.parseStatements();
+        this.expect('DEDENT');
+        return { kind: 'EventHandler', trigger, body, line };
+    }
+    // ── Action definitions ────────────────────────────────────
+    //
+    //   to load products:
+    //   to send a welcome email to "address":
+    //   to move "product" from "source" to "destination":
+    parseActionDef() {
+        const line = this.peek().line;
+        this.expectWord('to');
+        const verbPhrase = [];
+        const params = [];
+        // Collect verb words and quoted parameter slots until COLON
+        while (!this.check('COLON') && !this.check('NEWLINE') && !this.check('EOF')) {
+            if (this.check('STRING')) {
+                // "paramName" — a parameter slot in the verb phrase
+                const paramName = this.advance().value;
+                params.push({ name: paramName, type: { kind: 'SimpleType', name: 'any' } });
+                continue;
+            }
+            if (this.check('WORD')) {
+                verbPhrase.push(this.consumeWord());
+                continue;
+            }
+            break;
+        }
+        this.expect('COLON');
+        this.expect('NEWLINE');
+        this.expect('INDENT');
+        const body = this.parseStatements();
+        this.expect('DEDENT');
+        return { kind: 'ActionDef', verbPhrase, params, returnType: null, body, line };
+    }
+    // ── Statements ────────────────────────────────────────────
+    parseStatements() {
+        const stmts = [];
+        while (!this.check('DEDENT') && !this.check('EOF')) {
+            this.skipNewlines();
+            if (this.check('DEDENT') || this.check('EOF'))
+                break;
+            stmts.push(this.parseStatement());
+        }
+        return stmts;
+    }
+    parseStatement() {
+        const word = this.peekWord();
+        if (word === 'set')
+            return this.parseSetStatement();
+        if (word === 'add')
+            return this.parseAddStatement();
+        if (word === 'remove')
+            return this.parseRemoveStatement();
+        if (word === 'fetch')
+            return this.parseFetchStatement();
+        if (word === 'go')
+            return this.parseGoStatement();
+        if (word === 'present')
+            return this.parsePresentStatement();
+        if (word === 'dismiss')
+            return this.parseDismissStatement();
+        if (word === 'return')
+            return this.parseReturnStatement();
+        if (word === 'if')
+            return this.parseIfStatement();
+        // Default: function call (verb phrase)
+        return this.parseCallStatement();
+    }
+    // set X to VALUE
+    parseSetStatement() {
+        const line = this.peek().line;
+        this.expectWord('set');
+        const name = this.expectWord();
+        this.expectWord('to');
+        const value = this.parseExpr();
+        this.expectNewline();
+        return { kind: 'SetStatement', name, value, line };
+    }
+    // fetch X from "url"
+    //     expecting a Type / list of Type
+    //     on success: (data) ->
+    //         ...
+    //     on failure: (error) ->
+    //         ...
+    parseFetchStatement() {
+        const line = this.peek().line;
+        this.expectWord('fetch');
+        const resultName = this.expectWord();
+        this.expectWord('from');
+        const url = this.parseExpr();
+        let method = 'GET';
+        let sendBody = null;
+        let expectedType = null;
+        let onSuccess = null;
+        let onFailure = null;
+        // Optional "sending body" suffix on same line
+        if (this.peekWord() === 'sending') {
+            this.consumeWord();
+            this.consumeWord(); // "sending body"
+            method = 'POST';
+        }
+        this.expectNewline();
+        // Sub-clauses appear as an indented block
+        if (this.check('INDENT')) {
+            this.advance();
+            while (!this.check('DEDENT') && !this.check('EOF')) {
+                this.skipNewlines();
+                if (this.check('DEDENT'))
+                    break;
+                const kw = this.peekWord();
+                if (kw === 'method') {
+                    this.consumeWord();
+                    method = this.expectWord();
+                    this.expectNewline();
+                }
+                else if (kw === 'expecting') {
+                    this.consumeWord();
+                    expectedType = this.parseTypeAnnotation();
+                    this.expectNewline();
+                }
+                else if (kw === 'on') {
+                    this.consumeWord();
+                    const branch = this.expectWord(); // "success" or "failure"
+                    this.expect('COLON');
+                    // Inline: (param) -> ...
+                    this.expect('LPAREN');
+                    const param = this.expectWord();
+                    this.expect('RPAREN');
+                    this.expect('ARROW');
+                    let branchBody = [];
+                    if (this.check('NEWLINE')) {
+                        // Block form
+                        this.advance();
+                        this.expect('INDENT');
+                        branchBody = this.parseStatements();
+                        this.expect('DEDENT');
+                    }
+                    else {
+                        // Inline single statement (no newline yet)
+                        branchBody = [this.parseStatement()];
+                    }
+                    if (branch === 'success')
+                        onSuccess = { param, body: branchBody };
+                    else
+                        onFailure = { param, body: branchBody };
+                }
+                else {
+                    throw this.error(`Unexpected fetch sub-clause "${kw}"`);
+                }
+            }
+            this.expect('DEDENT');
+        }
+        return { kind: 'FetchStatement', resultName, url, method, sendBody, expectedType, onSuccess, onFailure, line };
+    }
+    // go to ScreenName [passing expr]
+    // go back
+    parseGoStatement() {
+        const line = this.peek().line;
+        this.expectWord('go');
+        if (this.peekWord() === 'back') {
+            this.consumeWord();
+            this.expectNewline();
+            return { kind: 'GoBackStatement', line };
+        }
+        this.expectWord('to');
+        const screen = this.expectWord();
+        let passing = null;
+        if (this.peekWord() === 'passing') {
+            this.consumeWord();
+            passing = this.parseExpr();
+        }
+        this.expectNewline();
+        return { kind: 'GoToStatement', screen, passing, line };
+    }
+    // present ScreenName as modal
+    parsePresentStatement() {
+        const line = this.peek().line;
+        this.expectWord('present');
+        const screen = this.expectWord();
+        this.expectWord('as');
+        this.expectWord('modal');
+        this.expectNewline();
+        return { kind: 'PresentStatement', screen, line };
+    }
+    // dismiss this screen
+    parseDismissStatement() {
+        const line = this.peek().line;
+        this.expectWord('dismiss');
+        this.expectWord('this');
+        this.expectWord('screen');
+        this.expectNewline();
+        return { kind: 'DismissStatement', line };
+    }
+    // return value
+    parseReturnStatement() {
+        const line = this.peek().line;
+        this.expectWord('return');
+        const value = this.parseExpr();
+        this.expectNewline();
+        return { kind: 'ReturnStatement', value, line };
+    }
+    // add N to name  →  set name to name + N
+    parseAddStatement() {
+        const line = this.peek().line;
+        this.expectWord('add');
+        const amount = this.parseExpr();
+        this.expectWord('to');
+        const name = this.expectWord();
+        this.expectNewline();
+        return {
+            kind: 'SetStatement', name, line,
+            value: { kind: 'BinaryExpr', op: '+', left: { kind: 'VariableRef', name }, right: amount }
+        };
+    }
+    // remove N from name  →  set name to name - N
+    parseRemoveStatement() {
+        const line = this.peek().line;
+        this.expectWord('remove');
+        const amount = this.parseExpr();
+        this.expectWord('from');
+        const name = this.expectWord();
+        this.expectNewline();
+        return {
+            kind: 'SetStatement', name, line,
+            value: { kind: 'BinaryExpr', op: '-', left: { kind: 'VariableRef', name }, right: amount }
+        };
+    }
+    // if condition: ... [otherwise if condition: ...] [otherwise: ...]
+    parseIfStatement() {
+        const line = this.peek().line;
+        this.expectWord('if');
+        const condition = this.parseCondition();
+        this.expect('COLON');
+        this.expect('NEWLINE');
+        this.expect('INDENT');
+        const thenBody = this.parseStatements();
+        this.expect('DEDENT');
+        const otherwiseIfBranches = [];
+        let elseBody = null;
+        while (this.peekWord() === 'otherwise') {
+            this.consumeWord();
+            if (this.peekWord() === 'if') {
+                this.consumeWord();
+                const cond = this.parseCondition();
+                this.expect('COLON');
+                this.expect('NEWLINE');
+                this.expect('INDENT');
+                const body = this.parseStatements();
+                this.expect('DEDENT');
+                otherwiseIfBranches.push({ condition: cond, body });
+            }
+            else {
+                this.expect('COLON');
+                this.expect('NEWLINE');
+                this.expect('INDENT');
+                elseBody = this.parseStatements();
+                this.expect('DEDENT');
+                break;
+            }
+        }
+        return { kind: 'IfStatement', condition, thenBody, otherwiseIfBranches, elseBody, line };
+    }
+    // Default call: verb phrase possibly followed by expressions
+    parseCallStatement() {
+        const line = this.peek().line;
+        const verbPhrase = [];
+        const args = [];
+        // Collect words until NEWLINE / COLON / EOF / DEDENT
+        while (this.check('WORD') && !this.check('NEWLINE') && !this.check('EOF') && !this.check('DEDENT')) {
+            verbPhrase.push(this.consumeWord());
+        }
+        // Any remaining non-word tokens on same line become args
+        while (!this.check('NEWLINE') && !this.check('EOF') && !this.check('DEDENT')) {
+            if (this.check('STRING') || this.check('NUMBER')) {
+                args.push(this.parseExpr());
+            }
+            else {
+                break;
+            }
+        }
+        this.expectNewline();
+        return { kind: 'CallStatement', verbPhrase, args, line };
+    }
+    // ── Expressions ───────────────────────────────────────────
+    parseExpr() {
+        const tok = this.peek();
+        if (tok.type === 'STRING') {
+            this.advance();
+            return { kind: 'StringLiteral', value: tok.value };
+        }
+        if (tok.type === 'NUMBER') {
+            this.advance();
+            return { kind: 'NumberLiteral', value: parseFloat(tok.value) };
+        }
+        if (tok.type === 'WORD') {
+            if (tok.value === 'true') {
+                this.advance();
+                return { kind: 'BooleanLiteral', value: true };
+            }
+            if (tok.value === 'false') {
+                this.advance();
+                return { kind: 'BooleanLiteral', value: false };
+            }
+            if (tok.value === 'nothing' || tok.value === 'null') {
+                this.advance();
+                return { kind: 'NullLiteral' };
+            }
+            this.advance();
+            // Property access via dot: product.name
+            if (this.check('DOT')) {
+                this.advance();
+                const prop = this.expectWord();
+                return { kind: 'PropertyAccess', object: tok.value, property: prop };
+            }
+            // Possessive: product's name
+            if (this.check('APOSTROPHE_S')) {
+                this.advance();
+                const prop = this.expectWord();
+                return { kind: 'PropertyAccess', object: tok.value, property: prop };
+            }
+            return { kind: 'VariableRef', name: tok.value };
+        }
+        throw this.error(`Expected expression, got ${tok.type} "${tok.value}"`);
+    }
+    // ── Conditions ────────────────────────────────────────────
+    parseCondition() {
+        const left = this.parseExpr();
+        const word = this.peekWord();
+        if (word === 'has') {
+            this.consumeWord();
+            this.expectWord('items');
+            return { kind: 'HasItems', expr: left };
+        }
+        if (word === 'is') {
+            this.consumeWord();
+            const next = this.peekWord();
+            if (next === 'empty') {
+                this.consumeWord();
+                return { kind: 'IsEmpty', expr: left };
+            }
+            if (next === 'not') {
+                this.consumeWord();
+                return { kind: 'NotEquals', left, right: this.parseExpr() };
+            }
+            if (next === 'greater') {
+                this.consumeWord();
+                this.expectWord('than');
+                return { kind: 'GreaterThan', left, right: this.parseExpr() };
+            }
+            if (next === 'less') {
+                this.consumeWord();
+                this.expectWord('than');
+                return { kind: 'LessThan', left, right: this.parseExpr() };
+            }
+            if (next === 'at') {
+                this.consumeWord();
+                const qualifier = this.expectWord();
+                if (qualifier === 'least')
+                    return { kind: 'AtLeast', left, right: this.parseExpr() };
+                if (qualifier === 'most')
+                    return { kind: 'AtMost', left, right: this.parseExpr() };
+                throw this.error(`Expected "least" or "most" after "at"`);
+            }
+            return { kind: 'Equals', left, right: this.parseExpr() };
+        }
+        if (word === 'exists') {
+            this.consumeWord();
+            return { kind: 'Exists', expr: left };
+        }
+        if (word === 'contains') {
+            this.consumeWord();
+            return { kind: 'Contains', haystack: left, needle: this.parseExpr() };
+        }
+        // Bare variable name — truthy check
+        return { kind: 'Truthy', expr: left };
+    }
+    // ── Type annotations ──────────────────────────────────────
+    parseTypeAnnotation() {
+        if (this.peekWord() === 'a' || this.peekWord() === 'an') {
+            this.consumeWord();
+        }
+        if (this.peekWord() === 'list') {
+            this.consumeWord();
+            this.expectWord('of');
+            const name = this.expectWord();
+            return { kind: 'ListType', itemType: name };
+        }
+        if (this.peekWord() === 'optional') {
+            this.consumeWord();
+            const name = this.expectWord();
+            return { kind: 'OptionalType', inner: { kind: 'SimpleType', name } };
+        }
+        const name = this.expectWord();
+        return { kind: 'SimpleType', name };
+    }
+    // ── Layout nodes ──────────────────────────────────────────
+    parseLayoutNodes() {
+        const nodes = [];
+        while (!this.check('DEDENT') && !this.check('EOF')) {
+            this.skipNewlines();
+            if (this.check('DEDENT') || this.check('EOF'))
+                break;
+            nodes.push(this.parseLayoutNode());
+        }
+        return nodes;
+    }
+    parseLayoutNode() {
+        const word = this.peekWord();
+        if (word === 'vertical')
+            return this.parseVerticalStack();
+        if (word === 'horizontal')
+            return this.parseHorizontalStack();
+        if (word === 'scroll')
+            return this.parseScrollView();
+        if (word === 'grid')
+            return this.parseGrid();
+        if (word === 'card')
+            return this.parseCard();
+        if (word === 'show')
+            return this.parseTextNode();
+        if (word === 'text') {
+            // "text field bound to X" vs "text X as style"
+            const next2 = this.tokens[this.pos + 1];
+            if (next2 && next2.type === 'WORD' && next2.value === 'field') {
+                return this.parseTextField();
+            }
+            return this.parseTextNode();
+        }
+        if (word === 'button')
+            return this.parseButton();
+        if (word === 'image')
+            return this.parseImage();
+        if (word === 'icon')
+            return this.parseIcon();
+        if (word === 'spacer') {
+            this.consumeWord();
+            this.expectNewline();
+            return { kind: 'Spacer' };
+        }
+        if (word === 'divider') {
+            this.consumeWord();
+            this.expectNewline();
+            return { kind: 'Divider' };
+        }
+        if (word === 'loading')
+            return this.parseLoadingSpinner();
+        if (word === 'if')
+            return this.parseLayoutIf();
+        if (word === 'for')
+            return this.parseForEach();
+        // Component call: starts with uppercase (e.g. ProductCard(...))
+        if (word && /^[A-Z]/.test(word))
+            return this.parseComponentCall();
+        throw this.error(`Unknown layout element "${word}"`);
+    }
+    // vertical stack [spacing N] [padding N]:
+    parseVerticalStack() {
+        this.expectWord('vertical');
+        this.expectWord('stack');
+        let spacing = null;
+        let padding = null;
+        while (this.check('WORD')) {
+            const kw = this.peekWord();
+            if (kw === 'spacing') {
+                this.consumeWord();
+                spacing = parseFloat(this.expect('NUMBER').value);
+            }
+            else if (kw === 'padding') {
+                this.consumeWord();
+                padding = parseFloat(this.expect('NUMBER').value);
+            }
+            else
+                break;
+        }
+        this.expect('COLON');
+        this.expect('NEWLINE');
+        this.expect('INDENT');
+        const children = this.parseLayoutNodes();
+        this.expect('DEDENT');
+        return { kind: 'VerticalStack', spacing, padding, children };
+    }
+    // horizontal stack [spacing N]:
+    parseHorizontalStack() {
+        this.expectWord('horizontal');
+        this.expectWord('stack');
+        let spacing = null;
+        if (this.peekWord() === 'spacing') {
+            this.consumeWord();
+            spacing = parseFloat(this.expect('NUMBER').value);
+        }
+        this.expect('COLON');
+        this.expect('NEWLINE');
+        this.expect('INDENT');
+        const children = this.parseLayoutNodes();
+        this.expect('DEDENT');
+        return { kind: 'HorizontalStack', spacing, children };
+    }
+    // scroll view [vertical|horizontal]:
+    parseScrollView() {
+        this.expectWord('scroll');
+        this.expectWord('view');
+        let direction = 'vertical';
+        if (this.peekWord() === 'vertical' || this.peekWord() === 'horizontal') {
+            direction = this.consumeWord();
+        }
+        this.expect('COLON');
+        this.expect('NEWLINE');
+        this.expect('INDENT');
+        const children = this.parseLayoutNodes();
+        this.expect('DEDENT');
+        return { kind: 'ScrollView', direction, children };
+    }
+    // grid with N columns [spacing N]:
+    parseGrid() {
+        this.expectWord('grid');
+        this.expectWord('with');
+        const columns = parseFloat(this.expect('NUMBER').value);
+        this.expectWord('columns');
+        let spacing = null;
+        if (this.peekWord() === 'spacing') {
+            this.consumeWord();
+            spacing = parseFloat(this.expect('NUMBER').value);
+        }
+        this.expect('COLON');
+        this.expect('NEWLINE');
+        this.expect('INDENT');
+        const children = this.parseLayoutNodes();
+        this.expect('DEDENT');
+        return { kind: 'Grid', columns, spacing, children };
+    }
+    // card [corner radius N]:
+    parseCard() {
+        this.expectWord('card');
+        let cornerRadius = null;
+        if (this.peekWord() === 'corner') {
+            this.consumeWord();
+            this.expectWord('radius');
+            cornerRadius = parseFloat(this.expect('NUMBER').value);
+        }
+        this.expect('COLON');
+        this.expect('NEWLINE');
+        this.expect('INDENT');
+        const children = this.parseLayoutNodes();
+        this.expect('DEDENT');
+        return { kind: 'Card', cornerRadius, children };
+    }
+    // show "text" [as style] [color X]
+    // show variable [as style] [color X]
+    // text "text" as style
+    // text variable as style
+    parseTextNode() {
+        const kw = this.consumeWord(); // 'show' or 'text'
+        if (kw !== 'show' && kw !== 'text')
+            throw this.error(`Expected "show" or "text", got "${kw}"`);
+        let expr;
+        if (this.check('STRING')) {
+            expr = { kind: 'StringLiteral', value: this.advance().value };
+        }
+        else if (this.check('WORD')) {
+            expr = this.parseExpr();
+        }
+        else {
+            throw this.error('Expected string or variable after "show"/"text"');
+        }
+        let style = 'body';
+        if (this.peekWord() === 'as') {
+            this.consumeWord();
+            style = this.expectWord();
+        }
+        let color = null;
+        if (this.peekWord() === 'color') {
+            this.consumeWord();
+            color = this.check('STRING') ? this.advance().value : this.expectWord();
+        }
+        this.expectNewline();
+        return { kind: 'Text', expr, style, color };
+    }
+    // button "Label" [style StyleName]
+    parseButton() {
+        this.expectWord('button');
+        const label = this.expect('STRING').value;
+        let style = null;
+        if (this.peekWord() === 'style') {
+            this.consumeWord();
+            style = this.expectWord();
+        }
+        this.expectNewline();
+        return { kind: 'Button', label, style };
+    }
+    // text field bound to varName [placeholder "..."]
+    parseTextField() {
+        this.expectWord('text');
+        this.expectWord('field');
+        this.expectWord('bound');
+        this.expectWord('to');
+        const boundTo = this.expectWord();
+        let placeholder = null;
+        if (this.peekWord() === 'placeholder') {
+            this.consumeWord();
+            placeholder = this.expect('STRING').value;
+        }
+        this.expectNewline();
+        return { kind: 'TextField', placeholder, boundTo };
+    }
+    // image from expr [width N] [height N]
+    parseImage() {
+        this.expectWord('image');
+        this.expectWord('from');
+        const source = this.parseExpr();
+        let width = null;
+        let height = null;
+        if (this.peekWord() === 'width') {
+            this.consumeWord();
+            width = parseFloat(this.expect('NUMBER').value);
+        }
+        if (this.peekWord() === 'height') {
+            this.consumeWord();
+            height = parseFloat(this.expect('NUMBER').value);
+        }
+        this.expectNewline();
+        return { kind: 'Image', source, width, height };
+    }
+    // icon named "name" [size N]
+    parseIcon() {
+        this.expectWord('icon');
+        this.expectWord('named');
+        const name = this.expect('STRING').value;
+        let size = null;
+        if (this.peekWord() === 'size') {
+            this.consumeWord();
+            size = parseFloat(this.expect('NUMBER').value);
+        }
+        this.expectNewline();
+        return { kind: 'Icon', name, size };
+    }
+    // loading spinner [centered]
+    parseLoadingSpinner() {
+        this.expectWord('loading');
+        this.expectWord('spinner');
+        let centered = false;
+        if (this.peekWord() === 'centered') {
+            this.consumeWord();
+            centered = true;
+        }
+        this.expectNewline();
+        return { kind: 'LoadingSpinner', centered };
+    }
+    // if condition: ... [otherwise if condition: ...] [otherwise: ...]
+    parseLayoutIf() {
+        this.expectWord('if');
+        const condition = this.parseCondition();
+        this.expect('COLON');
+        this.expect('NEWLINE');
+        this.expect('INDENT');
+        const thenBranch = this.parseLayoutNodes();
+        this.expect('DEDENT');
+        const otherwiseIfBranches = [];
+        let elseBranch = null;
+        while (this.peekWord() === 'otherwise') {
+            this.consumeWord();
+            if (this.peekWord() === 'if') {
+                this.consumeWord();
+                const cond = this.parseCondition();
+                this.expect('COLON');
+                this.expect('NEWLINE');
+                this.expect('INDENT');
+                const body = this.parseLayoutNodes();
+                this.expect('DEDENT');
+                otherwiseIfBranches.push({ condition: cond, body });
+            }
+            else {
+                this.expect('COLON');
+                this.expect('NEWLINE');
+                this.expect('INDENT');
+                elseBranch = this.parseLayoutNodes();
+                this.expect('DEDENT');
+                break;
+            }
+        }
+        return { kind: 'LayoutIf', condition, thenBranch, otherwiseIfBranches, elseBranch };
+    }
+    // for each item in collection:
+    parseForEach() {
+        this.expectWord('for');
+        this.expectWord('each');
+        const item = this.expectWord();
+        this.expectWord('in');
+        const collection = this.parseExpr();
+        this.expect('COLON');
+        this.expect('NEWLINE');
+        this.expect('INDENT');
+        const children = this.parseLayoutNodes();
+        this.expect('DEDENT');
+        return { kind: 'ForEach', item, collection, children };
+    }
+    // ComponentName(prop: value, ...)
+    parseComponentCall() {
+        const name = this.expectWord();
+        const args = [];
+        if (this.check('LPAREN')) {
+            this.advance();
+            while (!this.check('RPAREN') && !this.check('EOF')) {
+                const argName = this.expectWord();
+                this.expect('COLON');
+                const argValue = this.parseExpr();
+                args.push({ name: argName, value: argValue });
+                if (this.check('COMMA'))
+                    this.advance();
+            }
+            this.expect('RPAREN');
+        }
+        this.expectNewline();
+        return { kind: 'ComponentCall', name, args };
+    }
+    // ── Type and component declarations ───────────────────────
+    parseTypeDecl() {
+        const line = this.peek().line;
+        this.consumeWord(); // consume 'noun' or 'type'
+        // Name — may include relationship clauses: "Dog that is an Animal"
+        const name = this.expectWord();
+        // Skip relationship clause: "that is a/an Animal", "that cannot be used directly",
+        // "that is Payable", "that holds T"
+        if (this.peekWord() === 'that') {
+            while (!this.check('COLON') && !this.check('NEWLINE') && !this.check('EOF')) {
+                this.advance();
+            }
+        }
+        this.expect('COLON');
+        this.expect('NEWLINE');
+        this.expect('INDENT');
+        const fields = [];
+        while (!this.check('DEDENT') && !this.check('EOF')) {
+            this.skipNewlines();
+            if (this.check('DEDENT'))
+                break;
+            const fieldLine = this.peek().line;
+            const kw = this.peekWord();
+            // Method definition inside noun — skip for now (Phase 2)
+            if (kw === 'to' || kw === 'shared' || kw === 'must') {
+                this.skipBlock();
+                continue;
+            }
+            // Trait: "has a [type] name"  |  "has a list of Type"  |  "has a Name"
+            // Hidden trait: "keep [type] name private"
+            if (kw === 'has') {
+                this.consumeWord(); // 'has'
+                const article = this.peekWord();
+                if (article === 'a' || article === 'an' || article === 'an')
+                    this.consumeWord();
+                // List trait: "has a list of Type"
+                if (this.peekWord() === 'list') {
+                    this.consumeWord();
+                    this.expectWord('of');
+                    const itemType = this.expectWord();
+                    // infer field name as lowercase plural of type
+                    const fieldName = itemType.charAt(0).toLowerCase() + itemType.slice(1) + 's';
+                    // Skip optional "starting as value"
+                    if (this.peekWord() === 'starting') {
+                        while (!this.check('NEWLINE') && !this.check('EOF'))
+                            this.advance();
+                    }
+                    this.expectNewline();
+                    fields.push({ kind: 'TypeField', name: fieldName, type: { kind: 'ListType', itemType }, line: fieldLine });
+                    continue;
+                }
+                const firstWord = this.expectWord();
+                // If next token is a WORD and not a modifier, it's "has a [type] [name]"
+                const nextIsName = this.check('WORD') &&
+                    !['starting', 'private'].includes(this.peekWord() ?? '');
+                let typeName;
+                let fieldName;
+                if (nextIsName) {
+                    // "has a text name"  — type + name both present
+                    typeName = firstWord;
+                    fieldName = this.expectWord();
+                    // Handle multi-word names: "profile photo" → profilePhoto
+                    while (this.check('WORD') && !['starting', 'private'].includes(this.peekWord() ?? '')) {
+                        const extra = this.consumeWord();
+                        fieldName = fieldName + extra.charAt(0).toUpperCase() + extra.slice(1);
+                    }
+                }
+                else {
+                    // "has a User"  — custom noun, name inferred from type
+                    typeName = firstWord;
+                    fieldName = firstWord.charAt(0).toLowerCase() + firstWord.slice(1);
+                }
+                // Optional default: "starting as value"
+                let defaultVal = null;
+                if (this.peekWord() === 'starting') {
+                    this.consumeWord();
+                    this.expectWord('as');
+                    defaultVal = this.peek().value;
+                    this.advance();
+                }
+                this.expectNewline();
+                fields.push({ kind: 'TypeField', name: fieldName, type: { kind: 'SimpleType', name: typeName }, line: fieldLine });
+                continue;
+            }
+            if (kw === 'keep') {
+                // "keep [type] name private" or "keep [type] name starting as value private"
+                this.consumeWord(); // 'keep'
+                const typeName = this.expectWord();
+                const fieldName = this.expectWord();
+                // Skip the rest of the line (starting as, private)
+                while (!this.check('NEWLINE') && !this.check('EOF'))
+                    this.advance();
+                this.expectNewline();
+                fields.push({ kind: 'TypeField', name: fieldName, type: { kind: 'SimpleType', name: typeName }, line: fieldLine });
+                continue;
+            }
+            // Unknown — skip line
+            while (!this.check('NEWLINE') && !this.check('EOF'))
+                this.advance();
+            this.expectNewline();
+        }
+        this.expect('DEDENT');
+        return { kind: 'TypeDecl', name, fields, line };
+    }
+    parseComponentDecl() {
+        const line = this.peek().line;
+        this.expectWord('component');
+        const name = this.expectWord();
+        const params = [];
+        if (this.check('LPAREN')) {
+            this.advance();
+            while (!this.check('RPAREN') && !this.check('EOF')) {
+                const pName = this.expectWord();
+                this.expect('COLON');
+                const pType = this.expectWord();
+                params.push({ name: pName, type: { kind: 'SimpleType', name: pType } });
+                if (this.check('COMMA'))
+                    this.advance();
+            }
+            this.expect('RPAREN');
+        }
+        this.expect('COLON');
+        this.expect('NEWLINE');
+        this.expect('INDENT');
+        const events = [];
+        let layout = [];
+        while (!this.check('DEDENT') && !this.check('EOF')) {
+            this.skipNewlines();
+            if (this.check('DEDENT'))
+                break;
+            const word = this.peekWord();
+            if (word === 'when') {
+                events.push(this.parseEventHandler());
+            }
+            else {
+                // Everything else is layout
+                layout = this.parseLayoutNodes();
+            }
+        }
+        this.expect('DEDENT');
+        return { kind: 'ComponentDecl', name, params, layout, events, line };
+    }
+    // ── Skip helpers ──────────────────────────────────────────
+    skipBlock() {
+        // Consume until the block is finished (reached matching DEDENT)
+        while (!this.check('COLON') && !this.check('NEWLINE') && !this.check('EOF'))
+            this.advance();
+        if (this.check('COLON'))
+            this.advance();
+        if (this.check('NEWLINE'))
+            this.advance();
+        if (this.check('INDENT')) {
+            let depth = 1;
+            this.advance();
+            while (depth > 0 && !this.check('EOF')) {
+                if (this.check('INDENT')) {
+                    depth++;
+                    this.advance();
+                }
+                else if (this.check('DEDENT')) {
+                    depth--;
+                    this.advance();
+                }
+                else
+                    this.advance();
+            }
+        }
+    }
+    // ── Token primitives ──────────────────────────────────────
+    peek(offset = 0) {
+        const idx = this.pos + offset;
+        return this.tokens[idx] ?? this.tokens[this.tokens.length - 1];
+    }
+    advance() {
+        const tok = this.tokens[this.pos];
+        this.pos++;
+        return tok;
+    }
+    check(type, value) {
+        const tok = this.peek();
+        if (tok.type !== type)
+            return false;
+        if (value !== undefined && tok.value !== value)
+            return false;
+        return true;
+    }
+    expect(type, value) {
+        if (!this.check(type, value)) {
+            const got = this.peek();
+            const expected = value ? `${type}("${value}")` : type;
+            throw this.error(`Expected ${expected}, got ${got.type}("${got.value}")`);
+        }
+        return this.advance();
+    }
+    peekWord() {
+        const tok = this.peek();
+        return tok.type === 'WORD' ? tok.value : null;
+    }
+    expectWord(value) {
+        const tok = this.peek();
+        if (tok.type !== 'WORD') {
+            throw this.error(`Expected word${value ? ` "${value}"` : ''}, got ${tok.type}("${tok.value}")`);
+        }
+        if (value !== undefined && tok.value !== value) {
+            throw this.error(`Expected word "${value}", got "${tok.value}"`);
+        }
+        this.advance();
+        return tok.value;
+    }
+    consumeWord() {
+        return this.expectWord();
+    }
+    expectNewline() {
+        if (this.check('NEWLINE')) {
+            this.advance();
+            return;
+        }
+        // At end of block / file — acceptable
+        if (this.check('DEDENT') || this.check('EOF'))
+            return;
+        throw this.error(`Expected newline, got ${this.peek().type}("${this.peek().value}")`);
+    }
+    skipNewlines() {
+        while (this.check('NEWLINE'))
+            this.advance();
+    }
+    error(msg) {
+        const tok = this.peek();
+        return new Error(`[Parser] Line ${tok.line}: ${msg}`);
+    }
+}
+exports.Parser = Parser;