fazer-lang 2.3.0 → 2.4.0

package/README.md

@@ -24,6 +24,19 @@ Exécuter un script :
 fazer mon_script.fz
 ```
 
+## Création d'Exécutable (.exe)
+
+Transformez vos scripts Fazer en applications Windows portables et natives :
+
+1.  (Optionnel) Placez une icône `app.ico` dans le dossier.
+2.  Lancez la commande de build :
+    ```bash
+    fazer build mon_script.fz
+    ```
+3.  Récupérez votre application dans `dist/mon_script/mon_script.exe`.
+
+Le dossier généré est **portable** : zippez-le et envoyez-le à n'importe qui, aucune installation n'est requise !
+
 ## Documentation
 
 La documentation complète est disponible dans le dossier [`docs/`](./docs/README.md).
@@ -35,12 +48,13 @@ La documentation complète est disponible dans le dossier [`docs/`](./docs/READM
 
 ## Fonctionnalités Clés
 
+*   **GUI Native** : Créez de vraies applications Windows (WinForms) avec widgets natifs (`window`, `button`, `entry`, etc.).
 *   **Pipe Operator (`->>`)** : Enchaînez les opérations proprement.
 *   **Pattern Matching (`case`)** : Contrôle de flux expressif.
 *   **Sécurité Intégrée** : Chiffrement AES-256-GCM et SHA256 natifs.
 *   **Réseau & Web** : Client HTTP `fetch`, serveur web `server`, et module `discord`.
 *   **Système de Fichiers** : Manipulation simple et puissante.
-*   **Automation** : Gestion du presse-papier (`clipboard`), menus interactifs, et persistance (`db`).
+*   **Automation** : Gestion du presse-papier (`clipboard`), notifications (`notify`), et persistance (`db`).
 *   **Extensible** : Système de modules `import`.
 
 ## Copyright

package/docs/getting-started.md

@@ -1,46 +1,153 @@
-# Guide de Démarrage
+# Guide de Démarrage Fazer
+
+Bienvenue dans Fazer, le langage de script puissant et moderne pour Windows.
 
 ## Installation
 
-La façon la plus simple d'installer Fazer est via NPM (Node Package Manager).
+1. Téléchargez la dernière version.
+2. Lancez `install_system.ps1` pour configurer le PATH et les associations de fichiers.
+3. Ouvrez un terminal et tapez `fazer` pour lancer le REPL.
 
-```bash
-npm install -g fazer-lang
+## Votre premier script
+
+Créez un fichier `hello.fz` :
+
+```fazer
+"Bonjour Fazer !" ->> println
 ```
 
-Vérifiez l'installation :
+Exécutez-le :
+```bash
+fazer run hello.fz
+```
 
+Ou simplement (si installé) :
 ```bash
-fazer --version
+fazer hello.fz
 ```
 
-## Votre Premier Script
+## Concepts de Base
 
-Créez un fichier nommé `hello.fz` avec le contenu suivant :
+### Variables et Fonctions
 
 ```fazer
-"Hello World!" ->> println
+# Variable
+nom := "Monde"
+
+# Fonction
+fn saluer(n) ->
+  "Bonjour " + n
+end
+
+saluer(nom) ->> println
 ```
 
-Exécutez-le via la ligne de commande :
+### Pipe (`->>`)
 
-```bash
-fazer hello.fz
+L'opérateur pipe passe le résultat de gauche comme premier argument à la fonction de droite.
+
+```fazer
+"  texte sale  " ->> str_trim ->> str_upper ->> println
+# Affiche : "TEXTE SALE"
 ```
 
-Vous devriez voir `Hello World!` s'afficher.
+## Bibliothèque Standard (Nouveau !)
+
+Fazer dispose maintenant d'une bibliothèque standard riche pour les tâches réelles.
 
-## Le Mode Interactif (REPL)
+### 1. Système de Fichiers
+```fazer
+# Lire
+contenu := fs_read("config.txt")
 
-Si vous lancez `fazer` sans arguments, vous entrez dans le mode interactif. C'est idéal pour tester des petites lignes de code.
+# Écrire
+fs_write("log.txt", "Succès")
+```
 
-```bash
-$ fazer
-Welcome to Fazer v2.2.1
-> 10 ->> println
-10
-> "test" ->> sha256 ->> println
-9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08
+### 2. Modules (`import`)
+Organisez votre code en plusieurs fichiers.
+
+**math.fz** :
+```fazer
+add := (a, b) => a + b
+PI := 3.14159
+```
+
+**main.fz** :
+```fazer
+m := import("math.fz")
+m.add(10, 5) ->> println
+m.PI ->> println
 ```
 
-Tapez `exit` ou faites `Ctrl+C` pour quitter.
+### 3. Base de Données Native (`db`)
+Persistance des données JSON simple et efficace.
+
+```fazer
+# Initialiser (charge ou crée le fichier)
+store := db("data.json")
+
+# Sauvegarder une valeur
+store.set("score", 100)
+store.set("user", "viced")
+
+# Lire une valeur
+store.get("score") ->> println
+
+# Récupérer tout
+all := store.all()
+```
+
+### 4. Automation Système
+Interagissez avec Windows.
+
+```fazer
+# Presse-papier (Copier)
+clipboard_set("Copié depuis Fazer !")
+
+# Notifications
+notify("Titre", "Ceci est une notification Windows native")
+
+# Exécution de commandes
+ip := exec("ipconfig")
+```
+
+### 5. GUI Native (Vrai Native)
+Créez des applications Windows natives (WinForms) directement en Fazer.
+
+```fazer
+# 1. Définir l'interface
+window("Mon Application", 400, 300)
+label("lbl_msg", "Bienvenue !", 20, 20, 360, 30)
+button("btn_ok", "Cliquez-moi", 20, 60, 150, 40)
+entry("txt_nom", "Votre nom", 20, 120, 360, 30)
+
+# 2. Gestionnaire d'événements
+fn handler(ev) ->
+  id = ev["id"]
+  
+  if id == "btn_ok"
+    msgbox("Bouton cliqué !")
+    set_text("lbl_msg", "Merci !")
+  end
+  
+  if id == "txt_nom"
+    # ev["value"] contient le texte tapé
+    print("Nom changé: " + ev["value"])
+  end
+end
+
+# 3. Lancer l'interface
+gui(handler)
+```
+
+### 6. Serveur Web
+Créez des API ou des sites web.
+
+```fazer
+fn handler(req) ->
+  "Vous avez demandé : " + req.url
+end
+
+server(8080, handler)
+```

package/docs/stdlib.md

@@ -1,139 +1,111 @@
 # Bibliothèque Standard (Stdlib)
 
-Fazer inclut une bibliothèque standard riche pour interagir avec le système, les fichiers, le réseau et plus encore.
+Fazer inclut une bibliothèque standard "batteries included" pour le développement d'applications robustes.
 
-## Entrées / Sorties
+## Système de Fichiers (fs)
 
-### `print(valeur)` / `println(valeur)`
-Affiche une valeur sur la sortie standard (console).
+Manipulation de fichiers synchrones et performante.
 
-### `input(message)`
-Affiche un message et attend une entrée utilisateur (retourne une chaîne).
+### `fs_read(path)`
+Lit le contenu d'un fichier en texte (UTF-8). Retourne `null` en cas d'erreur.
+```fazer
+content := fs_read("config.json")
+```
 
-### `box(titre, contenu)`
-Affiche une boîte stylisée avec un titre et du contenu (texte ou liste).
+### `fs_write(path, content)`
+Écrit (écrase) du contenu dans un fichier. Retourne `true` si succès.
+```fazer
+fs_write("log.txt", "Initialisation...")
+```
 
-### `menu(options)`
-Affiche un menu interactif dans la console et retourne l'option choisie.
+### `fs_append(path, content)`
+Ajoute du contenu à la fin d'un fichier.
 ```fazer
-choix := menu(["Option A", "Option B"])
+fs_append("log.txt", "\nNouvelle entrée")
 ```
 
-### `style(texte, couleur)`
-Applique une couleur ANSI au texte pour l'affichage console.
-Couleurs : "red", "green", "blue", "yellow", "cyan", "magenta", "white", "bold", "dim".
+### `fs_exists(path)`
+Vérifie si un fichier ou dossier existe.
 ```fazer
-println(style("Succès !", "green"))
+if fs_exists("data") -> ... end
 ```
 
-## Fichiers (File System)
+## Manipulation de Données
 
-### `read(path)`
-Lit un fichier texte entier.
+### JSON
+*   `json_parse(str)` : Convertit une chaîne JSON en objet/liste.
+*   `json_stringify(obj)` : Convertit un objet en chaîne JSON formatée.
+    *   Alias : `json(obj)`
 
-### `write(path, content)`
-Écrit du contenu dans un fichier (écrase le fichier).
+### Chaînes de Caractères (String)
+*   `str_split(str, delimiter)` : Découpe une chaîne en liste.
+*   `str_replace(str, old, new)` : Remplace toutes les occurrences.
+*   `str_trim(str)` : Retire les espaces au début et à la fin.
+*   `str_upper(str)` : Convertit en majuscules.
+*   `str_lower(str)` : Convertit en minuscules.
 
-### `exists(path)`
-Retourne `true` si le fichier ou dossier existe.
+### Mathématiques
+*   `random()` : Retourne un nombre aléatoire entre 0.0 et 1.0.
+*   `round(n)` : Arrondi à l'entier le plus proche.
+*   `floor(n)` : Arrondi à l'entier inférieur.
+*   `ceil(n)` : Arrondi à l'entier supérieur.
+*   `int(n)` : Conversion en entier.
+*   `float(n)` : Conversion en flottant.
 
-### `readBytes(path)` / `writeBytes(path, b64)`
-Lecture/Écriture binaire (encodé en Base64).
+## Base de Données (db)
 
-### `import(chemin)`
-Charge et exécute un autre script Fazer.
+### `db(path)`
+Crée ou charge une base de données JSON persistante.
 ```fazer
-import("utils.fz")
+store := db("data.json")
+store.set("key", "value")
+val := store.get("key")
+data := store.all()
 ```
 
-## Système & Exécution
+## Automation & Système
 
-### `exec(cmd)`
-Exécute une commande shell et retourne la sortie (stdout) sous forme de chaîne.
-```fazer
-files := exec("ls -la")
-```
+### Presse-papier
+*   `clipboard_set(text)` : Copie du texte dans le presse-papier.
+*   `clipboard_get()` : Récupère le texte du presse-papier.
 
-### `notify(titre, message)`
-Affiche une notification système (Windows Toast).
-```fazer
-notify("Fazer", "Tâche terminée avec succès !")
-```
+### Notifications
+*   `notify(title, msg)` : Affiche une notification système native.
 
-### `clipboard`
-Objet global pour interagir avec le presse-papier système.
-*   `clipboard.read()` : Retourne le contenu texte du presse-papier.
-*   `clipboard.write(texte)` : Écrit du texte dans le presse-papier.
+### Exécution
+*   `exec(cmd)` : Exécute une commande système et capture la sortie.
+*   `sleep(ms)` : Pause l'exécution.
+*   `import(path)` : Charge un module Fazer externe.
 
-### `sleep(ms)`
-Met le script en pause pour `ms` millisecondes.
+## Interface Graphique (GUI Native)
 
-### `env(nom_var)`
-Lit une variable d'environnement.
+Créez des applications Windows Forms natives.
 
-### `cwd()`
-Retourne le dossier de travail actuel.
+### Widgets
+*   `window(title, width, height, icon_path)` : Définit la fenêtre principale. `icon_path` est optionnel (ex: `"app.ico"`).
+*   `button(id, text, x, y, w, h)` : Ajoute un bouton.
+*   `label(id, text, x, y, w, h)` : Ajoute une étiquette de texte.
+*   `entry(id, text, x, y, w, h)` : Ajoute un champ de saisie texte.
 
-### `argv()`
-Retourne les arguments de la ligne de commande.
+### Interaction
+*   `gui(handler)` : Lance la boucle d'événements. `handler` reçoit des événements `{id, type, value}`.
+*   `set_text(id, text)` : Change le texte d'un widget (à utiliser dans le handler).
+*   `msgbox(text)` : Affiche une boîte de dialogue modale.
 
 ## Réseau & Web
 
-### `fetch(url, options)`
-Effectue une requête HTTP. `options` est un objet (method, headers, body).
-Retourne `{ status, body, headers }`.
-
 ### `server(port, handler)`
-Démarre un serveur HTTP simple.
-`handler` peut être une fonction qui prend `req` et retourne `res`, ou un objet de routage simple.
+Démarre un serveur HTTP.
 ```fazer
 fn handler(req) ->
-  "Hello from Fazer!"
+  return({ "body": "Hello World" })
 end
 server(8080, handler)
 ```
 
-### `discord(token)`
-Crée un client Discord (Bot).
-*   `.on("message", fn)`
-*   `.send(channelId, content)`
-
-## Cryptographie
-
-### `sha256(texte)`
-Retourne le hash SHA-256 (hex).
-
-### `encrypt(texte, mot_de_passe)`
-Chiffre le texte avec AES-256-GCM (retourne Base64).
-
-### `decrypt(b64, mot_de_passe)`
-Déchiffre le texte.
-
-## JSON & Données
-
-### `json(obj)`
-Convertit un objet en chaîne JSON.
-
-### `parseJson(str)`
-Parse une chaîne JSON en objet.
-
-### `int(valeur)`
-Convertit une valeur en entier.
-
-### `float(valeur)`
-Convertit une valeur en nombre flottant.
-
-### `db(chemin_json)`
-Crée ou charge une base de données JSON persistante.
-Retourne un objet avec `.get(k)`, `.set(k, v)`, `.save()` et `.data()`.
+### `fetch(url, options)`
+Effectue une requête HTTP asynchrone.
 ```fazer
-mydb := db("data.json")
-mydb.set("score", 100)
-mydb.save()
+res := fetch("https://api.example.com/data")
+print(res.body)
 ```
-
-### `keys(obj)`
-Retourne les clés d'un objet JSON.
-
-### `get(obj, clé)`
-Récupère une valeur dans un objet/map.

package/fazer.js

@@ -23,7 +23,7 @@ const Comment = createToken({ name: "Comment", pattern: /(#|\/\/)[^\n]*/, group:
 const Assign = createToken({ name: "Assign", pattern: /:=/ });
 
 const Arrow = createToken({ name: "Arrow", pattern: /->|→/ });
-const DoublePipe = createToken({ name: "DoublePipe", pattern: /\|>|→>/ });
+const DoublePipe = createToken({ name: "DoublePipe", pattern: /->>|\|>|→>/ });
 
 const Case = createToken({ name: "Case", pattern: /case\b/ });
 const Else = createToken({ name: "Else", pattern: /else\b/ });
@@ -158,7 +158,15 @@ class FazerParser extends EmbeddedActionsParser {
       $.OR([
         { ALT: () => $.SUBRULE($.fnDef) },
         { ALT: () => $.SUBRULE($.returnStmt) },
-        { ALT: () => $.SUBRULE($.assignStmt) },
+        {
+          GATE: () => {
+            const t1 = $.LA(1).tokenType;
+            if (t1 === Mut) return true;
+            const t2 = $.LA(2).tokenType;
+            return t1 === Identifier && t2 === Assign;
+          },
+          ALT: () => $.SUBRULE($.assignStmt)
+        },
         { ALT: () => $.SUBRULE($.caseBlock) },
         { ALT: () => $.SUBRULE($.exprStmt) },
       ])
@@ -203,7 +211,8 @@ class FazerParser extends EmbeddedActionsParser {
 
     $.RULE("caseBlock", () => {
       const caseTok = $.CONSUME(Case);
-      const expr = $.SUBRULE($.expression);
+      // Use addExpr to avoid consuming comparison operators (==, >, etc.) which start patterns
+      const expr = $.SUBRULE($.addExpr);
       const arms = [];
       $.AT_LEAST_ONE(() => {
         const pat = $.OR([
@@ -588,6 +597,7 @@ class FazerRuntime {
     this.code = code;
     this.global = new Scope(null);
     this.fns = new Map(); // name -> {params, body, closure}
+    this.native_ui_state = { widgets: [], updates: {} };
     this._installStdlib(argv);
   }
 
@@ -748,6 +758,111 @@ class FazerRuntime {
       writeText,
       saveText: (s, p) => { fs.writeFileSync(path.resolve(String(p)), String(s), "utf8"); return null; },
       exists: (p) => fs.existsSync(path.resolve(String(p))),
+      
+      // Core Utils (Standard Library)
+      fs_read: (p) => { try { return fs.readFileSync(path.resolve(String(p)), "utf8"); } catch(e) { return null; } },
+      fs_write: (p, c) => { try { fs.writeFileSync(path.resolve(String(p)), String(c)); return true; } catch(e) { return false; } },
+      fs_exists: (p) => fs.existsSync(path.resolve(String(p))),
+      
+          // Module System
+      import: async (p) => {
+          const pAbs = path.resolve(String(p));
+          if (!fs.existsSync(pAbs)) return null;
+          const code = fs.readFileSync(pAbs, "utf8");
+          const lex = lexer.tokenize(code);
+          if (lex.errors.length) throw new FazerError("Import Lexer Error: " + lex.errors[0].message);
+          const parser = new FazerParser();
+          parser.input = lex.tokens;
+          const ast = parser.program();
+          if (parser.errors.length) throw new FazerError("Import Parser Error: " + parser.errors[0].message);
+          
+          const rt = new FazerRuntime({ filename: pAbs, code });
+          await rt.run(ast);
+          
+          const exports = {};
+          console.log("Exporting vars from module...");
+          for (const [k, v] of rt.global.vars) {
+              console.log("Exporting:", k, v);
+              if (k === "__builtins__" || builtins[k]) continue; 
+              
+              let value = v.value;
+              // Handle functions: migrate definition to current runtime
+              if (value && typeof value === "object" && value.__fnref__) {
+                  const fnName = value.__fnref__;
+                  const fnDef = rt.fns.get(fnName);
+                  if (fnDef) {
+                      const uniqueName = `__import_${Math.floor(Math.random()*1000000)}_${fnName}`;
+                      // console.log("Importing function:", fnName, "->", uniqueName);
+                      this.fns.set(uniqueName, fnDef);
+                      value = { __fnref__: uniqueName };
+                  } else {
+                      // Debug log
+                      console.log("Warning: Function definition not found for", fnName);
+                  }
+              }
+              
+              exports[k] = value;
+          }
+          return exports;
+      },
+      
+      // Persistence (Simple JSON DB)
+      db_load: (p) => { try { return JSON.parse(fs.readFileSync(path.resolve(String(p)), "utf8")); } catch(e) { return {}; } },
+      db_save: (p, data) => { try { fs.writeFileSync(path.resolve(String(p)), JSON.stringify(data, null, 2)); return true; } catch(e) { return false; } },
+      
+      // System Automation
+      clipboard_set: (text) => {
+          if (process.platform === "win32") {
+              try {
+                  const script = `Set-Clipboard -Value '${String(text).replace(/'/g, "''")}'`;
+                  const b64 = Buffer.from(script, 'utf16le').toString('base64');
+                  child_process.execSync(`powershell -EncodedCommand ${b64}`);
+                  return true;
+              } catch(e) { return false; }
+          }
+          return false;
+      },
+      clipboard_get: () => {
+          if (process.platform === "win32") {
+              try { return child_process.execSync(`powershell -command "Get-Clipboard"`).toString().trim(); } catch(e) { return ""; }
+          }
+          return "";
+      },
+      notify: (title, msg) => {
+          if (process.platform === "win32") {
+              const cmd = `
+              [reflection.assembly]::loadwithpartialname("System.Windows.Forms");
+              [reflection.assembly]::loadwithpartialname("System.Drawing");
+              $n = new-object system.windows.forms.notifyicon;
+              $n.icon = [system.drawing.systemicons]::information;
+              $n.visible = $true;
+              $n.showballoontip(10, "${String(title).replace(/"/g, '`"')}", "${String(msg).replace(/"/g, '`"')}", [system.windows.forms.tooltipicon]::none);
+              Start-Sleep -s 3;
+              $n.Visible = $false;
+              `;
+              try {
+                  const b64 = Buffer.from(cmd, 'utf16le').toString('base64');
+                  child_process.execSync(`powershell -EncodedCommand ${b64}`);
+                  return true;
+              } catch(e) { return false; }
+          }
+          return false;
+      },
+      
+      json_parse: (s) => { try { return JSON.parse(String(s)); } catch(e) { return null; } },
+      json_stringify: (x) => JSON.stringify(x, null, 2),
+      
+      str_split: (s, d) => String(s).split(String(d)),
+      str_replace: (s, a, b) => String(s).split(String(a)).join(String(b)), // simple replace all
+      str_trim: (s) => String(s).trim(),
+      str_upper: (s) => String(s).toUpperCase(),
+      str_lower: (s) => String(s).toLowerCase(),
+      
+      random: () => Math.random(),
+      round: (x) => Math.round(Number(x)),
+      floor: (x) => Math.floor(Number(x)),
+      ceil: (x) => Math.ceil(Number(x)),
+      
       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; } },
@@ -902,52 +1017,7 @@ class FazerRuntime {
         };
       },
 
-      import: async (p) => {
-        const pAbs = path.resolve(String(p));
-        if (!fs.existsSync(pAbs)) throw new FazerError("Module not found: " + p);
-        const code = fs.readFileSync(pAbs, "utf8");
-        const lex = lexer.tokenize(code);
-        if (lex.errors.length) throw new FazerError("Lexer error in module: " + lex.errors[0].message);
-        const parser = new FazerParser();
-        parser.input = lex.tokens;
-        const ast = parser.program();
-        if (parser.errors.length) throw new FazerError("Parser error in module: " + parser.errors[0].message);
-        return await this._execBlock(ast, this.global);
-      },
-
-      db: (dbPath) => {
-        const absPath = path.resolve(String(dbPath));
-        let data = {};
-        if (fs.existsSync(absPath)) {
-            try { data = JSON.parse(fs.readFileSync(absPath, "utf8")); } catch(e) {}
-        }
-        return {
-            get: (k) => data[String(k)],
-            set: (k, v) => { data[String(k)] = v; return null; },
-            save: () => { fs.writeFileSync(absPath, JSON.stringify(data, null, 2), "utf8"); return null; },
-            data: () => data
-        };
-      },
 
-      clipboard: {
-         read: () => {
-             try {
-                 if (process.platform === "win32") {
-                     return require("child_process").execSync("powershell -command \"Get-Clipboard\"", {encoding: "utf8"}).trim();
-                 }
-                 return "";
-             } catch (e) { return ""; }
-         },
-         write: (s) => {
-             try {
-                 const str = String(s);
-                 if (process.platform === "win32") {
-                     require("child_process").execSync("powershell -command \"Set-Clipboard -Value '" + str.replace(/'/g, "''") + "'\"");
-                 }
-             } catch (e) {}
-             return null;
-         }
-      },
       
       menu: async (options) => {
          if (!Array.isArray(options)) throw new FazerError("menu expects a list of options");
@@ -964,23 +1034,7 @@ class FazerRuntime {
          });
       },
 
-      notify: (title, message) => {
-         try {
-             if (process.platform === "win32") {
-                 const psScript = `
-                 [void] [System.Reflection.Assembly]::LoadWithPartialName("System.Windows.Forms")
-                 $obj = New-Object System.Windows.Forms.NotifyIcon
-                 $obj.Icon = [System.Drawing.SystemIcons]::Information
-                 $obj.Visible = $true
-                 $obj.ShowBalloonTip(3000, "${String(title).replace(/"/g, '`"')}", "${String(message).replace(/"/g, '`"')}", [System.Windows.Forms.ToolTipIcon]::Info)
-                 Start-Sleep -s 3
-                 $obj.Visible = $false
-                 `;
-                 require("child_process").execSync("powershell -command \"" + psScript.replace(/\n/g, ";") + "\"");
-             }
-         } catch(e) {}
-         return null;
-      },
+
 
       exec: (cmd) => {
           try {
@@ -1059,12 +1113,299 @@ class FazerRuntime {
                      close: () => { srv.close(); return null; }
                  });
              });
+             srv.on('error', (e) => {
+                 if (e.code === 'EADDRINUSE') {
+                     console.error(`Error: Port ${port} is already in use.`);
+                 } else {
+                     console.error(`Server error: ${e.message}`);
+                 }
+                 resolve(null); // Resolve with null to avoid crashing
+             });
          });
       },
 
+      // --- NATIVE UI (WinForms) ---
+      
+      window: (title, w, h, icon) => {
+          this.native_ui_state.widgets = [{ type: 'window', title, w, h, icon }];
+          return "window";
+      },
+      
+      button: (id, text, x, y, w, h) => {
+          this.native_ui_state.widgets.push({ type: 'widget', cls: 'Button', id, text, x, y, w, h });
+          return id;
+      },
+      
+      label: (id, text, x, y, w, h) => {
+          this.native_ui_state.widgets.push({ type: 'widget', cls: 'Label', id, text, x, y, w, h });
+          return id;
+      },
+      
+      entry: (id, text, x, y, w, h) => {
+          this.native_ui_state.widgets.push({ type: 'widget', cls: 'TextBox', id, text, x, y, w, h });
+          return id;
+      },
+      
+      set_text: (id, val) => {
+          if (!this.native_ui_state.updates.set_text) this.native_ui_state.updates.set_text = {};
+          this.native_ui_state.updates.set_text[id] = val;
+          return val;
+      },
+      
+      msgbox: (msg) => {
+           this.native_ui_state.updates.msgbox = String(msg);
+           return true;
+      },
+
+      gui: async (handler) => {
+         if (process.platform !== 'win32') throw new FazerError("Native GUI is Windows only.");
+         
+         const http = require("http");
+         const port = await new Promise(r => {
+             const s = http.createServer();
+             s.listen(0, () => {
+                 const p = s.address().port;
+                 s.close(() => r(p));
+             });
+         });
+     
+         const srv = http.createServer(async (req, res) => {
+              if (req.method === "POST" && req.url === "/event") {
+                  let body = "";
+                  for await (const chunk of req) body += chunk;
+                  try {
+                      const event = JSON.parse(body);
+                      this.native_ui_state.updates = {}; // Reset
+                      
+                      if (handler) {
+                          await this._call(handler, [event], this.global);
+                      }
+                      
+                      res.writeHead(200, { "Content-Type": "application/json" });
+                      res.end(JSON.stringify(this.native_ui_state.updates));
+                  } catch(e) {
+                      console.error(e);
+                      res.writeHead(500); res.end("{}");
+                  }
+              }
+         });
+         
+         srv.listen(port);
+     
+         // Generate PowerShell Script
+         let ps = `
+         Add-Type -AssemblyName System.Windows.Forms
+         Add-Type -AssemblyName System.Drawing
+         $url = "http://localhost:${port}/event"
+         
+         function Send-Event($id, $type, $val) {
+             $body = @{id=$id; type=$type; value=$val} | ConvertTo-Json -Compress
+             try {
+                 $res = Invoke-RestMethod -Uri $url -Method POST -Body $body -ContentType "application/json"
+                 if ($res.set_text) {
+                     foreach($k in $res.set_text.PSObject.Properties) {
+                         $c = $form.Controls.Find($k.Name, $true)
+                         if ($c) { $c[0].Text = $k.Value }
+                     }
+                 }
+                 if ($res.msgbox) { [System.Windows.Forms.MessageBox]::Show($res.msgbox) }
+             } catch {}
+         }
+         `;
+     
+         const widgets = this.native_ui_state.widgets;
+         const win = widgets.find(w => w.type === 'window');
+         if (!win) throw new FazerError("No window defined. Use window().");
+         
+         let iconCmd = "";
+         if (win.icon) {
+             const iconAbs = require('path').resolve(String(win.icon));
+             const iconPath = iconAbs.replace(/\\/g, '\\\\'); 
+             if (require('fs').existsSync(iconAbs)) {
+                 if (String(win.icon).endsWith(".ico")) {
+                    iconCmd = `$form.Icon = New-Object System.Drawing.Icon("${iconPath}")`;
+                 } else {
+                    iconCmd = `$form.Icon = [System.Drawing.Icon]::ExtractAssociatedIcon("${iconPath}")`;
+                 }
+             }
+         }
+     
+         ps += `
+         $form = New-Object System.Windows.Forms.Form
+         $form.Text = "${win.title}"
+         ${iconCmd}
+         $form.Width = ${win.w}
+         $form.Height = ${win.h}
+         $form.StartPosition = "CenterScreen"
+         $form.BackColor = [System.Drawing.Color]::FromArgb(30, 30, 30)
+         $form.ForeColor = [System.Drawing.Color]::White
+         `;
+     
+         for (const w of widgets) {
+             if (w.type === 'window') continue;
+             ps += `
+             $${w.id} = New-Object System.Windows.Forms.${w.cls}
+             $${w.id}.Name = "${w.id}"
+             $${w.id}.Text = "${w.text}"
+             $${w.id}.Left = ${w.x}
+             $${w.id}.Top = ${w.y}
+             $${w.id}.Width = ${w.w}
+             $${w.id}.Height = ${w.h}
+             $${w.id}.Font = New-Object System.Drawing.Font("Segoe UI", 10)
+             `;
+             
+             if (w.cls === 'Button') {
+                ps += `
+                $${w.id}.FlatStyle = "Flat"
+                $${w.id}.BackColor = [System.Drawing.Color]::FromArgb(60, 60, 60)
+                $${w.id}.FlatAppearance.BorderSize = 0
+                $${w.id}.Add_Click({ Send-Event "${w.id}" "click" "" })
+                `;
+            } else if (w.cls === 'TextBox') {
+                 ps += `
+                 $${w.id}.BorderStyle = "FixedSingle"
+                 $${w.id}.BackColor = [System.Drawing.Color]::FromArgb(50, 50, 50)
+                 $${w.id}.ForeColor = [System.Drawing.Color]::White
+                 $${w.id}.Add_TextChanged({ Send-Event "${w.id}" "change" $this.Text })
+                 `;
+            }
+             
+             ps += `$form.Controls.Add($${w.id})\n`;
+         }
+     
+         ps += `
+         [void]$form.ShowDialog()
+         `;
+     
+         // Run PS
+         const b64 = Buffer.from(ps, 'utf16le').toString('base64');
+         require('child_process').spawn('powershell', ['-EncodedCommand', b64], { stdio: 'inherit' });
+         
+         return new Promise(r => {}); 
+      },
+
       argv: argvFn,
       env: envFn,
       cwd: cwdFn,
+      input: (p) => builtins.ask(p),
+      nowMs: () => Date.now(),
+      
+      // --- EXTENDED FEATURES (Automation, State, DB) ---
+      
+      set: (obj, key, val) => {
+          if (obj && typeof obj === 'object') {
+              obj[key] = val;
+              return val;
+          }
+          return null;
+      },
+
+      clipboard_set: (text) => {
+          try {
+              if (process.platform === 'win32') {
+                  require('child_process').execSync(`echo ${String(text).replace(/[&|<>^]/g, '^$&')} | clip`);
+              } else {
+                  // TODO: Linux/Mac support
+              }
+              return true;
+          } catch(e) { return false; }
+      },
+
+      notify: (title, msg) => {
+          try {
+              if (process.platform === 'win32') {
+                  const script = `
+                  [void] [System.Reflection.Assembly]::LoadWithPartialName("System.Windows.Forms");
+                  $objNotifyIcon = New-Object System.Windows.Forms.NotifyIcon;
+                  $objNotifyIcon.Icon = [System.Drawing.SystemIcons]::Information;
+                  $objNotifyIcon.Visible = $True;
+                  $objNotifyIcon.BalloonTipTitle = "${String(title).replace(/"/g, '`"')}";
+                  $objNotifyIcon.BalloonTipText = "${String(msg).replace(/"/g, '`"')}";
+                  $objNotifyIcon.ShowBalloonTip(5000);
+                  Start-Sleep -s 5;
+                  $objNotifyIcon.Dispose();
+                  `;
+                  require('child_process').exec(`powershell -Command "${script.replace(/\n/g, ' ')}"`);
+              }
+              return true;
+          } catch(e) { return false; }
+      },
+
+      db: (p) => {
+          const dbPath = path.resolve(String(p));
+          let data = {};
+          if (fs.existsSync(dbPath)) {
+              try { data = JSON.parse(fs.readFileSync(dbPath, "utf8")); } catch(e){}
+          }
+          
+          return {
+              get: (k) => data[k],
+              set: (k, v) => { 
+                  data[k] = v; 
+                  fs.writeFileSync(dbPath, JSON.stringify(data, null, 2)); 
+                  return v; 
+              },
+              all: () => data
+          };
+       },
+
+      import: async (p) => {
+         const fullPath = path.resolve(String(p));
+         if (!fs.existsSync(fullPath)) throw new FazerError(`Module not found: ${p}`);
+         const code = fs.readFileSync(fullPath, "utf8");
+         
+         const lexResult = lexer.tokenize(code);
+         if (lexResult.errors.length > 0) throw new FazerError(`Lexer error in ${p}: ${lexResult.errors[0].message}`);
+         
+         const parser = new FazerParser();
+         parser.input = lexResult.tokens;
+         const ast = parser.program();
+         if (parser.errors.length > 0) throw new FazerError(`Parser error in ${p}: ${parser.errors[0].message}`);
+         
+         const moduleScope = new Scope(this.global);
+         await this._execBlock(ast, moduleScope);
+         
+         const exports = {};
+         for(const [k, v] of moduleScope.vars) {
+             exports[k] = v.value;
+         }
+         return exports;
+      },
+
+      // File System
+      fs_read: (p) => {
+          try { return require("fs").readFileSync(String(p), "utf8"); } catch(e) { return null; }
+      },
+      fs_write: (p, c) => {
+          try { require("fs").writeFileSync(String(p), String(c)); return true; } catch(e) { return false; }
+      },
+      fs_append: (p, c) => {
+          try { require("fs").appendFileSync(String(p), String(c)); return true; } catch(e) { return false; }
+      },
+      fs_exists: (p) => {
+          try { return require("fs").existsSync(String(p)); } catch(e) { return false; }
+      },
+      
+      // JSON
+      json_parse: (s) => {
+          try { return JSON.parse(String(s)); } catch(e) { return null; }
+      },
+      json_stringify: (o) => {
+          try { return JSON.stringify(o, null, 2); } catch(e) { return null; }
+      },
+      
+      // String Utils
+      str_split: (s, d) => String(s).split(String(d)),
+      str_replace: (s, old, n) => String(s).split(String(old)).join(String(n)),
+      str_trim: (s) => String(s).trim(),
+      str_upper: (s) => String(s).toUpperCase(),
+      str_lower: (s) => String(s).toLowerCase(),
+      
+      // Math
+      random: () => Math.random(),
+      round: (n) => Math.round(Number(n)),
+      floor: (n) => Math.floor(Number(n)),
+      ceil: (n) => Math.ceil(Number(n)),
     };
 
     this.global.set("__builtins__", builtins, false);
@@ -1213,15 +1554,16 @@ class FazerRuntime {
       case "get": {
         const obj = await this._eval(expr.obj, scope);
         const key = await this._eval(expr.key, scope);
-        return (obj == null) ? null : obj[String(key)];
+        const v = (obj == null) ? null : obj[String(key)];
+        return v === undefined ? null : v;
       }
 
       case "idx": {
         const obj = await this._eval(expr.obj, scope);
         const idx = await this._eval(expr.idx, scope);
         if (obj == null) return null;
-        if (Array.isArray(obj)) return obj[Number(idx)];
-        return obj[String(idx)];
+        if (Array.isArray(obj)) return obj[Number(idx)] === undefined ? null : obj[Number(idx)];
+        return obj[String(idx)] === undefined ? null : obj[String(idx)];
       }
 
       case "call": {
@@ -1547,6 +1889,16 @@ async function main() {
   // 1. fazer run file.fz ...
   // 2. fazer file.fz ...
   
+  if (cmd === "build") {
+    try {
+        const builder = require("./tools/builder.js");
+        await builder(argv[1], argv.slice(2));
+    } catch (e) {
+        console.error(e);
+    }
+    return;
+  }
+
   if (cmd === "run") {
     fileArg = argv[1];
     if (!fileArg) usage();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "fazer-lang",
-  "version": "2.3.0",
-  "description": "Fazer — The ultimate automation language. Batteries-included: HTTP Server, System Exec, Clipboard, Discord, Crypto, and Pipe Operators (->).",
+  "version": "2.4.0",
+  "description": "Fazer — The ultimate automation language. Batteries-included: Native EXE Build, Icons, HTTP Server, System Exec, Clipboard, Discord, Crypto, and Pipe Operators (->).",
   "main": "fazer.js",
   "bin": {
     "fazer": "fazer.js"

package/tools/builder.js

@@ -0,0 +1,208 @@
+
+const fs = require('fs');
+const path = require('path');
+const { execSync, spawnSync } = require('child_process');
+
+function log(msg) { console.log(`[Fazer Build] ${msg}`); }
+function error(msg) { console.error(`[Error] ${msg}`); process.exit(1); }
+
+module.exports = async function build(inputFile, args) {
+    if (!inputFile) error("No input file specified. Usage: fazer build <app.fz>");
+    
+    const inputPath = path.resolve(inputFile);
+    if (!fs.existsSync(inputPath)) error(`Input file not found: ${inputPath}`);
+    
+    const appName = path.basename(inputFile, '.fz');
+    const distDir = path.resolve(process.cwd(), 'dist', appName);
+    
+    // Parse args
+    let iconPath = null;
+    for(let i=0; i<args.length; i++) {
+        if (args[i] === '--icon' && args[i+1]) {
+            iconPath = path.resolve(args[i+1]);
+            i++;
+        }
+    }
+
+    log(`Building '${appName}'...`);
+    log(`Output Directory: ${distDir}`);
+
+    // 1. Prepare Directory
+    if (fs.existsSync(distDir)) {
+        fs.rmSync(distDir, { recursive: true, force: true });
+    }
+    fs.mkdirSync(distDir, { recursive: true });
+
+    // 2. Copy Core Files
+    const fazerRoot = path.dirname(__dirname); // tools/.. -> fazer-lang/
+    const fazerJsPath = path.join(fazerRoot, 'fazer.js');
+    
+    fs.copyFileSync(fazerJsPath, path.join(distDir, 'fazer.js'));
+    fs.copyFileSync(inputPath, path.join(distDir, 'app.fz'));
+
+    // 3. Copy node_modules (Optimized: only copy chevrotain/ws if possible, but full copy is safer)
+    const nodeModulesSrc = path.join(fazerRoot, 'node_modules');
+    if (fs.existsSync(nodeModulesSrc)) {
+        log("Copying dependencies...");
+        // Use robocopy on Windows for speed, or recursive copy
+        try {
+            // Recursive copy
+            fs.cpSync(nodeModulesSrc, path.join(distDir, 'node_modules'), { recursive: true });
+        } catch(e) {
+            log("Warning: Failed to copy node_modules. You may need to run 'npm install' in dist.");
+        }
+    } else {
+        log("Warning: node_modules not found. The app might not run without dependencies.");
+    }
+
+    // 4. Generate Launcher (C#)
+    log("Generating Native Launcher...");
+    
+    // We embed the logic to find 'node'
+    // If we want to be truly portable, we should copy node.exe here too.
+    // For now, we assume 'node' is in PATH or next to the exe.
+    
+    const launcherCs = `
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Windows.Forms;
+
+class Program {
+    [STAThread]
+    static void Main() {
+        string appDir = AppDomain.CurrentDomain.BaseDirectory;
+        string script = Path.Combine(appDir, "fazer.js");
+        string app = Path.Combine(appDir, "app.fz");
+        
+        string nodeExe = "node";
+        if (File.Exists(Path.Combine(appDir, "node.exe"))) {
+            nodeExe = Path.Combine(appDir, "node.exe");
+        }
+
+        string extraArgs = "";
+        string[] cmdArgs = Environment.GetCommandLineArgs();
+        // Skip first arg which is the executable itself
+        for (int i = 1; i < cmdArgs.Length; i++) {
+            extraArgs += " \\\"" + cmdArgs[i] + "\\\"";
+        }
+
+        ProcessStartInfo psi = new ProcessStartInfo();
+        psi.FileName = nodeExe;
+        // Arguments: "path/to/fazer.js" "path/to/app.fz" extraArgs
+        psi.Arguments = "\\\"" + script + "\\\" \\\"" + app + "\\\" " + extraArgs;
+        
+        psi.UseShellExecute = false;
+        psi.CreateNoWindow = true; 
+        psi.WindowStyle = ProcessWindowStyle.Hidden;
+
+        try {
+            Process p = Process.Start(psi);
+        } catch (Exception e) {
+            MessageBox.Show("Failed to launch Fazer App:\\n" + e.Message + "\\n\\nEnsure Node.js is installed or node.exe is in the folder.", "Launch Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
+        }
+    }
+}
+    `;
+    
+    const csPath = path.join(distDir, 'Launcher.cs');
+    fs.writeFileSync(csPath, launcherCs);
+
+    // 5. Compile Launcher
+    // We use C# compiler (csc.exe) which is available on most Windows
+    // Or we use PowerShell Add-Type hack to compile to exe? 
+    // Add-Type -OutputAssembly is easiest from PS.
+    
+    const exeName = `${appName}.exe`;
+    const exePath = path.join(distDir, exeName);
+    
+    let iconArg = "";
+    if (iconPath && fs.existsSync(iconPath)) {
+        // Copy icon to dist
+        const distIcon = path.join(distDir, 'app.ico');
+        fs.copyFileSync(iconPath, distIcon);
+        iconArg = `-Win32Icon "${distIcon}"`; // PowerShell param
+        // For csc: /win32icon:app.ico
+    }
+
+    log("Compiling EXE...");
+    
+    // We use PowerShell to compile because locating csc.exe can be annoying
+    // Add-Type -TypeDefinition $code -OutputAssembly $out -Target WinExe ...
+    
+    const psScript = `
+    $code = Get-Content -Raw "${csPath}"
+    $params = @{
+        TypeDefinition = $code
+        OutputAssembly = "${exePath}"
+        Target = "WinExe"
+        ReferencedAssemblies = "System.Windows.Forms"
+    }
+    ${iconArg ? `$compilerOptions = New-Object System.CodeDom.Compiler.CompilerParameters
+    $compilerOptions.CompilerOptions = "/win32icon:${path.join(distDir, 'app.ico').replace(/\\/g, '\\\\')}"
+    # Add-Type doesn't easily support CompilerOptions for icons in all versions.
+    # Fallback to direct csc call if needed or use specific Add-Type overload.
+    ` : ''}
+    
+    # Simple compilation without icon for now via Add-Type, 
+    # but for Icon we usually need csc. Let's try to find csc.
+    
+    $csc = (Get-ChildItem -Path "$env:windir\\Microsoft.NET\\Framework64\\v4*" -Filter csc.exe | Select-Object -Last 1).FullName
+    if (-not $csc) {
+        $csc = (Get-ChildItem -Path "$env:windir\\Microsoft.NET\\Framework\\v4*" -Filter csc.exe | Select-Object -Last 1).FullName
+    }
+    
+    if ($csc) {
+        Write-Host "Compiling with CSC: $csc"
+        $args = @("/target:winexe", "/out:${exePath}", "${csPath}")
+        if ("${iconArg}") { $args += "/win32icon:${path.join(distDir, 'app.ico')}" }
+        & $csc $args
+    } else {
+        Write-Host "CSC not found, using CSharpCodeProvider..."
+        $codeProvider = New-Object Microsoft.CSharp.CSharpCodeProvider
+        $parameters = New-Object System.CodeDom.Compiler.CompilerParameters
+        $parameters.GenerateExecutable = $true
+        $parameters.OutputAssembly = "${exePath}"
+        $parameters.CompilerOptions = "/target:winexe"
+        $parameters.ReferencedAssemblies.Add("System.Windows.Forms.dll")
+        $parameters.ReferencedAssemblies.Add("System.dll")
+        $parameters.ReferencedAssemblies.Add("System.Drawing.dll")
+        
+        if ("${iconArg}") {
+            $parameters.CompilerOptions += " /win32icon:${path.join(distDir, 'app.ico').replace(/\\/g, '\\\\')}"
+        }
+
+        $results = $codeProvider.CompileAssemblyFromSource($parameters, $code)
+        
+        if ($results.Errors.HasErrors) {
+            foreach($e in $results.Errors) {
+                Write-Error $e.ToString()
+            }
+            exit 1
+        }
+    }
+    `;
+    
+    // Write PS build script
+    const psBuildPath = path.join(distDir, 'build_exe.ps1');
+    fs.writeFileSync(psBuildPath, psScript);
+    
+    try {
+        execSync(`powershell -ExecutionPolicy Bypass -File "${psBuildPath}"`, { stdio: 'inherit' });
+    } catch(e) {
+        log("Compilation failed. See error above.");
+        // Clean up temp files
+        return;
+    }
+    
+    // Clean up
+    if (fs.existsSync(exePath)) {
+        fs.unlinkSync(csPath);
+        fs.unlinkSync(psBuildPath);
+        log("Build Success!");
+        log(`Created: ${exePath}`);
+        log("You can now zip the folder '${distDir}' and share it.");
+    } else {
+        error("EXE file was not created.");
+    }
+};