fazer-lang 1.1.0 → 2.1.0

package/fazer.js

@@ -1,234 +1,1228 @@
 #!/usr/bin/env node
+"use strict";
+
+/*
+  Fazer v2 — interpreter "batteries included"
+  - Chevrotain lexer/parser → AST
+  - Runtime with scopes, functions, pipes, lists/maps, property/index access
+  - Stdlib: fs/path/crypto/encoding/ui
+*/
+
+const fs = require("fs");
+const path = require("path");
+const crypto = require("crypto");
+const { Lexer, createToken, EmbeddedActionsParser } = require("chevrotain");
+
+/* ────────────────────────────────────────────────────────────────────────── */
+/* Tokens                                                                     */
+/* ────────────────────────────────────────────────────────────────────────── */
+
+const WhiteSpace = createToken({ name: "WhiteSpace", pattern: /[ \t\r\n]+/, group: Lexer.SKIPPED });
+const Comment = createToken({ name: "Comment", pattern: /#[^\n]*/, group: Lexer.SKIPPED });
+
+const Assign = createToken({ name: "Assign", pattern: /:=/ });
+
+const Arrow = createToken({ name: "Arrow", pattern: /→/ });
+const DoublePipe = createToken({ name: "DoublePipe", pattern: /→>/ });
+
+const Case = createToken({ name: "Case", pattern: /case\b/ });
+const Else = createToken({ name: "Else", pattern: /else\b/ });
+const End = createToken({ name: "End", pattern: /end\b/ });
+
+const Fn = createToken({ name: "Fn", pattern: /fn\b/ });
+const Return = createToken({ name: "Return", pattern: /return\b/ });
+const Mut = createToken({ name: "Mut", pattern: /mut\b/ });
+
+const True = createToken({ name: "True", pattern: /true\b/ });
+const False = createToken({ name: "False", pattern: /false\b/ });
+const Null = createToken({ name: "Null", pattern: /null\b/ });
+
+const And = createToken({ name: "And", pattern: /and\b/ });
+const Or = createToken({ name: "Or", pattern: /or\b/ });
+const Not = createToken({ name: "Not", pattern: /not\b/ });
+
+const GreaterEq = createToken({ name: "GreaterEq", pattern: />=/ });
+const LessEq = createToken({ name: "LessEq", pattern: /<=/ });
+const Eq = createToken({ name: "Eq", pattern: /==/ });
+const NotEq = createToken({ name: "NotEq", pattern: /!=/ });
+const Greater = createToken({ name: "Greater", pattern: />/ });
+const Less = createToken({ name: "Less", pattern: /</ });
+
+const LParen = createToken({ name: "LParen", pattern: /\(/ });
+const RParen = createToken({ name: "RParen", pattern: /\)/ });
+const LBracket = createToken({ name: "LBracket", pattern: /\[/ });
+const RBracket = createToken({ name: "RBracket", pattern: /\]/ });
+const LBrace = createToken({ name: "LBrace", pattern: /{/ });
+const RBrace = createToken({ name: "RBrace", pattern: /}/ });
+
+const Colon = createToken({ name: "Colon", pattern: /:/ });
+const Comma = createToken({ name: "Comma", pattern: /,/ });
+const Dot = createToken({ name: "Dot", pattern: /\./ });
+
+const Plus = createToken({ name: "Plus", pattern: /\+/ });
+const Minus = createToken({ name: "Minus", pattern: /-/ });
+const Star = createToken({ name: "Star", pattern: /\*/ });
+const Slash = createToken({ name: "Slash", pattern: /\// });
+const Percent = createToken({ name: "Percent", pattern: /%/ });
+
+const Float = createToken({ name: "Float", pattern: /-?\d+\.\d+/ });
+const Integer = createToken({ name: "Integer", pattern: /-?\d+/ });
+const StringLiteral = createToken({
+  name: "StringLiteral",
+  pattern: /"([^"\\]|\\.)*"/,
+});
+
+const Identifier = createToken({
+  name: "Identifier",
+  pattern: /[a-zA-Z_][a-zA-Z0-9_]*/,
+});
+
+const allTokens = [
+  WhiteSpace,
+  Comment,
+
+  Assign,
+
+  DoublePipe,
+  Arrow,
+
+  Case,
+  Else,
+  End,
+
+  Fn,
+  Return,
+  Mut,
+
+  True,
+  False,
+  Null,
+
+  And,
+  Or,
+  Not,
+
+  GreaterEq,
+  LessEq,
+  Eq,
+  NotEq,
+  Greater,
+  Less,
+
+  LParen,
+  RParen,
+  LBracket,
+  RBracket,
+  LBrace,
+  RBrace,
+
+  Colon,
+  Comma,
+  Dot,
+
+  Plus,
+  Minus,
+  Star,
+  Slash,
+  Percent,
+
+  Float,
+  Integer,
+  StringLiteral,
+  Identifier,
+];
+
+const lexer = new Lexer(allTokens, { positionTracking: "full" });
+
+/* ────────────────────────────────────────────────────────────────────────── */
+/* Parser → AST                                                               */
+/* ────────────────────────────────────────────────────────────────────────── */
 
-const fs = require('fs');
-const path = require('path');
-const { Lexer, Parser, createToken, EmbeddedActionsParser } = require('chevrotain');
-
-// Tokens (restent les mêmes, ajoutés Equals, NotEq, And, Or, Not pour expressions)
-const Assign        = createToken({ name: 'Assign',        pattern: /:=/ });
-const Arrow         = createToken({ name: 'Arrow',         pattern: /→/ });
-const DoublePipe    = createToken({ name: 'DoublePipe',    pattern: /→>/ });
-const Case          = createToken({ name: 'Case',          pattern: /case/ });
-const Rescue        = createToken({ name: 'Rescue',        pattern: /rescue/ });
-const Catch         = createToken({ name: 'Catch',         pattern: /catch/ });
-const From          = createToken({ name: 'From',          pattern: /from/ });
-const End           = createToken({ name: 'End',           pattern: /end/ });
-const Await         = createToken({ name: 'Await',         pattern: /await/ });
-const Mut           = createToken({ name: 'Mut',           pattern: /mut/ });
-const Async         = createToken({ name: 'Async',         pattern: /async/ });
-const Else          = createToken({ name: 'Else',          pattern: /else/ });
-const In            = createToken({ name: 'In',            pattern: /in/ });
-const Step          = createToken({ name: 'Step',          pattern: /step/ });
-
-const Identifier    = createToken({ name: 'Identifier',    pattern: /[a-zA-Z_][a-zA-Z0-9_]*/ });
-const Integer       = createToken({ name: 'Integer',       pattern: /-?\d+/ });
-const Float         = createToken({ name: 'Float',         pattern: /-?\d+\.\d+/ });
-const StringLiteral = createToken({ name: 'StringLiteral', pattern: /"([^"\\]|\\.)*"/ });
-const True          = createToken({ name: 'True',          pattern: /true/ });
-const False         = createToken({ name: 'False',         pattern: /false/ });
-const Colon         = createToken({ name: 'Colon',         pattern: /:/ });
-const LBracket      = createToken({ name: 'LBracket',      pattern: /\[/ });
-const RBracket      = createToken({ name: 'RBracket',      pattern: /\]/ });
-const LBrace        = createToken({ name: 'LBrace',        pattern: /{/ });
-const RBrace        = createToken({ name: 'RBrace',        pattern: /}/ });
-const Comma         = createToken({ name: 'Comma',         pattern: /,/ });
-const Dot           = createToken({ name: 'Dot',           pattern: /\./ });
-const Plus          = createToken({ name: 'Plus',          pattern: /\+/ });
-const Minus         = createToken({ name: 'Minus',         pattern: /-/ });
-const Star          = createToken({ name: 'Star',          pattern: /\*/ });
-const Slash         = createToken({ name: 'Slash',         pattern: /\// });
-const Percent       = createToken({ name: 'Percent',       pattern: /%/ });
-const Greater       = createToken({ name: 'Greater',       pattern: />/ });
-const Less          = createToken({ name: 'Less',          pattern: /</ });
-const GreaterEq     = createToken({ name: 'GreaterEq',     pattern: />=/ });
-const LessEq        = createToken({ name: 'LessEq',        pattern: /<=/ });
-const Eq            = createToken({ name: 'Eq',            pattern: /==/ });
-const NotEq         = createToken({ name: 'NotEq',         pattern: /!=/ });
-const And           = createToken({ name: 'And',           pattern: /and/ });
-const Or            = createToken({ name: 'Or',            pattern: /or/ });
-const Not           = createToken({ name: 'Not',           pattern: /not/ });
-const Comment       = createToken({ name: 'Comment',       pattern: /#.*/, group: Lexer.SKIPPED });
-const WhiteSpace    = createToken({ name: 'WhiteSpace',    pattern: /\s+/, group: Lexer.SKIPPED });
-
-const lexer = new Lexer([
-  Assign, Arrow, DoublePipe, Case, Rescue, Catch, From, End, Await, Mut, Async, Else, In, Step,
-  Identifier, Float, Integer, StringLiteral, True, False, Colon, LBracket, RBracket, LBrace, RBrace,
-  Comma, Dot, Plus, Minus, Star, Slash, Percent, Greater, Less, GreaterEq, LessEq, Eq, NotEq, And, Or, Not,
-  Comment, WhiteSpace
-]);
-
-// ── Parser avec Embedded Actions (exécution inline) ──────────────────────────
 class FazerParser extends EmbeddedActionsParser {
   constructor() {
-    super(lexer.allTokens);
+    super(allTokens, { recoveryEnabled: true });
     const $ = this;
 
-    $.RULE('program', () => {
-      const stmts = $.MANY(() => $.SUBRULE($.statement));
+    const node = (type, props) => ({ type, ...props });
+
+    $.RULE("program", () => {
+      const stmts = [];
+      $.MANY(() => {
+        const s = $.SUBRULE($.statement);
+        if (s) stmts.push(s);
+      });
       return stmts;
     });
 
-    $.RULE('statement', () => $.OR([
-      { ALT: () => $.SUBRULE($.assignStmt) },
-      { ALT: () => $.SUBRULE($.functionDef) },
-      { ALT: () => $.SUBRULE($.caseBlock) },
-      { ALT: () => $.SUBRULE($.rescueBlock) },
-      { ALT: () => $.SUBRULE($.expressionStmt) }
-    ]));
+    $.RULE("statement", () =>
+      $.OR([
+        { ALT: () => $.SUBRULE($.fnDef) },
+        { ALT: () => $.SUBRULE($.returnStmt) },
+        { ALT: () => $.SUBRULE($.assignStmt) },
+        { ALT: () => $.SUBRULE($.caseBlock) },
+        { ALT: () => $.SUBRULE($.exprStmt) },
+      ])
+    );
 
-    $.RULE('assignStmt', () => {
-      const isMut = $.OPTION(() => $.CONSUME(Mut));
-      const id = $.CONSUME(Identifier);
-      let type = null;
-      $.OPTION2(() => {
-        $.CONSUME(Colon);
-        type = $.CONSUME2(Identifier).image;
+    $.RULE("fnDef", () => {
+      $.CONSUME(Fn);
+      const nameTok = $.CONSUME(Identifier);
+      $.CONSUME(LParen);
+      const params = [];
+      $.OPTION(() => {
+        params.push($.CONSUME2(Identifier).image);
+        $.MANY(() => {
+          $.CONSUME(Comma);
+          params.push($.CONSUME3(Identifier).image);
+        });
       });
+      $.CONSUME(RParen);
+      $.CONSUME(Arrow);
+      const body = $.SUBRULE($.block);
+      return node("fn", { name: nameTok.image, params, body, loc: locOf(nameTok) });
+    });
+
+    $.RULE("returnStmt", () => {
+      const tok = $.CONSUME(Return);
+      const value = $.OPTION(() => $.SUBRULE($.expression));
+      return node("return", { value: value ?? node("null", {}), loc: locOf(tok) });
+    });
+
+    $.RULE("assignStmt", () => {
+      const mutTok = $.OPTION(() => $.CONSUME(Mut));
+      const idTok = $.CONSUME(Identifier);
       $.CONSUME(Assign);
       const value = $.SUBRULE($.expression);
-      return { type: 'assign', mut: !!isMut, name: id.image, varType: type, value };
+      return node("assign", {
+        name: idTok.image,
+        mut: !!mutTok,
+        value,
+        loc: locOf(idTok),
+      });
     });
 
-    $.RULE('caseBlock', () => {
-      $.CONSUME(Case);
+    $.RULE("caseBlock", () => {
+      const caseTok = $.CONSUME(Case);
       const expr = $.SUBRULE($.expression);
-      const cases = [];
-      $.MANY(() => {
-        let pattern = $.OR([
+      const arms = [];
+      $.AT_LEAST_ONE(() => {
+        const pat = $.OR([
           { ALT: () => $.SUBRULE($.pattern) },
-          { ALT: () => $.CONSUME(Else) ? 'else' : null }
+          { ALT: () => ( $.CONSUME(Else), node("else", {}) ) },
         ]);
         $.CONSUME(Arrow);
         const body = $.SUBRULE($.block);
-        cases.push({ pattern, body });
+        arms.push({ pat, body });
       });
-      return { type: 'case', expr, cases };
+      $.CONSUME(End);
+      return node("case", { expr, arms, loc: locOf(caseTok) });
     });
 
-    $.RULE('block', () => {
-      const stmts = $.MANY(() => $.SUBRULE($.statement));
+    $.RULE("block", () => {
+      const stmts = [];
+      $.MANY(() => {
+        const s = $.SUBRULE($.statement);
+        if (s) stmts.push(s);
+      });
       $.CONSUME(End);
       return stmts;
     });
 
-    $.RULE('expression', () => {
-      let left = $.SUBRULE($.primaryExpr);
+    $.RULE("exprStmt", () => {
+      const expr = $.SUBRULE($.expression);
+      if (!expr) return node("noop", {});
+      return node("exprstmt", { expr, loc: expr.loc ?? null });
+    });
+
+    $.RULE("pattern", () =>
+      $.OR([
+        { ALT: () => $.SUBRULE($.patternCompare) },
+        { ALT: () => $.SUBRULE($.literal) },
+        { ALT: () => node("identPat", { name: $.CONSUME(Identifier).image }) }, // binds
+      ])
+    );
+
+    $.RULE("patternCompare", () => {
+      // Examples:
+      //   > 10
+      //   <= 3
+      const op = $.OR([
+        { ALT: () => $.CONSUME(GreaterEq).image },
+        { ALT: () => $.CONSUME(LessEq).image },
+        { ALT: () => $.CONSUME(Greater).image },
+        { ALT: () => $.CONSUME(Less).image },
+        { ALT: () => $.CONSUME(Eq).image },
+        { ALT: () => $.CONSUME(NotEq).image },
+      ]);
+      const rhs = $.SUBRULE($.expression);
+      return node("cmpPat", { op, rhs });
+    });
+
+    /* Expression precedence:
+      pipe →>   (lowest)
+      or
+      and
+      equality
+      relational
+      additive
+      multiplicative
+      unary
+      postfix (calls, dot, index)
+      primary
+    */
+
+    $.RULE("expression", () => $.SUBRULE($.pipeExpr));
+
+    $.RULE("pipeExpr", () => {
+      let left = $.SUBRULE($.orExpr);
+      $.MANY(() => {
+        $.CONSUME(DoublePipe);
+        const right = $.SUBRULE2($.orExpr);
+        left = node("pipe", { left, right, loc: left.loc ?? null });
+      });
+      return left;
+    });
+
+    $.RULE("orExpr", () => {
+      let left = $.SUBRULE($.andExpr);
+      $.MANY(() => {
+        $.CONSUME(Or);
+        const right = $.SUBRULE2($.andExpr);
+        left = node("bin", { op: "or", left, right, loc: left.loc ?? null });
+      });
+      return left;
+    });
+
+    $.RULE("andExpr", () => {
+      let left = $.SUBRULE($.eqExpr);
+      $.MANY(() => {
+        $.CONSUME(And);
+        const right = $.SUBRULE2($.eqExpr);
+        left = node("bin", { op: "and", left, right, loc: left.loc ?? null });
+      });
+      return left;
+    });
+
+    $.RULE("eqExpr", () => {
+      let left = $.SUBRULE($.relExpr);
+      $.MANY(() => {
+        const op = $.OR([
+          { ALT: () => $.CONSUME(Eq).image },
+          { ALT: () => $.CONSUME(NotEq).image },
+        ]);
+        const right = $.SUBRULE2($.relExpr);
+        left = node("bin", { op, left, right, loc: left.loc ?? null });
+      });
+      return left;
+    });
+
+    $.RULE("relExpr", () => {
+      let left = $.SUBRULE($.addExpr);
+      $.MANY(() => {
+        const op = $.OR([
+          { ALT: () => $.CONSUME(GreaterEq).image },
+          { ALT: () => $.CONSUME(LessEq).image },
+          { ALT: () => $.CONSUME(Greater).image },
+          { ALT: () => $.CONSUME(Less).image },
+        ]);
+        const right = $.SUBRULE2($.addExpr);
+        left = node("bin", { op, left, right, loc: left.loc ?? null });
+      });
+      return left;
+    });
+
+    $.RULE("addExpr", () => {
+      let left = $.SUBRULE($.mulExpr);
       $.MANY(() => {
         const op = $.OR([
           { ALT: () => $.CONSUME(Plus).image },
           { ALT: () => $.CONSUME(Minus).image },
+        ]);
+        const right = $.SUBRULE2($.mulExpr);
+        left = node("bin", { op, left, right, loc: left.loc ?? null });
+      });
+      return left;
+    });
+
+    $.RULE("mulExpr", () => {
+      let left = $.SUBRULE($.unaryExpr);
+      $.MANY(() => {
+        const op = $.OR([
           { ALT: () => $.CONSUME(Star).image },
-          { ALT: () => $.CONSUME(Slash).image }
+          { ALT: () => $.CONSUME(Slash).image },
+          { ALT: () => $.CONSUME(Percent).image },
         ]);
-        const right = $.SUBRULE2($.primaryExpr);
-        left = { type: 'binop', op, left, right };
+        const right = $.SUBRULE2($.unaryExpr);
+        left = node("bin", { op, left, right, loc: left.loc ?? null });
       });
       return left;
     });
 
-    $.RULE('primaryExpr', () => $.OR([
-      { ALT: () => $.CONSUME(Integer).image },
-      { ALT: () => $.CONSUME(StringLiteral).image.slice(1, -1) },
-      { ALT: () => $.CONSUME(Identifier).image },
-      // Ajouter list, map, call, etc.
-    ]));
+    $.RULE("unaryExpr", () =>
+      $.OR([
+        {
+          ALT: () => {
+            const tok = $.CONSUME(Not);
+            const expr = $.SUBRULE($.unaryExpr);
+            return node("un", { op: "not", expr, loc: locOf(tok) });
+          },
+        },
+        {
+          ALT: () => {
+            const tok = $.CONSUME(Minus);
+            const expr = $.SUBRULE2($.unaryExpr);
+            return node("un", { op: "-", expr, loc: locOf(tok) });
+          },
+        },
+        { ALT: () => $.SUBRULE($.postfixExpr) },
+      ])
+    );
+
+    $.RULE("postfixExpr", () => {
+      let base = $.SUBRULE($.primaryExpr);
+
+      $.MANY(() => {
+        $.OR([
+          {
+            ALT: () => {
+              // call: foo(a,b)
+              $.CONSUME(LParen);
+              const args = [];
+              $.OPTION(() => {
+                args.push($.SUBRULE($.expression));
+                $.MANY2(() => {
+                  $.CONSUME(Comma);
+                  args.push($.SUBRULE2($.expression));
+                });
+              });
+              $.CONSUME(RParen);
+              base = node("call", { callee: base, args, loc: base.loc ?? null });
+            },
+          },
+          {
+            ALT: () => {
+              // dot: obj.key
+              $.CONSUME(Dot);
+              const keyTok = $.CONSUME(Identifier);
+              base = node("get", { obj: base, key: node("str", { value: keyTok.image }), loc: base.loc ?? null });
+            },
+          },
+          {
+            ALT: () => {
+              // index: obj[expr]
+              $.CONSUME(LBracket);
+              const idx = $.SUBRULE3($.expression);
+              $.CONSUME(RBracket);
+              base = node("idx", { obj: base, idx, loc: base.loc ?? null });
+            },
+          },
+        ]);
+      });
+
+      return base;
+    });
+
+    $.RULE("primaryExpr", () =>
+      $.OR([
+        { ALT: () => $.SUBRULE($.literal) },
+        {
+          ALT: () => {
+            const tok = $.CONSUME(Identifier);
+            return node("ident", { name: tok.image, loc: locOf(tok) });
+          },
+        },
+        {
+          ALT: () => {
+            $.CONSUME(LParen);
+            const e = $.SUBRULE($.expression);
+            $.CONSUME(RParen);
+            return e;
+          },
+        },
+        { ALT: () => $.SUBRULE($.listLiteral) },
+        { ALT: () => $.SUBRULE($.mapLiteral) },
+      ])
+    );
+
+    $.RULE("literal", () =>
+      $.OR([
+        {
+          ALT: () => {
+            const tok = $.CONSUME(Float);
+            return node("num", { value: Number(tok.image), loc: locOf(tok) });
+          },
+        },
+        {
+          ALT: () => {
+            const tok = $.CONSUME(Integer);
+            return node("num", { value: Number(tok.image), loc: locOf(tok) });
+          },
+        },
+        {
+          ALT: () => {
+            const tok = $.CONSUME(StringLiteral);
+            return node("str", { value: unescapeString(tok.image), loc: locOf(tok) });
+          },
+        },
+        {
+          ALT: () => {
+            const tok = $.CONSUME(True);
+            return node("bool", { value: true, loc: locOf(tok) });
+          },
+        },
+        {
+          ALT: () => {
+            const tok = $.CONSUME(False);
+            return node("bool", { value: false, loc: locOf(tok) });
+          },
+        },
+        {
+          ALT: () => {
+            const tok = $.CONSUME(Null);
+            return node("null", { loc: locOf(tok) });
+          },
+        },
+      ])
+    );
+
+    $.RULE("listLiteral", () => {
+      const tok = $.CONSUME(LBracket);
+      const items = [];
+      $.OPTION(() => {
+        items.push($.SUBRULE($.expression));
+        $.MANY(() => {
+          $.CONSUME(Comma);
+          items.push($.SUBRULE2($.expression));
+        });
+      });
+      $.CONSUME(RBracket);
+      return node("list", { items, loc: locOf(tok) });
+    });
+
+    $.RULE("mapLiteral", () => {
+      const tok = $.CONSUME(LBrace);
+      const entries = [];
+      $.OPTION(() => {
+        entries.push($.SUBRULE($.mapEntry));
+        $.MANY(() => {
+          $.CONSUME(Comma);
+          entries.push($.SUBRULE2($.mapEntry));
+        });
+      });
+      $.CONSUME(RBrace);
+      return node("map", { entries, loc: locOf(tok) });
+    });
 
-    // Ajouter rules pour functionDef, rescueBlock, pattern, etc.
+    $.RULE("mapEntry", () => {
+      // key can be Identifier or String
+      const key = $.OR([
+        {
+          ALT: () => {
+            const t = $.CONSUME(StringLiteral);
+            return node("str", { value: unescapeString(t.image), loc: locOf(t) });
+          },
+        },
+        {
+          ALT: () => {
+            const t = $.CONSUME(Identifier);
+            return node("str", { value: t.image, loc: locOf(t) });
+          },
+        },
+      ]);
+      $.CONSUME(Colon);
+      const value = $.SUBRULE($.expression);
+      return { key, value };
+    });
 
     this.performSelfAnalysis();
   }
 }
 
-// ── Runtime (exécution du CST) ───────────────────────────────────────────────
-class FazerRuntime {
-  constructor() {
-    this.vars = new Map(); // name → {value, mut, type}
-    this.fns = new Map();
-  }
-
-  evalExpr(node) {
-    if (typeof node === 'string' || typeof node === 'number') return node;
-    if (node.type === 'binop') {
-      const left = this.evalExpr(node.left);
-      const right = this.evalExpr(node.right);
-      switch (node.op) {
-        case '+': return left + right;
-        case '-': return left - right;
-        case '*': return left * right;
-        case '/': return left / right;
-      }
+/* ────────────────────────────────────────────────────────────────────────── */
+/* Runtime                                                                     */
+/* ────────────────────────────────────────────────────────────────────────── */
+
+class FazerError extends Error {
+  constructor(message, meta = {}) {
+    super(message);
+    this.name = "FazerError";
+    this.meta = meta;
+  }
+}
+
+class ReturnSignal {
+  constructor(value) {
+    this.value = value;
+  }
+}
+
+class Scope {
+  constructor(parent = null) {
+    this.parent = parent;
+    this.vars = new Map(); // name -> {value, mut}
+  }
+  hasHere(name) { return this.vars.has(name); }
+  get(name) {
+    if (this.vars.has(name)) return this.vars.get(name);
+    if (this.parent) return this.parent.get(name);
+    return null;
+  }
+  set(name, value, mut = false) {
+    this.vars.set(name, { value, mut });
+  }
+  assign(name, value) {
+    if (this.vars.has(name)) {
+      const cell = this.vars.get(name);
+      if (!cell.mut) throw new FazerError(`Variable '${name}' is immutable (use mut)`);
+      cell.value = value;
+      return;
     }
-    if (node === 'print') {
-      console.log(this.evalExpr(node.args));
+    if (this.parent) return this.parent.assign(name, value);
+    throw new FazerError(`Undefined variable '${name}'`);
+  }
+}
+
+class FazerRuntime {
+  constructor({ argv = process.argv.slice(2), filename = "<stdin>", code = "" } = {}) {
+    this.filename = filename;
+    this.code = code;
+    this.global = new Scope(null);
+    this.fns = new Map(); // name -> {params, body, closure}
+    this._installStdlib(argv);
+  }
+
+  _installStdlib(argv) {
+    const { execFileSync } = require("child_process");
+
+    const ANSI = {
+      reset: "\x1b[0m",
+      bold: "\x1b[1m",
+      dim: "\x1b[2m",
+      red: "\x1b[31m",
+      green: "\x1b[32m",
+      yellow: "\x1b[33m",
+      blue: "\x1b[34m",
+      magenta: "\x1b[35m",
+      cyan: "\x1b[36m",
+      gray: "\x1b[90m",
+    };
+
+    const style = (s, c) => (ANSI[c] || "") + String(s) + ANSI.reset;
+
+    const stripAnsi = (s) => String(s).replace(/\x1b\[[0-9;]*m/g, "");
+
+    const box = (title, lines) => {
+      const arr = Array.isArray(lines) ? lines.map(String) : [String(lines)];
+      const all = [String(title), ...arr];
+      
+      const visibleLen = (s) => stripAnsi(s).length;
+      const w = Math.max(...all.map(visibleLen)) + 4;
+      
+      const top = "┌" + "─".repeat(w - 2) + "┐";
+      const bot = "└" + "─".repeat(w - 2) + "┘";
+      
+      const mid = all.map((l) => {
+        const vl = visibleLen(l);
+        const pad = w - 4 - vl;
+        return "│ " + l + " ".repeat(Math.max(0, pad)) + " │";
+      });
+      
+      console.log(top);
+      for (const m of mid) console.log(m);
+      console.log(bot);
       return null;
+    };
+
+    const toBuf = (x, enc = "utf8") => {
+      if (Buffer.isBuffer(x)) return x;
+      if (typeof x === "string") return Buffer.from(x, enc);
+      return Buffer.from(String(x), enc);
+    };
+
+    const readText = (p) => fs.readFileSync(path.resolve(String(p)), "utf8");
+    const writeText = (p, s) => { fs.writeFileSync(path.resolve(String(p)), String(s), "utf8"); return null; };
+
+    const readBytesB64 = (p) => fs.readFileSync(path.resolve(String(p))).toString("base64");
+    const writeBytesB64 = (p, b64) => { fs.writeFileSync(path.resolve(String(p)), Buffer.from(String(b64), "base64")); return null; };
+
+    const hex = (buf) => Buffer.from(buf).toString("hex");
+    const b64 = (buf) => Buffer.from(buf).toString("base64");
+    const fromHex = (h) => Buffer.from(String(h), "hex");
+    const fromB64 = (b) => Buffer.from(String(b), "base64");
+
+    const sha256 = (x) => hex(crypto.createHash("sha256").update(toBuf(x)).digest());
+
+    // AES-256-GCM(payload): [salt16|iv12|tag16|ct...], base64-encoded
+    const encText = (plaintext, password) => {
+      const salt = crypto.randomBytes(16);
+      const key = crypto.scryptSync(String(password), salt, 32);
+      const iv = crypto.randomBytes(12);
+      const cipher = crypto.createCipheriv("aes-256-gcm", key, iv);
+      const ct = Buffer.concat([cipher.update(String(plaintext), "utf8"), cipher.final()]);
+      const tag = cipher.getAuthTag();
+      return b64(Buffer.concat([salt, iv, tag, ct]));
+    };
+
+    const decText = (payloadB64, password) => {
+      const payload = fromB64(payloadB64);
+      if (payload.length < 16 + 12 + 16) throw new FazerError("Invalid encrypted payload");
+      const salt = payload.subarray(0, 16);
+      const iv = payload.subarray(16, 28);
+      const tag = payload.subarray(28, 44);
+      const ct = payload.subarray(44);
+      const key = crypto.scryptSync(String(password), salt, 32);
+      const decipher = crypto.createDecipheriv("aes-256-gcm", key, iv);
+      decipher.setAuthTag(tag);
+      const pt = Buffer.concat([decipher.update(ct), decipher.final()]);
+      return pt.toString("utf8");
+    };
+
+    const encB64 = (b64data, password) => encText(String(b64data), password);
+    const decB64 = (payloadB64, password) => decText(payloadB64, password);
+
+    const pathJoin = (...xs) => path.join(...xs.map(String));
+    const pathAbs = (p) => path.resolve(String(p));
+    const pathDir = (p) => path.dirname(String(p));
+    const pathBase = (p) => path.basename(String(p));
+
+    const nowMs = () => Date.now();
+    const len = (x) => (x == null ? 0 : (typeof x === "string" || Array.isArray(x)) ? x.length : (typeof x === "object" ? Object.keys(x).length : 0));
+
+    const keys = (o) => {
+      if (o == null || typeof o !== "object") return [];
+      return Object.keys(o);
+    };
+
+    const get = (o, k) => {
+      if (o == null) return null;
+      if (Array.isArray(o)) return o[Number(k)];
+      return o[String(k)];
+    };
+
+    const set = (o, k, v) => {
+      if (o == null || typeof o !== "object") throw new FazerError("set(obj,key,val) expects object/list");
+      if (Array.isArray(o)) { o[Number(k)] = v; return o; }
+      o[String(k)] = v; return o;
+    };
+
+    const argvFn = () => argv.slice();
+    const envFn = (k) => process.env[String(k)] ?? null;
+    const cwdFn = () => process.cwd();
+
+    const http = require("http");
+    const child_process = require("child_process");
+
+    // register builtins in global scope
+    const builtins = {
+      println: (x = "") => (console.log(String(x)), null),
+      print: (x = "") => (process.stdout.write(String(x)), null),
+      ask: (prompt = "") => {
+        process.stdout.write(String(prompt));
+        const buf = Buffer.alloc(1);
+        let str = "";
+        try {
+          while (true) {
+            const n = fs.readSync(0, buf, 0, 1, null);
+            if (n === 0) break;
+            const c = buf.toString();
+            if (c === "\r") continue;
+            if (c === "\n") break;
+            str += c;
+          }
+          return str;
+        } catch (e) {
+          return null;
+        }
+      },
+
+      style: (s, color) => style(s, String(color || "reset")),
+      box: (title, ...lines) => box(title, lines),
+
+      readText,
+      writeText,
+      saveText: (s, p) => { fs.writeFileSync(path.resolve(String(p)), String(s), "utf8"); return null; },
+      exists: (p) => fs.existsSync(path.resolve(String(p))),
+      ls: (p) => { try { return fs.readdirSync(path.resolve(String(p || "."))); } catch(e) { return []; } },
+      rm: (p) => { try { fs.rmSync(path.resolve(String(p)), { recursive: true, force: true }); return true; } catch(e) { return false; } },
+      mkdir: (p) => { try { fs.mkdirSync(path.resolve(String(p)), { recursive: true }); return true; } catch(e) { return false; } },
+      
+      readB64: readBytesB64,
+      writeB64: writeBytesB64,
+      saveB64: (s, p) => { fs.writeFileSync(path.resolve(String(p)), Buffer.from(String(s), "base64")); return null; },
+
+      sha256,
+      encText,
+      decText,
+      encB64,
+      decB64,
+
+      hex,
+      b64,
+      fromHex,
+      fromB64,
+
+      join: pathJoin,
+      abs: pathAbs,
+      dir: pathDir,
+      base: pathBase,
+
+      nowMs,
+      len,
+      keys,
+      get,
+      set,
+      
+      json: (x) => JSON.stringify(x, null, 2),
+      parseJson: (s) => JSON.parse(s),
+      
+      exec: (cmd) => {
+        try {
+          return child_process.execSync(String(cmd)).toString();
+        } catch (e) {
+          return null;
+        }
+      },
+      
+      server: (port, handlerName) => {
+        const srv = http.createServer((req, res) => {
+           // We need to call the Fazer function `handlerName`
+           // But `this._call` requires scope context.
+           // This is tricky in a sync interpreter loop.
+           // For now, simple static server or basic response?
+           // To do it properly, we need to invoke the runtime from the callback.
+           // Since we are inside the class, we can do it!
+           
+           // We need to find the function in `this.fns`
+           const fn = this.fns.get(handlerName);
+           if (!fn) {
+             res.writeHead(500);
+             res.end("Handler not found");
+             return;
+           }
+           
+           // Construct request object
+           const reqObj = {
+             method: req.method,
+             url: req.url,
+             headers: req.headers
+           };
+           
+           // Call handler(req) -> { status, body, headers }
+           try {
+             const inner = new Scope(fn.closure);
+             inner.set(fn.params[0], reqObj, true); 
+             const result = this._execBlock(fn.body, inner);
+             const out = (result instanceof ReturnSignal) ? result.value : result;
+             
+             const status = (out && out.status) || 200;
+             const body = (out && out.body) || "";
+             const headers = (out && out.headers) || {};
+             
+             res.writeHead(status, headers);
+             res.end(String(body));
+           } catch (e) {
+             console.error(e);
+             res.writeHead(500);
+             res.end("Internal Server Error");
+           }
+        });
+        srv.listen(Number(port));
+        console.log(`Server listening on port ${port}`);
+      },
+
+      argv: argvFn,
+      env: envFn,
+      cwd: cwdFn,
+    };
+
+    this.global.set("__builtins__", builtins, false);
+    // Also expose builtins as top-level identifiers (fast path)
+    for (const [k, v] of Object.entries(builtins)) this.global.set(k, v, false);
+  }
+
+  run(ast) {
+    try {
+      return this._execBlock(ast, this.global);
+    } catch (e) {
+      throw e;
     }
-    return null; // Étendre
   }
 
-  execute(stmt) {
-    if (stmt.type === 'assign') {
-      const value = this.evalExpr(stmt.value);
-      this.vars.set(stmt.name, { value, mut: stmt.mut, type: stmt.varType });
-      return value;
+  _execBlock(stmts, scope) {
+    let last = null;
+    for (const s of stmts) {
+      const v = this._execStmt(s, scope);
+      if (v instanceof ReturnSignal) return v;
+      last = v;
     }
+    return last;
+  }
 
-    if (stmt.type === 'case') {
-      const exprValue = this.evalExpr(stmt.expr);
-      for (const c of stmt.cases) {
-        if (c.pattern === 'else' || this.matchPattern(exprValue, c.pattern)) {
-          return this.executeBlock(c.body);
+  _execStmt(stmt, scope) {
+    switch (stmt.type) {
+      case "assign": {
+        const val = this._eval(stmt.value, scope);
+        if (scope.hasHere(stmt.name)) {
+          scope.assign(stmt.name, val);
+        } else {
+          scope.set(stmt.name, val, stmt.mut);
         }
+        return val;
+      }
+      case "exprstmt":
+        return this._eval(stmt.expr, scope);
+
+      case "fn": {
+        this.fns.set(stmt.name, { params: stmt.params, body: stmt.body, closure: scope });
+        scope.set(stmt.name, { __fnref__: stmt.name }, false);
+        return null;
       }
-      return null;
-    }
 
-    // Étendre pour fn def, etc.
+      case "return": {
+        const v = stmt.value ? this._eval(stmt.value, scope) : null;
+        return new ReturnSignal(v);
+      }
+
+      case "case": {
+        const val = this._eval(stmt.expr, scope);
+        for (const arm of stmt.arms) {
+          const { matched, bindings } = this._matchPattern(val, arm.pat, scope);
+          if (matched) {
+            const inner = new Scope(scope);
+            for (const [k, v] of Object.entries(bindings)) inner.set(k, v, true);
+            const out = this._execBlock(arm.body, inner);
+            if (out instanceof ReturnSignal) return out;
+            return out;
+          }
+        }
+        return null;
+      }
+
+      default:
+        throw new FazerError(`Unknown statement type: ${stmt.type}`);
+    }
   }
 
-  matchPattern(value, pattern) {
-    // Implémentation basique : pour conditions > < ==, ou patterns {key: val}
-    return value === pattern; // Étendre
+  _eval(expr, scope) {
+    if (!expr) return null;
+
+    switch (expr.type) {
+      case "num":
+      case "str":
+      case "bool":
+        return expr.value;
+
+      case "null":
+        return null;
+
+      case "list":
+        return expr.items.map((it) => this._eval(it, scope));
+
+      case "map": {
+        const o = {};
+        for (const ent of expr.entries) {
+          const k = this._eval(ent.key, scope);
+          o[String(k)] = this._eval(ent.value, scope);
+        }
+        return o;
+      }
+
+      case "ident": {
+        const cell = scope.get(expr.name);
+        if (!cell) throw new FazerError(`Undefined variable '${expr.name}'`);
+        const v = cell.value;
+        // fnref is stored as {__fnref__: name} to avoid collisions with user objects
+        if (v && typeof v === "object" && v.__fnref__) return v;
+        return v;
+      }
+
+      case "un": {
+        const v = this._eval(expr.expr, scope);
+        if (expr.op === "not") return !truthy(v);
+        if (expr.op === "-") return -Number(v);
+        throw new FazerError(`Unknown unary op ${expr.op}`);
+      }
+
+      case "bin": {
+        // short-circuit for and/or
+        if (expr.op === "and") {
+          const l = this._eval(expr.left, scope);
+          if (!truthy(l)) return l;
+          return this._eval(expr.right, scope);
+        }
+        if (expr.op === "or") {
+          const l = this._eval(expr.left, scope);
+          if (truthy(l)) return l;
+          return this._eval(expr.right, scope);
+        }
+
+        const l = this._eval(expr.left, scope);
+        const r = this._eval(expr.right, scope);
+
+        switch (expr.op) {
+          case "+": return (typeof l === "string" || typeof r === "string") ? String(l) + String(r) : Number(l) + Number(r);
+          case "-": return Number(l) - Number(r);
+          case "*": return Number(l) * Number(r);
+          case "/": return Number(l) / Number(r);
+          case "%": return Number(l) % Number(r);
+
+          case "==": return deepEqual(l, r);
+          case "!=": return !deepEqual(l, r);
+          case ">": return Number(l) > Number(r);
+          case "<": return Number(l) < Number(r);
+          case ">=": return Number(l) >= Number(r);
+          case "<=": return Number(l) <= Number(r);
+          default:
+            throw new FazerError(`Unknown binary op ${expr.op}`);
+        }
+      }
+
+      case "get": {
+        const obj = this._eval(expr.obj, scope);
+        const key = this._eval(expr.key, scope);
+        return (obj == null) ? null : obj[String(key)];
+      }
+
+      case "idx": {
+        const obj = this._eval(expr.obj, scope);
+        const idx = this._eval(expr.idx, scope);
+        if (obj == null) return null;
+        if (Array.isArray(obj)) return obj[Number(idx)];
+        return obj[String(idx)];
+      }
+
+      case "call": {
+        const callee = this._eval(expr.callee, scope);
+        const args = expr.args.map((a) => this._eval(a, scope));
+        return this._call(callee, args, scope);
+      }
+
+      case "pipe": {
+        // left →> right
+        // If right is a call: pass left as first arg
+        // If right is an identifier: treat as function name, call with left
+        // Otherwise: if right evaluates to function, call it with left
+        const leftVal = this._eval(expr.left, scope);
+        const rightNode = expr.right;
+
+        if (rightNode.type === "call") {
+          const callee = this._eval(rightNode.callee, scope);
+          const args = [leftVal, ...rightNode.args.map((a) => this._eval(a, scope))];
+          return this._call(callee, args, scope);
+        }
+
+        if (rightNode.type === "ident") {
+          const fn = this._eval(rightNode, scope);
+          return this._call(fn, [leftVal], scope);
+        }
+
+        const fn = this._eval(rightNode, scope);
+        return this._call(fn, [leftVal], scope);
+      }
+
+      default:
+        throw new FazerError(`Unknown expression type: ${expr.type}`);
+    }
   }
 
-  executeBlock(block) {
-    let last = null;
-    for (const stmt of block) {
-      last = this.execute(stmt);
+  _call(callee, args, scope) {
+    // builtin JS function
+    if (typeof callee === "function") return callee(...args);
+
+    // function reference stored as {__fnref__: "name"}
+    if (callee && typeof callee === "object" && callee.__fnref__) {
+      const name = callee.__fnref__;
+      const fn = this.fns.get(name);
+      if (!fn) throw new FazerError(`Unknown function '${name}'`);
+      if (args.length !== fn.params.length) {
+        throw new FazerError(`Arity mismatch: ${name} expects ${fn.params.length}, got ${args.length}`);
+      }
+      const inner = new Scope(fn.closure);
+      for (let i = 0; i < fn.params.length; i++) inner.set(fn.params[i], args[i], true);
+      const out = this._execBlock(fn.body, inner);
+      if (out instanceof ReturnSignal) return out.value;
+      return out;
     }
-    return last;
+
+    throw new FazerError(`Value is not callable`);
   }
 
-  run(code) {
-    const lexResult = lexer.tokenize(code);
-    if (lexResult.errors.length > 0) {
-      console.error('Lexer errors:', lexResult.errors);
-      return;
+  _matchPattern(value, pat, scope) {
+    // returns { matched, bindings }
+    if (!pat) return { matched: false, bindings: {} };
+
+    if (pat.type === "else") return { matched: true, bindings: {} };
+
+    if (pat.type === "identPat") {
+      // binding: case x  name → ...
+      return { matched: true, bindings: { [pat.name]: value } };
     }
 
-    const parser = new FazerParser();
-    parser.input = lexResult.tokens;
-    const cst = parser.program();
+    if (pat.type === "cmpPat") {
+      const rhs = this._eval(pat.rhs, scope);
+      const l = value;
+      const r = rhs;
+      switch (pat.op) {
+        case "==": return { matched: deepEqual(l, r), bindings: {} };
+        case "!=": return { matched: !deepEqual(l, r), bindings: {} };
+        case ">": return { matched: Number(l) > Number(r), bindings: {} };
+        case "<": return { matched: Number(l) < Number(r), bindings: {} };
+        case ">=": return { matched: Number(l) >= Number(r), bindings: {} };
+        case "<=": return { matched: Number(l) <= Number(r), bindings: {} };
+        default: return { matched: false, bindings: {} };
+      }
+    }
 
-    if (parser.errors.length > 0) {
-      console.error('Parse errors:', parser.errors);
-      return;
+    // literal patterns
+    if (pat.type === "num" || pat.type === "str" || pat.type === "bool" || pat.type === "null") {
+      const p = pat.type === "null" ? null : pat.value;
+      return { matched: deepEqual(value, p), bindings: {} };
     }
 
-    this.executeBlock(cst);
+    return { matched: false, bindings: {} };
+  }
+}
+
+/* ────────────────────────────────────────────────────────────────────────── */
+/* Utilities                                                                    */
+/* ────────────────────────────────────────────────────────────────────────── */
+
+function unescapeString(rawTokenImage) {
+  // rawTokenImage includes quotes
+  const s = rawTokenImage.slice(1, -1);
+  // minimal escapes
+  return s
+    .replace(/\\n/g, "\n")
+    .replace(/\\r/g, "\r")
+    .replace(/\\t/g, "\t")
+    .replace(/\\"/g, '"')
+    .replace(/\\\\/g, "\\");
+}
+
+function locOf(tok) {
+  return {
+    offset: tok.startOffset,
+    line: tok.startLine,
+    col: tok.startColumn,
+    endOffset: tok.endOffset,
+    endLine: tok.endLine,
+    endCol: tok.endColumn,
+  };
+}
+
+function truthy(v) {
+  return !!v;
+}
+
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (a == null || b == null) return a === b;
+  if (typeof a !== typeof b) return false;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) if (!deepEqual(a[i], b[i])) return false;
+    return true;
   }
+  if (typeof a === "object" && typeof b === "object") {
+    const ka = Object.keys(a);
+    const kb = Object.keys(b);
+    if (ka.length !== kb.length) return false;
+    for (const k of ka) if (!deepEqual(a[k], b[k])) return false;
+    return true;
+  }
+  return false;
+}
+
+function prettyError(err, filename, code) {
+  const lines = String(code).split(/\r?\n/);
+  const meta = err && err.meta ? err.meta : null;
+  if (!meta || !meta.line) return `${err.name}: ${err.message}`;
+
+  const lineNo = meta.line;
+  const col = meta.col || 1;
+  const line = lines[lineNo - 1] ?? "";
+  const caret = " ".repeat(Math.max(0, col - 1)) + "^";
+
+  return [
+    `${err.name}: ${err.message}`,
+    `at ${filename}:${lineNo}:${col}`,
+    line,
+    caret,
+  ].join("\n");
+}
+
+/* ────────────────────────────────────────────────────────────────────────── */
+/* CLI                                                                          */
+/* ────────────────────────────────────────────────────────────────────────── */
+
+function usage() {
+  console.log("Usage:");
+  console.log("  fazer run <file.fz> [-- args...]");
+  process.exit(1);
 }
 
-// ── CLI ──────────────────────────────────────────────────────────────────────
-const args = process.argv.slice(2);
+function main() {
+  const argv = process.argv.slice(2);
+  if (argv.length === 0) usage();
+
+  const cmd = argv[0];
+
+  if (cmd !== "run") usage();
+  const fileArg = argv[1];
+  if (!fileArg) usage();
 
-if (args[0] === 'run' && args[1]) {
-  const filePath = path.resolve(args[1]);
+  // forward args after "--" to the script
+  const sep = argv.indexOf("--");
+  const forwarded = sep >= 0 ? argv.slice(sep + 1) : [];
+
+  const filePath = path.resolve(fileArg);
   if (!fs.existsSync(filePath)) {
-    console.error(`Fichier non trouvé : ${filePath}`);
+    console.error(`File not found: ${filePath}`);
+    process.exit(1);
+  }
+
+  const code = fs.readFileSync(filePath, "utf8");
+  const lex = lexer.tokenize(code);
+  if (lex.errors.length) {
+    console.error("Lexer error:", lex.errors[0].message || String(lex.errors[0]));
+    process.exit(1);
+  }
+
+  const parser = new FazerParser();
+  parser.input = lex.tokens;
+  const ast = parser.program();
+
+  if (parser.errors.length) {
+    const e = parser.errors[0];
+    const tok = e.token || (lex.tokens.length ? lex.tokens[0] : null);
+    const meta = tok ? locOf(tok) : null;
+    const ferr = new FazerError(e.message, meta || {});
+    console.error(prettyError(ferr, filePath, code));
     process.exit(1);
   }
-  const code = fs.readFileSync(filePath, 'utf8');
-  new FazerRuntime().run(code);
-} else {
-  console.log('Usage: fazer run fichier.fz');
-}
+
+  const rt = new FazerRuntime({ argv: forwarded, filename: filePath, code });
+  try {
+    rt.run(ast);
+  } catch (err) {
+    if (err instanceof FazerError) {
+      console.error(prettyError(err, filePath, code));
+    } else {
+      console.error(err && err.stack ? err.stack : String(err));
+    }
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  Lexer,
+  createToken,
+  FazerParser,
+  FazerRuntime,
+  FazerError,
+  lexer,
+  prettyError,
+  locOf
+};
+
+if (require.main === module) main();