@xnoxs/flux-lang 3.2.0 → 3.2.1

package/README.md

@@ -1,74 +1,164 @@
-# Flux Lang v3.1.1 — TypeScript Parity Edition
+# ⚡ Flux Lang v3.2.0
 
-**Flux** adalah bahasa pemrograman modern yang di-transpile ke JavaScript — menggabungkan sintaks bersih ala Python (indentasi berbasis blok), tipe statis ala TypeScript, dan ekspresi kuat ala Rust/Haskell.
+**Flux** is a modern programming language that transpiles to clean JavaScript — combining Python-style indentation, TypeScript-grade type safety, Rust-inspired pattern matching, and a rich standard library — all with **zero runtime overhead**.
 
 ```
-source.flux  →  [Lexer → Parser → TypeChecker → CodeGen]  →  output.js
+source.flux  →  [CSS Pre → JSX Pre → Lexer → Parser → TypeChecker → CodeGen]  →  output.js
 ```
 
+Every Flux file compiles to plain `.js` — no virtual machine, no custom runtime. You get the full JavaScript ecosystem for free.
+
 ---
 
-## Instalasi & Penggunaan
+## Installation
 
 ```bash
-# Jalankan langsung
-node bin/flux.js run app.flux
+# Install globally
+npm install -g @xnoxs/flux-lang
 
-# Compile ke JS
-node bin/flux.js compile app.flux -o dist/app.js
+# Or locally in a project
+npm install --save-dev @xnoxs/flux-lang
+```
 
-# Type check (temukan kesalahan tipe sebelum runtime)
-node bin/flux.js check app.flux
+**Node.js API** — use `require('@xnoxs/flux-lang')` (or `require('@xnoxs/flux-lang/src/transpiler')`) to transpile Flux programmatically:
 
-# Format kode
-node bin/flux.js fmt app.flux
+```js
+const { transpile } = require('@xnoxs/flux-lang');
+const result = transpile('val x = 42\nprint(x)', {});
+console.log(result.output);
+```
 
-# Jalankan semua test
-node bin/flux.js test tests/
+---
 
-# REPL interaktif
-node bin/flux.js repl
+## CLI Reference
+
+| Command | Description |
+|---|---|
+| `flux run file.flux` | Compile and immediately execute |
+| `flux compile file.flux` | Compile to JavaScript |
+| `flux compile file.flux -o out.js` | Compile to specific output file |
+| `flux bundle main.flux -o bundle.js` | Bundle all imports into one file |
+| `flux watch file.flux` | Watch for changes and auto-compile |
+| `flux check file.flux` | Type check + static analysis |
+| `flux lint file.flux` | Lint — unused vars, unreachable code, shadowing |
+| `flux fmt file.flux` | Format source code |
+| `flux test [dir]` | Find and run all `*.test.flux` files |
+| `flux tokens file.flux` | Show lexer token stream |
+| `flux ast file.flux` | Show AST as JSON |
+| `flux repl` | Interactive REPL |
+| `flux version` | Show version |
+| `flux init [name]` | Create new Flux project |
+
+### Flags
 
-# Bundle beberapa file
-node bin/flux.js bundle main.flux -o bundle.js
+```
+--out, -o <file>    Output file
+--sourcemap, -m     Generate source map (.js.map)
+--stdout            Print output to terminal
+--no-color          Disable color output
 ```
 
 ---
 
-## Sintaks Dasar
+## Quick Start
+
+```flux
+// Immutable and mutable variables
+val name = "Flux"
+var count = 0
+
+// Typed function
+fn greet(who: String) -> String:
+    return "Hello, {who}!"
+
+print(greet(name))    // Hello, Flux!
+
+// Arrays + pipe operator
+val result = [1, 2, 3, 4, 5]
+    |> filter(n -> n % 2 == 0)
+    |> map(n -> n * n)
+    |> sum                        // 20
 
-### Variabel
+// Algebraic Data Types + pattern matching
+type Result = Ok(value) | Err(message)
+
+fn divide(a, b):
+    if b == 0: return Err("division by zero")
+    return Ok(a / b)
+
+match divide(10, 2):
+    when Ok(v)  -> print("Result: {v}")
+    when Err(e) -> print("Error: {e}")
+```
+
+---
+
+## Variables & Data Types
 
 ```flux
 val x = 42            // immutable (const)
 var count = 0         // mutable (let)
 
-// Dengan type annotation
+// With type annotation
 val name: String = "Flux"
-val age: Int = 3
-val score: Float = 9.5
-val active: Bool = true
-val nothing: Null = null
+val age:  Int    = 3
+val pi:   Float  = 3.14159
+val on:   Bool   = true
 
-// Tanpa annotation — type diinfer otomatis
-val items = [1, 2, 3]   // infer: Array<Int>
-val greeting = "Hello"   // infer: String
+// Type is inferred automatically when omitted
+val items = [1, 2, 3]      // inferred: Array<Int>
+val greeting = "Hello"      // inferred: String
 ```
 
-### Print & Template Strings
+### Primitive Types
+
+| Type | Description | Example |
+|---|---|---|
+| `String` | Text | `"Hello"`, `'World'` |
+| `Int` | Integer | `42`, `-7` |
+| `Float` | Decimal | `3.14`, `-0.5` |
+| `Number` | Int or Float | `100`, `3.14` |
+| `Bool` | True or false | `true`, `false` |
+| `Null` | Null value | `null` |
+| `Void` | No return value | empty return |
+| `Never` | Never completes | throw / infinite loop |
+| `Any` | Skip type check | all types |
+| `Unknown` | Needs narrowing first | — |
+
+---
+
+## Strings & Regex
+
+Flux has four string literal types:
 
 ```flux
-print("Hello, World!")
-print("Dua ditambah dua: {2 + 2}")
-print("Pi: {3.14159:.2f}")     // format spec
-print("Besar: {n:,}")           // separator ribuan
-print("Persen: {rate:.1%}")     // format persen
+// Double-quoted — interpolation + format specs
+val n = 3.14159
+print("Pi is {n:.2f}")        // Pi is 3.14
+print("Big: {5000000:,}")     // Big: 5,000,000
+print("Rate: {0.1573:.1%}")   // Rate: 15.7%
+
+// Single-quoted — no interpolation (safe for CSS/HTML)
+val css = 'color: #38bdf8'
+
+// Backtick — multiline, no interpolation
+val html = `
+  <div class="card">
+    <h2>Hello</h2>
+  </div>
+`
+
+// Regex literals
+val emailPattern = /^[a-z]+@[a-z]+\.[a-z]+$/i
+val isEmail = emailPattern.test("user@example.com")   // true
 ```
 
-### Operator
+---
+
+## Operators
 
 ```flux
-// Aritmatika
+// Arithmetic
 val a = 10 + 3    // 13
 val b = 10 - 3    // 7
 val c = 10 * 3    // 30
@@ -76,12 +166,12 @@ val d = 10 / 3    // 3.333...
 val e = 10 % 3    // 1
 val f = 2 ** 10   // 1024
 
-// Perbandingan
+// Comparison
 val eq  = a == b    // false
 val neq = a != b    // true
 val lt  = a < b     // false
 
-// Logika
+// Logical
 val and_ = true && false   // false
 val or_  = true || false   // true
 val not_ = !true            // false
@@ -91,16 +181,32 @@ val result = maybeNull ?? "default"
 
 // Optional chaining
 val len = user?.name?.length
+
+// Range (exclusive)
+for i in 0..10: print(i)    // 0 to 9
+
+// Pipe operator
+val total = nums |> filter(n -> n > 0) |> sum
+
+// Spread
+val merged = { ...defaults, ...overrides }
+
+// Non-null assertion
+val upper = value!.toUpperCase()
+
+// Cast and satisfies
+val n = expr as Int
+val config = obj satisfies Config
 ```
 
 ---
 
-## Fungsi
+## Functions
 
-### Deklarasi Dasar
+### Block & Inline
 
 ```flux
-// Inline (satu baris)
+// Inline — single expression
 fn double(x) -> x * 2
 fn add(a, b) -> a + b
 fn greet(name) -> "Hello, {name}!"
@@ -114,134 +220,167 @@ fn factorial(n):
 ### Type Annotations
 
 ```flux
-// Parameter dan return type
 fn greet(name: String) -> String:
     return "Hello, {name}!"
 
-fn add(a: Int, b: Int) -> Int:
-    return a + b
-
 fn area(w: Float, h: Float) -> Float:
     return w * h
 
-// Parameter opsional
+// Optional param (caller may omit it)
 fn greetUser(name: String, title?: String) -> String:
     val prefix = title ?? ""
-    if prefix != "":
-        return "{prefix} {name}"
+    if prefix != "": return "{prefix} {name}"
     return name
-```
-
-### Sintaks Return Type
-
-Gunakan `-> ReturnType:` sebelum badan blok fungsi:
-
-```flux
-// Blok body dengan return type annotation
-fn multiply(a: Int, b: Int) -> Int:
-    return a * b
 
-// Inline body (tanpa return type — diinfer otomatis)
-fn square(x) -> x * x
-
-// Nullable return type
-fn findUser(id: Int) -> String?:
-    if id > 0: return "user_{id}"
-    return null
-```
-
-### Tipe Return Khusus
-
-```flux
-// Void — tidak mengembalikan nilai
+// Void / Never
 fn logMessage(msg: String) -> Void:
     print(msg)
 
-// Never — selalu melempar error (tidak pernah selesai)
 fn crash(msg: String) -> Never:
     throw new Error(msg)
 ```
 
-### Parameter Rest & Default
+### Default & Rest Parameters
 
 ```flux
-// Rest parameter
-fn sum(...nums):
-    return nums.reduce((acc, x) -> acc + x, 0)
-
-// Default value
 fn repeat(str: String, times: Int = 3) -> String:
     return str.repeat(times)
+
+fn sum(...nums):
+    return nums.reduce((acc, x) -> acc + x, 0)
 ```
 
-### Fungsi Async
+### Async Functions
 
 ```flux
 async fn fetchData(url: String) -> String:
-    val res = await fetch(url)
-    return await res.text()
+    val res  = await fetch(url)
+    val text = await res.text()
+    return text
 
 async fn main():
-    val data = await fetchData("https://api.example.com")
+    val data = await fetchData("https://api.example.com/data")
     print(data)
 ```
 
-### Higher-Order Functions & Lambda
+### Lambda & Higher-Order
 
 ```flux
-// Lambda ekspresi
 val square = x -> x * x
-val add = (a, b) -> a + b
+val add    = (a, b) -> a + b
+
+// Multi-statement lambda
+val process = x -> {
+    val doubled = x * 2
+    return doubled + 1
+}
 
-// Fungsi sebagai argumen
+// Functions as arguments
 val doubled = [1, 2, 3].map(x -> x * 2)          // [2, 4, 6]
-val evens   = [1, 2, 3, 4, 5].filter(x -> x % 2 == 0)  // [2, 4]
-val total   = [1, 2, 3, 4].reduce((acc, x) -> acc + x, 0)  // 10
+val evens   = [1..10].filter(x -> x % 2 == 0)    // [2, 4, 6, 8, 10]
 
-// Pipe operator — rantai transformasi
+// Pipe operator — chain transformations
 val result = [1, 2, 3, 4, 5]
     |> filter(x -> x > 2)
     |> map(x -> x * 10)
-    |> sum
+    |> sum                  // 120
 ```
 
 ---
 
-## Tipe Data (Type System)
+## Control Flow
 
-Flux v3.0.0 memiliki sistem tipe yang diperiksa saat kompilasi (`flux check`). Tipe dihapus pada output JavaScript — sama seperti TypeScript.
+### If / Elif / Else
 
-### Tipe Primitif
+```flux
+if x > 0:
+    print("positive")
+elif x < 0:
+    print("negative")
+else:
+    print("zero")
 
-| Tipe      | Deskripsi                    | Contoh                |
-|-----------|------------------------------|-----------------------|
-| `String`  | Teks                         | `"Hello"`, `'World'` |
-| `Int`     | Bilangan bulat               | `42`, `-7`            |
-| `Float`   | Bilangan desimal             | `3.14`, `-0.5`        |
-| `Number`  | Int atau Float               | `100`, `3.14`         |
-| `Bool`    | Benar atau salah             | `true`, `false`       |
-| `Null`    | Nilai null                   | `null`                |
-| `Void`    | Tidak mengembalikan nilai    | return kosong         |
-| `Never`   | Tidak pernah selesai         | throw / infinite loop |
-| `Any`     | Lewati type check            | semua tipe            |
-| `Unknown` | Perlu narrowing dulu         | —                     |
+// Ternary
+val label = x > 0 ? "positive" : "non-positive"
+```
 
-### Union Types
+### For / While / Do-While
 
 ```flux
-val id: Int | String = 42           // Int atau String
-val value: Int | String = "hello"   // juga valid
+// Iterate array
+for item in items:
+    print(item)
 
-fn stringify(x: Int | String | Bool) -> String:
-    return "{x}"
+// Range
+for i in 0..10:
+    print(i)            // 0 to 9
+
+// for..of — any JS iterable
+for char of "hello":
+    print(char)
+
+// For with array destructuring
+for [i, v] in enumerate(items):
+    print("{i}: {v}")
+
+// Labeled break / continue
+outer: for i in 0..5:
+    for j in 0..5:
+        if j == 2: break outer
+
+// While
+var n = 10
+while n > 0:
+    print(n)
+    n -= 1
+
+// Do-while
+do:
+    print("runs at least once")
+while false
 ```
 
-### Nullable Types
+### Match (Pattern Matching)
 
 ```flux
-// String? adalah singkatan dari String | Null
-val name: String? = null
-val other: String? = "Flux"
+// Literal
+match value:
+    when 0       -> print("zero")
+    when 1..9    -> print("one digit")
+    when 10..99  -> print("two digits")
+    when _       -> print("other")
+
+// Guards
+match score:
+    when s if s >= 90 -> print("A")
+    when s if s >= 80 -> print("B")
+    when s if s >= 70 -> print("C")
+    when _            -> print("D")
+
+// ADT destructuring
+match result:
+    when Ok(v)  -> print("Result: {v}")
+    when Err(e) -> print("Error: {e}")
+
+// As expression
+val label = match status:
+    when "active"   -> "Online"
+    when "inactive" -> "Offline"
+    when _          -> "Unknown"
+```
+
+---
+
+## Type System
+
+### Union & Nullable
+
+```flux
+val id: Int | String = 42            // Int or String
+val name: String?    = null          // String | Null shorthand
+
+fn stringify(x: Int | String | Bool) -> String:
+    return "{x}"
 
 fn findById(id: Int) -> String?:
     if id > 0: return "item_{id}"
@@ -252,18 +391,115 @@ fn findById(id: Int) -> String?:
 
 ```flux
 val names: Array<String> = ["Andi", "Budi", "Cici"]
-val nums:  Array<Int>    = [1, 2, 3, 4, 5]
+val map:   Map<String, Int> = new Map()
 
-fn first(items: Array<String>) -> String?:
+fn first<T>(items: Array<T>) -> T?:
     if items.length == 0: return null
     return items[0]
 ```
 
+### Function Types
+
+```flux
+fn mapInts(arr: Array<Int>, f: fn(Int) -> Int) -> Array<Int>:
+    return arr.map(f)
+
+// In an interface
+interface Handler:
+    fn handle(req: String) -> String
+```
+
+### Inline Object Types & Tuples
+
+```flux
+fn makePoint(x: Float, y: Float) -> { x: Float, y: Float }:
+    return { x, y }
+
+fn getCoord() -> [Float, Float]:
+    return [3.14, 2.71]
+
+val [lat, lng] = getCoord()
+```
+
+### Intersection Types
+
+```flux
+interface Named:  name: String
+interface Aged:   age: Int
+
+class Person implements Named, Aged:
+    name: String
+    age:  Int
+
+// Type alias intersection
+type Entity = Named & { id: Int }
+```
+
+### Conditional Types
+
+```flux
+// T extends U ? A : B
+type IsString<T> = T extends String ? "yes" : "no"
+
+// infer — extract a type from inside another
+type Unwrap<T> = T extends Array<infer U> ? U : T
+```
+
+### Type Narrowing
+
+```flux
+val user = getUser(1)   // String?
+
+if user != null:
+    print(user.toUpperCase())   // narrowed to String here
+
+// typeof narrowing
+fn process(x: Int | String | Bool) -> String:
+    if typeof x == "number": return "num: {x}"
+    if typeof x == "string": return "str: {x}"
+    return "bool: {x}"
+```
+
+### Utility Types
+
+```flux
+Partial<T>          // all fields optional
+Required<T>         // all fields required
+Readonly<T>         // all fields read-only
+Record<K, V>        // dictionary type
+Pick<T, K>          // keep only specified keys
+Omit<T, K>          // remove specified keys
+NonNullable<T>      // remove null from union
+ReturnType<T>       // extract return type of fn
+Awaited<T>          // unwrap Promise<T>
+Parameters<T>       // parameter types as tuple
+Exclude<T, U>       // remove U from T
+Extract<T, U>       // keep only U in T
+```
+
+### Index Signatures
+
+```flux
+fn buildRegistry() -> { [key: String]: String }:
+    return { name: "Flux", version: "3.2.0" }
+```
+
+### `keyof` & `typeof`
+
+```flux
+fn getField(key: keyof Config) -> String:
+    return key
+
+val config = new Config("host", "localhost")
+fn cloneConfig(src: typeof config) -> typeof config:
+    return new Config(src.key, src.value)
+```
+
 ---
 
-## Interface
+## Interfaces
 
-Interface mendefinisikan kontrak yang harus dipenuhi class. `flux check` melaporkan **error** jika ada anggota yang tidak diimplementasi.
+Interfaces define structural contracts. `flux check` reports an **error** if a required member is missing.
 
 ```flux
 interface Printable:
@@ -271,56 +507,44 @@ interface Printable:
 
 interface Shape:
     name: String
-    fn area() -> Float
+    fn area()      -> Float
     fn perimeter() -> Float
 
-// Interface dengan inheritance
+// Inheritance
 interface ColoredShape extends Shape:
     color: String
     fn setColor(c: String) -> Void
 
-// Generic interface
+// Generic
 interface Container<T>:
-    fn get() -> T
-    fn set(value: T) -> Void
+    fn get()         -> T
+    fn set(v: T)     -> Void
+    fn isEmpty()     -> Bool
 ```
 
-### Class Mengimplementasi Interface
+### Class Implementing Interface
 
 ```flux
 class Rectangle implements Shape:
-    name: String
-    width: Float
+    name:   String
+    width:  Float
     height: Float
 
-    fn area() -> Float:
-        return self.width * self.height
-
-    fn perimeter() -> Float:
-        return 2.0 * (self.width + self.height)
-
-class Circle implements Shape:
-    name: String
-    radius: Float
+    fn area()      -> Float -> self.width * self.height
+    fn perimeter() -> Float -> 2.0 * (self.width + self.height)
 
-    fn area() -> Float:
-        return 3.14159 * self.radius * self.radius
-
-    fn perimeter() -> Float:
-        return 2.0 * 3.14159 * self.radius
-
-val r = new Rectangle("Persegi", 5.0, 3.0)
+val r = new Rectangle("rect", 5.0, 3.0)
 print(r.area())        // 15
 print(r.perimeter())   // 16
 ```
 
 ---
 
-## Class
+## Classes
 
 ```flux
 class Animal:
-    name: String
+    name:  String
     sound: String
 
     fn speak() -> String:
@@ -342,8 +566,9 @@ print(dog.info())    // Dog: Rex (Labrador)
 
 ```flux
 class BankAccount:
-    private balance: Float
-    readonly owner: String
+    private   balance:  Float
+    readonly  id:       String
+    public    owner:    String
 
     fn deposit(amount: Float) -> Void:
         self.balance += amount
@@ -352,35 +577,130 @@ class BankAccount:
         return self.balance
 ```
 
+> **Private fields** compile to JavaScript `#field` syntax — enforced at the JS engine level, not just TypeScript-style erased annotations.
+
+### Static Methods & Properties
+
+```flux
+class MathUtils:
+    static val PI = 3.14159
+
+    static fn circle(r: Float) -> Float:
+        return MathUtils.PI * r * r
+```
+
+### Getter / Setter
+
+```flux
+class Temperature:
+    private celsius: Float
+
+    get fahrenheit() -> Float:
+        return self.celsius * 9.0 / 5.0 + 32.0
+
+    set fahrenheit(f: Float):
+        self.celsius = (f - 32.0) * 5.0 / 9.0
+```
+
+### Generic Classes
+
+```flux
+class Stack<T>:
+    private items: Array<T> = []
+
+    fn push(item: T) -> Void:
+        self.items.push(item)
+
+    fn pop() -> T?:
+        return self.items.pop()
+
+    get size() -> Int:
+        return self.items.length
+```
+
+---
+
+## Decorators
+
+Decorators wrap functions and classes to add behaviour without modifying their source.
+
+```flux
+// @name — apply decorator after definition
+@log
+fn fetchUser(id: Int):
+    return fetch("/api/users/{id}")
+
+// @name(args) — decorator factory (called with args, returns decorator)
+@deprecated("use fetchUserV2 instead")
+fn fetchUser(id):
+    return fetch("/api/users/{id}")
+
+// Class decorator
+@injectable
+class UserService:
+    var db: Database
+
+// Multiple decorators (applied bottom-up)
+@singleton
+@injectable
+class AppService:
+    var repo: Repository
+```
+
+**How it compiles:**
+
+```javascript
+// @log fn greet()  →
+function greet(name) { ... }
+greet = log(greet);
+
+// @deprecated("...") fn foo()  →
+function foo() { ... }
+foo = deprecated("use fetchUserV2 instead")(foo);
+
+// @injectable class Service  →
+class Service { ... }
+Service = injectable(Service);
+```
+
 ---
 
 ## Algebraic Data Types (ADT)
 
 ```flux
-// Definisi
+// Definition
 type Option = Some(value) | None
-type Result = Ok(value) | Err(message)
+type Result = Ok(value)   | Err(message)
 type Shape  = Circle(radius) | Rectangle(w, h) | Triangle(base, height)
+
+// Generic ADTs
+type Result<T> = Ok(value) | Err(message)
+type Either<L, R> = Left(value) | Right(value)
 ```
 
-### Pattern Matching dengan ADT
+### Pattern Matching with ADT
 
 ```flux
 fn safeDivide(a: Float, b: Float) -> Result:
     if b == 0.0: return Err("Division by zero")
     return Ok(a / b)
 
-val result = safeDivide(10.0, 2.0)
-
-match result:
-    when Ok(v)  -> print("Result: {v}")
-    when Err(e) -> print("Error: {e}")
+match safeDivide(10.0, 2.0):
+    when Ok(v)             -> print("Result: {v}")
+    when Err(e)            -> print("Error: {e}")
 
-// Dengan guard
-match result:
-    when Ok(v) if v > 0 -> print("Positive: {v}")
+// Guards
+match safeDivide(10.0, 2.0):
+    when Ok(v) if v > 0  -> print("Positive: {v}")
     when Ok(v)           -> print("Non-positive: {v}")
     when Err(e)          -> print("Error: {e}")
+
+// Shape area using ADT
+fn area(shape: Shape) -> Float:
+    match shape:
+        when Circle(r)      -> 3.14159 * r * r
+        when Rectangle(w,h) -> w * h
+        when Triangle(b,h)  -> 0.5 * b * h
 ```
 
 ---
@@ -399,63 +719,46 @@ enum Status:
     Inactive
     Pending
 
-print(Direction.North)   // 0
-print(Status.Active)     // 0
+enum Color:
+    Red           // 0
+    Green = 10    // 10
+    Blue          // 11  (auto-increments from explicit value)
+
+print(Direction.North)  // 0
+print(Status.Active)    // 0
+
+// Enums in match
+match dir:
+    when Direction.North -> print("Going north")
+    when Direction.South -> print("Going south")
+    when _               -> print("Other direction")
 ```
 
 ---
 
-## Kontrol Alur
-
-### If / Else
-
-```flux
-if x > 0:
-    print("positif")
-else if x < 0:
-    print("negatif")
-else:
-    print("nol")
-```
-
-### For / While / Do-While
+## Destructuring & Spread
 
 ```flux
-// Iterasi array
-for item in items:
-    print(item)
-
-// Range
-for i in 0..10:
-    print(i)
+// Object destructuring
+val person = { name: "Budi", age: 25, city: "Jakarta" }
+val { name, age } = person
 
-// While
-var n = 10
-while n > 0:
-    print(n)
-    n -= 1
+// With alias
+val { name: personName, age: personAge } = person
 
-// Do-while
-do:
-    print("minimal sekali")
-while false
-```
+// Array destructuring
+val [first, second, ...rest] = [1, 2, 3, 4, 5]
 
-### Match (Pattern Matching)
+// With default value
+val { title = "Untitled", content } = post
 
-```flux
-match nilai:
-    when 0       -> print("nol")
-    when 1..9    -> print("satu digit")
-    when 10..99  -> print("dua digit")
-    when _       -> print("lainnya")
+// In function params
+fn greet({ name, title = "Mr" }) -> String:
+    return "Hello, {title} {name}!"
 
-// Match dengan guard
-match score:
-    when s if s >= 90 -> print("A")
-    when s if s >= 80 -> print("B")
-    when s if s >= 70 -> print("C")
-    when _            -> print("D")
+// Spread — shallow merge
+val defaults_ = { role: "viewer", active: true }
+val merged    = { ...defaults_, ...overrides }
 ```
 
 ---
@@ -468,317 +771,419 @@ try:
     val data = JSON.parse(input)
     print(data)
 catch(e):
-    print("Error: {e.message}")
+    print("Parse error: {e.message}")
 finally:
-    print("Selesai")
+    print("Done")
 
 // Throw
 fn validateAge(age: Int) -> Void:
     if age < 0:
-        throw new Error("Usia tidak boleh negatif: {age}")
+        throw new Error("Age cannot be negative: {age}")
 
-// Dengan ADT Result
+// ADT Result pattern (no exceptions)
 type Result = Ok(value) | Err(message)
 
 fn parseNumber(s: String) -> Result:
     val n = parseInt(s, 10)
-    if isNaN(n): return Err("Bukan angka: {s}")
+    if isNaN(n): return Err("Not a number: {s}")
     return Ok(n)
+
+match parseNumber("42"):
+    when Ok(n)  -> print("Got: {n}")
+    when Err(e) -> print("Failed: {e}")
 ```
 
 ---
 
-## Destructuring
+## Async / Await
 
 ```flux
-// Object destructuring
-val person = { name: "Budi", age: 25, city: "Jakarta" }
-val { name, age, city } = person
-
-// Dengan alias
-val { name: personName, age: personAge } = person
-
-// Array destructuring
-val [first, second, ...rest] = [1, 2, 3, 4, 5]
-
-// Dengan default value
-val { title = "Tanpa Judul", content } = post
+async fn fetchUser(id: Int):
+    val res  = await fetch("/api/users/{id}")
+    val user = await res.json()
+    return user
+
+// Parallel requests
+async fn loadDashboard():
+    val [user, posts, config] = await Promise.all([
+        fetchUser(1),
+        fetchPosts(),
+        fetchConfig()
+    ])
+    print("Loaded: {user.name}, {posts.length} posts")
+
+// Error handling in async
+async fn safeLoad(url: String):
+    try:
+        val res = await fetch(url)
+        return await res.json()
+    catch(e):
+        print("Network error: {e.message}")
+        return null
 ```
 
 ---
 
-## Import / Export
+## Modules
 
 ```flux
 // Import default
 import express from 'express'
 
-// Import named
+// Named imports
 import { readFileSync, writeFileSync } from 'fs'
 
-// Import namespace
+// Namespace import
 import * as path from 'path'
 
-// Export
+// Aliased import
+import { useState as useLocalState } from 'react'
+
+// Export named
 export fn calculateTax(amount: Float, rate: Float) -> Float:
     return amount * rate
 
+export val TAX_RATE = 0.1
+
+// Export default
 export default fn main():
     print("Hello from main!")
 ```
 
 ---
 
-## Interop dengan npm
+## Pipe Operator
 
-Flux di-transpile ke JavaScript — semua package npm dapat digunakan langsung:
+The `|>` operator passes the left value as the first argument to the right function. Combine with stdlib for expressive data pipelines.
 
 ```flux
-import express from 'express'
-import { readFileSync } from 'fs'
-
-val app = express()
-
-app.get("/", fn(req, res):
-    res.json({ status: "ok", lang: "Flux" })
-)
-
-app.listen(3000, fn():
-    print("Server Flux berjalan di port 3000")
-)
+// Chained transformations
+val total = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+    |> filter(n -> n % 2 == 0)
+    |> map(n -> n * n)
+    |> reduce((acc, n) -> acc + n, 0)   // 220
+
+// String pipeline
+val slug = "  Hello World  "
+    |> trim
+    |> s -> s.toLowerCase()
+    |> s -> s.replace(/\s+/g, "-")     // "hello-world"
+
+// With stdlib functions
+val topScorers = students
+    |> sortBy(s -> s.score)
+    |> s -> s.reverse()
+    |> take(3)
+    |> map(s -> s.name)
 ```
 
 ---
 
-## JSX (React)
+## JSX
+
+Configure the target in `flux.config.js`: `jsxTarget: "react"` for React, `jsxTarget: "server"` for server-side string rendering.
 
 ```flux
-// Server-side JSX
-val heading = <h1 class="title">Hello Flux!</h1>
-val card = <div class="card">
-    <h2>{title}</h2>
-    <p>{description}</p>
-</div>
+// React component
+fn Button({ label, onClick, disabled = false }):
+    return (
+        <button
+            onClick={onClick}
+            disabled={disabled}
+            className={disabled ? 'btn disabled' : 'btn'}
+        >
+            {label}
+        </button>
+    )
+
+// Conditional rendering
+fn UserCard({ user }):
+    return (
+        <div className="card">
+            <h2>{user.name}</h2>
+            {user.email && <p>{user.email}</p>}
+        </div>
+    )
+
+// List rendering
+fn ItemList({ items }):
+    return (
+        <ul>
+            {items.map(item -> <li key={item.id}>{item.name}</li>)}
+        </ul>
+    )
 ```
 
 ---
 
-## CSS Preprocessor
+## CSS-in-Flux
+
+The `css {}` block is a Flux-native CSS preprocessor. Supports shorthand properties and standard CSS with Flux sugar.
 
 ```flux
-val styles = css`
-    .button {
-        background: var(--primary);
-        border-radius: 8px;
-        padding: 8px 16px;
+val styles = css {
+    .card {
+        flex; center; bold
+        bg: #0f172a
+        radius: 12px
+        p: 20px
+        border: 1px solid #1e3a5f
 
         &:hover {
-            opacity: 0.9;
+            border-color: #38bdf8
         }
     }
-`
-```
-
----
 
-## Perintah CLI
-
-| Perintah                        | Deskripsi                                            |
-|---------------------------------|------------------------------------------------------|
-| `flux init [nama]`              | Buat project Flux baru                               |
-| `flux compile file.flux`        | Compile ke JavaScript                                |
-| `flux compile file.flux -o out` | Compile ke file output tertentu                      |
-| `flux bundle main.flux`         | Bundle semua import menjadi satu file                |
-| `flux run file.flux`            | Compile dan langsung jalankan                        |
-| `flux watch file.flux`          | Pantau perubahan dan compile otomatis                |
-| `flux check file.flux`          | **Type check** + analisis statis                     |
-| `flux lint file.flux`           | **Lint** — unused vars, unreachable code, shadowing  |
-| `flux fmt file.flux`            | Format kode sumber                                   |
-| `flux test [dir]`               | Temukan dan jalankan file `*.test.flux`              |
-| `flux tokens file.flux`         | Tampilkan daftar token dari lexer                    |
-| `flux ast file.flux`            | Tampilkan AST dalam format JSON                      |
-| `flux repl`                     | Mode REPL interaktif                                 |
-| `flux version`                  | Tampilkan versi                                      |
-
-### Flag
+    .button {
+        bg: linear-gradient(135deg, #38bdf8, #818cf8)
+        radius: 8px
+        p: 10px 20px
+        color: white
+        bold
 
+        &:hover { opacity: 0.85 }
+    }
+}
 ```
---out, -o <file>    File output
---sourcemap, -m     Hasilkan source map (.js.map)
---stdout            Cetak output ke terminal
---no-color          Nonaktifkan warna
-```
+
+**Shorthand properties:** `flex` → `display:flex`, `bold` → `font-weight:700`, `center` → `text-align:center`, `bg` → `background`, `radius` → `border-radius`, `p` → `padding`, `m` → `margin`.
 
 ---
 
-## Sistem Tipe — TypeScript Parity
+## Standard Library
 
-Flux v3.1.0 memiliki sistem tipe yang setara dengan TypeScript. Berikut fitur lengkapnya:
+All stdlib functions are **tree-shaken** — only symbols actually used in compiled output are injected.
 
-### Intersection Types (`A & B`)
+### Sequences
 
 ```flux
-interface Named:
-    name: String
-
-interface Aged:
-    age: Int
-
-// Intersection: class harus memenuhi SEMUA interface
-class Person implements Named, Aged:
-    name: String
-    age: Int
+range(end)                   // range(5)              → [0,1,2,3,4]
+range(start, end)            // range(1, 4)           → [1,2,3]
+range(start, end, step)      // range(0, 10, 2)       → [0,2,4,6,8]
+zip(...arrays)               // zip([1,2],[3,4])       → [[1,3],[2,4]]
+unzip(pairs)                 // unzip([[1,"a"]])       → [[1],["a"]]
+enumerate(arr, start?)       // enumerate(["a","b"])   → [[0,"a"],[1,"b"]]
+flatten(arr, depth?)         // flatten([[1,[2]],3])   → [1,2,3]
+chunk(arr, size)             // chunk([1..5], 2)       → [[1,2],[3,4],[5]]
+unique(arr)                  // unique([1,2,2,3])      → [1,2,3]
+groupBy(arr, fn|key)         // groupBy(items, "type") → { fruit:[...], veg:[...] }
+sortBy(arr, fn|key)          // sortBy(users, "age")
+countBy(arr, fn|key)         // countBy(words, w -> w[0]) → { a:3, b:2 }
+partition(arr, fn)           // partition(nums, n -> n>0) → [[pos],[neg]]
+toPairs(obj)                 // toPairs({a:1})         → [["a",1]]
 ```
 
-### Tuple Types
+### Arrays (pipe-compatible)
 
 ```flux
-fn getCoord() -> [Float, Float]:
-    return [3.14, 2.71]
-
-fn parseKV(pair: String) -> [String, String]:
-    val parts = pair.split("=")
-    return [parts[0], parts[1]]
-
-val [lat, lng] = getCoord()        // destructure tuple
-val [key, val_] = parseKV("a=b")
+// Pipe helpers — designed for |>
+map(arr, fn)                 // [1,2,3] |> map(x -> x*2)
+filter(arr, fn)              // nums |> filter(x -> x > 0)
+reduce(arr, fn, init?)       // nums |> reduce((a,n) -> a+n, 0)
+forEach(arr, fn)             // items |> forEach(print)
+find(arr, fn)                // users |> find(u -> u.id == id)
+findIndex(arr, fn)           // arr |> findIndex(x -> x == 5)
+some(arr, fn)                // arr |> some(x -> x > 10)
+every(arr, fn)               // arr |> every(x -> x > 0)
+join(arr, sep?)              // words |> join(", ")
+sort(arr, fn?)               // nums |> sort()
+flat(arr, depth?)            // nested |> flat()
+flatMap(arr, fn)             // arrs |> flatMap(x -> x)
+includes(arr, val)           // arr |> includes(5)
+
+// Array extras
+first(arr) / head(arr)       // first([1,2,3])        → 1
+last(arr)                    // last([1,2,3])          → 3
+tail(arr)                    // tail([1,2,3])          → [2,3]
+nth(arr, n)                  // nth([1,2,3], -1)       → 3
+take(arr, n)                 // take([1,2,3,4], 2)     → [1,2]
+drop(arr, n)                 // drop([1,2,3,4], 2)     → [3,4]
+takeWhile(arr, fn)           // takeWhile([1,2,5,3], n -> n<4) → [1,2]
+dropWhile(arr, fn)           // dropWhile([1,2,5,3], n -> n<4) → [5,3]
+compact(arr)                 // compact([0,1,null,2,""])       → [1,2]
+intersection(a, b)           // intersection([1,2,3],[2,3,4])  → [2,3]
+difference(a, b)             // difference([1,2,3],[2,3])      → [1]
+arrayUnion(a, b)             // arrayUnion([1,2],[2,3])        → [1,2,3]
+count(arr, fn?)              // count(arr, x -> x > 0)
+minBy(arr, fn|key)           // minBy(users, u -> u.age)
+maxBy(arr, fn|key)           // maxBy(products, p -> p.price)
+rotate(arr, n)               // rotate([1,2,3,4], 1)   → [2,3,4,1]
+sliding(arr, size, step?)    // sliding([1,2,3,4], 2)  → [[1,2],[2,3],[3,4]]
 ```
 
-### Inline Object Types
+### Math & Random
 
 ```flux
-fn makePoint(x: Float, y: Float) -> { x: Float, y: Float }:
-    return { x, y }
-
-fn distance(p1: { x: Float, y: Float }, p2: { x: Float, y: Float }) -> Float:
-    val dx = p1.x - p2.x
-    val dy = p1.y - p2.y
-    return Math.sqrt(dx * dx + dy * dy)
+clamp(val, min, max)         // clamp(150, 0, 100)     → 100
+sum(arr)                     // sum([1,2,3,4])          → 10
+product(arr)                 // product([1,2,3,4])      → 24
+min(arr) / min(a, b, ...)    // min([3,1,4])            → 1
+max(arr) / max(a, b, ...)    // max([3,1,4])            → 4
+abs(n)                       // abs(-5)                 → 5
+floor(n)                     // floor(3.7)              → 3
+ceil(n)                      // ceil(3.2)               → 4
+round(n, decimals?)          // round(3.14159, 2)       → 3.14
+mean(arr)                    // mean([1,2,3,4,5])       → 3
+median(arr)                  // median([1,3,5])         → 3
+stdDev(arr)                  // stdDev([2,4,4,4,5])     → ~0.97
+lerp(a, b, t)                // lerp(0, 100, 0.5)       → 50
+randInt(min, max)            // randInt(1, 6)           → dice roll
+sample(arr)                  // sample(["a","b","c"])   → random element
+shuffle(arr)                 // shuffle(range(1, 53))   → shuffled deck
 ```
 
-### Structural Typing
+> **`Math` object** — all JS `Math` functions are also directly available: `Math.sqrt`, `Math.pow`, `Math.log`, `Math.sin`, `Math.cos`, `Math.PI`, etc.
 
-```flux
-interface Printable:
-    fn toString() -> String
+### Objects
 
-// Tidak perlu implements jika shape cocok (duck typing)
-class Config implements Printable:
-    key: String
-    fn toString() -> String -> "Config({self.key})"
+```flux
+keys(obj)                    // keys({a:1,b:2})             → ["a","b"]
+values(obj)                  // values({a:1,b:2})           → [1,2]
+entries(obj)                 // entries({a:1})              → [["a",1]]
+pick(obj, keys)              // pick(user, ["name","role"])
+omit(obj, keys)              // omit(user, ["password"])
+merge(obj, ...sources)       // merge(defaults, overrides)
+defaults(obj, ...sources)    // fill null/undefined only
+invert(obj)                  // invert({ok:200})            → {"200":"ok"}
+mapValues(obj, fn)           // mapValues(scores, v -> v*2)
+filterValues(obj, fn)        // filterValues(obj, v -> v > 0)
+fromEntries(entries)         // fromEntries([["x",1]])      → {x:1}
+deepEqual(a, b)              // deepEqual({a:1}, {a:1})     → true
+deepClone(v)                 // deep copy via JSON round-trip
 ```
 
-### Type Narrowing via Control Flow
+### Strings
 
 ```flux
-fn getUser(id: Int) -> String?:
-    if id > 0: return "User_{id}"
-    return null
+capitalize(s)                // capitalize("hello")         → "Hello"
+camelCase(s)                 // camelCase("hello world")    → "helloWorld"
+snakeCase(s)                 // snakeCase("helloWorld")     → "hello_world"
+kebabCase(s)                 // kebabCase("helloWorld")     → "hello-world"
+truncate(s, len, suffix?)    // truncate("long text", 8)    → "long ..."
+pad(s, len, char?)           // pad("hi", 6)               → "  hi  "
+padStart(s, len, char?)      // padStart("42", 5, "0")      → "00042"
+padEnd(s, len, char?)        // padEnd("hi", 5)            → "hi   "
+trim(s)                      // trim("  hi  ")             → "hi"
+trimStart(s)                 // trimStart("  hi")          → "hi"
+trimEnd(s)                   // trimEnd("hi  ")            → "hi"
+words(s)                     // words("hello world")        → ["hello","world"]
+lines(s)                     // lines("a\nb\nc")           → ["a","b","c"]
+startsWith(s, prefix)        // startsWith("flux", "fl")   → true
+endsWith(s, suffix)          // endsWith("flux", "ux")     → true
+repeat(s, n)                 // repeat("ab", 3)            → "ababab"
+replaceAll(s, find, rep)     // replaceAll("aabba", "a", "x") → "xxbbx"
+reverseStr(s)                // reverseStr("flux")         → "xulf"
+```
 
-val user = getUser(1)
+> **Native string methods** also available: `.toUpperCase()`, `.toLowerCase()`, `.split()`, `.replace()`, `.includes()`, `.slice()`, `.indexOf()`, `.match()`.
 
-// Flux mengecilkan tipe di dalam blok null-check
-if user != null:
-    print(user.toUpperCase())   // OK — user adalah String di sini, bukan String?
+### Functional
 
-// typeof narrowing
-fn process(x: Int | String | Bool) -> String:
-    if typeof x == "number": return "num: {x}"
-    if typeof x == "string": return "str: {x}"
-    return "bool: {x}"
+```flux
+pipe(f1, f2, ...)            // compose left-to-right → new function
+compose(f1, f2, ...)         // compose right-to-left → new function
+partial(fn, ...args)         // pre-fill first N arguments
+curry(fn)                    // auto-curry — one arg at a time
+memoize(fn)                  // cache results by JSON-serialized args
+once(fn)                     // execute only on first call; cache result
+flip(fn)                     // swap first two arguments
+complement(fn)               // negate fn's boolean result
+identity(v)                  // return v unchanged
+noop()                       // do nothing
 ```
 
-### Function Types
-
 ```flux
-// Anotasi tipe fungsi sebagai parameter
-fn mapInts(arr: Array<Int>, f: fn(Int) -> Int) -> Array<Int>:
-    return arr.map(f)
-
-fn double(x: Int) -> Int:
-    return x * 2
-
-val results = mapInts([1, 2, 3], double)
-
-// Tipe fungsi di interface
-interface Handler:
-    fn handle(req: String) -> String
+// pipe example
+val process = pipe(
+    s -> s.trim(),
+    s -> s.toLowerCase(),
+    capitalize
+)
+process("  hello WORLD  ")   // "Hello world"
+
+// once — run initialization only once
+val init = once(() -> {
+    print("connecting...")
+    return connectDB()
+})
+init()   // "connecting..." → connection
+init()   // silent          → same connection
+
+// complement — negate a predicate
+val isEven = n -> n % 2 == 0
+val isOdd  = complement(isEven)
+[1,2,3,4] |> filter(isOdd)   // [1,3]
+
+// curry
+val add     = curry((a, b) -> a + b)
+val addFive = add(5)
+addFive(3)    // 8
 ```
 
-### `keyof` & `typeof` di Tipe
+### Type Checks
 
 ```flux
-// keyof T — union dari semua key interface
-fn getField(key: keyof Config) -> String:
-    return key
-
-// typeof x — tipe dari variabel
-val config = new Config("host", "localhost")
-fn cloneConfig(src: typeof config) -> typeof config:
-    return new Config(src.key, src.value)
+isNil(v)                     // true if null or undefined
+isString(v)                  // true if typeof v === "string"
+isNumber(v)                  // true if finite number (excludes NaN)
+isArray(v)                   // true if Array.isArray(v)
+isObject(v)                  // true if plain object (not array/null)
+isFunction(v)                // true if typeof v === "function"
+isBool(v)                    // true if typeof v === "boolean"
 ```
 
-### Utility Types
-
 ```flux
-// Semua utility type TypeScript tersedia:
-fn setPartial(opts: Partial<Config>) -> Void:
-    // semua field optional
-    pass
-
-fn setRequired(opts: Required<Config>) -> Void:
-    // semua field wajib
-    pass
-
-fn makeReadonly(opts: Readonly<Config>) -> Void:
-    // tidak bisa diubah
-    pass
-
-// Record<K, V> — dictionary type
-fn buildMap(keys: Array<String>) -> Record<String, Int>:
-    return {}
-
-// NonNullable<T> — hapus null dari union
-fn safeGet(x: NonNullable<String?>) -> String:
-    return x
-
-// ReturnType<T> — extract return type
-// Pick<T, K>, Omit<T, K>, Exclude<T, U>, Extract<T, U>
-// Awaited<T>, Parameters<T>, InstanceType<T>
+fn safeLength(v) -> Int:
+    if isString(v): return v.length
+    if isArray(v):  return v.length
+    return 0
 ```
 
-### Index Signatures
+### Async Utils
 
 ```flux
-// { [key: String]: T } — map arbitrary keys to type
-fn buildRegistry() -> { [key: String]: String }:
-    return { name: "Flux", version: "3.1.0" }
+sleep(ms)                    // Promise that resolves after ms
+retry(fn, attempts?, delay?) // retry up to N times with exponential back-off
+timeout(fn|promise, ms)      // reject with Error if exceeds ms
+allSettled(promises)         // like Promise.allSettled — never rejects
+debounce(fn, ms)             // delay until ms of inactivity (trailing edge)
+throttle(fn, ms)             // fire at most once per ms
+memoize(fn)                  // cache async results too
 ```
 
-### Generic Type Parameters di ADT
-
 ```flux
-// Type parameter <T> di ADT declarations
-type Result<T> = Ok(value) | Err(message)
-type Option<T> = Some(value) | None
-type Either<L, R> = Left(value) | Right(value)
+// sleep — non-blocking delay
+await sleep(2000)    // wait 2 seconds
+
+// retry — defaults: 3 attempts, 300ms base delay, exponential back-off
+val data = await retry(
+    () -> fetchDataFromAPI(),
+    5,     // max attempts
+    200    // base delay ms (doubles each retry)
+)
 
-fn safeDivide(a: Float, b: Float) -> Result:
-    if b == 0.0: return Err("Division by zero")
-    return Ok(a / b)
+// timeout — fail if too slow
+val res = await timeout(fetchFromSlowAPI(), 5000)
+
+// debounce — fire after user stops typing
+val onSearch = debounce(q -> search(q), 300)
+
+// allSettled — collect every outcome without throwing
+val results = await allSettled([fetchUser(), fetchPosts()])
+for r in results:
+    if r.status == "fulfilled": print("ok: {r.value}")
+    else: print("err: {r.reason}")
 ```
 
 ---
 
 ## `flux check` — Type Checker
 
-Perintah `flux check` menjalankan tiga lapisan:
-
-1. **Syntax check** — pastikan kode bisa diparse
-2. **Val immutability** — cegah reassignment `val`
-3. **Type checker** — periksa tipe annotations, return types, interface implementations, dan type narrowing
+`flux check` runs three layers:
 
-### Contoh Output
+1. **Syntax check** — ensure code is parseable
+2. **Val immutability** — prevent reassignment of `val`
+3. **Type checker** — validate type annotations, return types, interface implementations, and type narrowing
 
 ```
 $ flux check app.flux
@@ -792,251 +1197,138 @@ $ flux check app.flux
 
   [TypeError]:28:1  Class 'Cat' does not implement method 'area()' required by interface 'Shape'
              hint: Add 'fn area()' to the class
-
-✗ app.flux — 2 type errors
-  Functions: 5  |  Classes: 2  |  JS output: 47 lines
 ```
 
-### Hal yang Diperiksa
+### What is Checked
 
-| Pemeriksaan                   | Contoh yang ditangkap                                     |
-|-------------------------------|-----------------------------------------------------------|
-| Mismatch tipe variabel        | `val name: String = 42` → error                          |
-| Return type mismatch          | `fn f() -> Int: return "hello"` → error                  |
-| Interface tidak diimplementasi| class tidak punya method yang diwajibkan interface        |
-| Val reassignment              | `val x = 1; x = 2` → error                              |
-| Nullable / union assignability| `val x: Int = null` → error                              |
+| Check | Example caught |
+|---|---|
+| Variable type mismatch | `val name: String = 42` → error |
+| Return type mismatch | `fn f() -> Int: return "hello"` → error |
+| Interface not implemented | class missing a required method |
+| Val reassignment | `val x = 1; x = 2` → error |
+| Nullable assignability | `val x: Int = null` → error |
 
 ---
 
 ## `flux lint` — Linter
 
-Perintah `flux lint` menjalankan **semua** lapisan pemeriksaan `flux check`, ditambah tiga aturan AST-level yang menangkap masalah logika tanpa melihat tipe:
-
-| Lapisan | Aturan | Keparahan |
-|---------|--------|-----------|
-| Syntax  | Parse errors | Error (fatal) |
-| Immutability | Reassignment `val` | Error |
-| Type checker | Mismatch tipe, interface | Error |
-| **unused-var** | `val`/`var` dideklarasi tapi tidak pernah dibaca | Warning |
-| **unreachable** | Statement setelah `return`/`throw`/`break` | Error |
-| **shadow-val** | `val x` di scope dalam menutupi `val x` di scope luar | Warning |
-| Format | File tidak terformat | Warning |
-| Style | Baris terlalu panjang (>120 karakter), TODO/FIXME | Info |
-
-### Perbedaan `flux check` vs `flux lint`
+`flux lint` runs everything `flux check` does, plus three AST-level rules:
 
-| | `flux check` | `flux lint` |
-|-|---|---|
-| Type errors | ✓ | ✓ |
-| Immutability | ✓ | ✓ |
-| **Unused variables** | ✗ | ✓ |
-| **Unreachable code** | ✗ | ✓ |
-| **Variable shadowing** | ✗ | ✓ |
-| Format check | ✗ | ✓ |
-
-### Contoh Output
+| Layer | Rule | Severity |
+|---|---|---|
+| Syntax | Parse errors | Error (fatal) |
+| Immutability | `val` reassignment | Error |
+| Type checker | Type mismatches, interface | Error |
+| **unused-var** | `val`/`var` declared but never read | Warning |
+| **unreachable** | Statement after `return`/`throw`/`break` | Error |
+| **shadow-val** | Inner `val x` hides outer `val x` | Warning |
+| Format | File is not formatted | Warning |
+| Style | Line > 120 chars, TODO/FIXME | Info |
 
 ```
 $ flux lint app.flux
 
-⊛ Linting: app.flux
-
   [E] unreachable:15:5  Unreachable code after 'return'
-         hint: Remove or move the unreachable statement
     15 │     val dead = 99
-       │     ^
 
   [W] unused-var:8:5  'temp' is declared but never used
-         hint: Prefix with '_' (e.g. '_temp') to silence this warning, or remove the declaration
+         hint: Prefix with '_' to silence
      8 │     val temp = calculate()
-       │     ^
 
   [W] shadow-val:22:9  'x' shadows an outer declaration
-         hint: Rename one of the 'x' variables to avoid confusion
     22 │         val x = 0
-       │         ^
 
 ──────────────────────────────────────────────────
-✗ app.flux — 3 issue(s) (45 lines)
-```
-
-### Cara Menonaktifkan Warning Tertentu
-
-Prefiks nama variabel dengan `_` untuk menonaktifkan `unused-var` dan `shadow-val`:
-
-```flux
-val _ignored = sideEffect()   // tidak dilaporkan unused
-fn process(_unused, value):   // param tidak dilaporkan unused
-    return value * 2
-```
-
----
-
-## Bug Fixes & Riwayat Perubahan
-
-### v3.1.1 — Perbaikan Bug (Juni 2026)
-
-Empat bug ditemukan melalui analisis statis dan dibuktikan dengan test sebelum diperbaiki. Semua perubahan diverifikasi dengan suite test penuh (71 test, 0 gagal).
-
----
-
-#### Bug #1 — `codegen.js`: Wildcard arm pertama menghasilkan `else {` tanpa `if`
-
-**Dampak:** `SyntaxError` runtime di JavaScript — kode tidak bisa dijalankan sama sekali.
-
-**Penyebab:** `genMatch` di `src/codegen.js` menghasilkan `else {` untuk arm wildcard, tetapi jika wildcard adalah arm *pertama*, tidak ada `if` sebelumnya → JS tidak valid.
-
-**Sebelum:**
-```javascript
-// Jika wildcard adalah arm pertama, menghasilkan:
-else {        // ← SyntaxError: tidak ada `if` sebelumnya
-  return "matched";
-}
-```
-
-**Sesudah:** Ditambahkan flag `hasOpenIf` — arm wildcard pertama menghasilkan `if (true) {` sehingga JS tetap valid.
-
-```flux
-// Kode Flux ini sekarang berfungsi benar:
-fn classify(x):
-    match x:
-        when _ -> "default"
-        when 1 -> "one"
-```
-
----
-
-#### Bug #2 — `stdlib.js`: `truncate` menghasilkan string terlalu panjang jika suffix ≥ len
-
-**Dampak:** Hasil `truncate` melebihi panjang yang diminta.
-
-**Penyebab:** `slice(0, len - suffix.length)` menghasilkan indeks negatif jika `suffix.length >= len`, yang diinterpretasi JavaScript sebagai `slice(0, negatif)` → mengembalikan karakter dari akhir string alih-alih awal.
-
-**Sebelum:**
-```javascript
-return str.slice(0, len - suffix.length) + suffix;
-// truncate("hello world", 3, "......") → hasil > 3 karakter ❌
+✗ app.flux — 3 issue(s)
 ```
 
-**Sesudah:** Ditambahkan guard — jika `suffix.length >= len`, kembalikan `suffix.slice(0, len)`:
-```javascript
-const cut = len - suffix.length;
-if (cut <= 0) return suffix.slice(0, len);
-return str.slice(0, cut) + suffix;
-// truncate("hello world", 3, "......") → "..." (3 karakter) ✓
-```
-
----
-
-#### Bug #3 — `parser.js`: `(a, b, c)` tanpa `->` diam-diam membuang nilai
+Prefix any name with `_` to suppress `unused-var` and `shadow-val`:
 
-**Dampak:** Nilai di posisi 1, 2, ... dalam ekspresi kurung banyak diam-diam hilang tanpa pesan error apapun — sangat sulit di-debug.
-
-**Penyebab:** Parser membangun `items[]` dari ekspresi berkoma di dalam `(...)`, tetapi jika tidak ada `->` (bukan lambda), ia mengembalikan `items[0]` saja.
-
-**Sebelum:**
 ```flux
-val x = (10, 20, 30)
-// Dikompilasi menjadi: const x = 10;  ← 20 dan 30 hilang diam-diam
-```
-
-**Sesudah:** Jika `items.length > 1` tanpa `->`, ParseError yang jelas dilempar:
-```
-ParseError: Unexpected comma in expression — did you mean a lambda?
-  Write (p0, p1, p2) -> expr
+val _ignored = sideEffect()
+fn process(_unused, value): return value * 2
 ```
 
 ---
 
-#### Bug #4 — `parser.js`: Auto-index enum tidak direset setelah nilai eksplisit
-
-**Dampak:** Member enum setelah nilai eksplisit mendapat indeks yang salah.
-
-**Penyebab:** `autoIndex` hanya dimulai dari 0 dan naik +1, tanpa pernah mengambil nilai dari assignment eksplisit `member = N`.
-
-**Sebelum:**
-```flux
-enum Color:
-    Red          // 0 ✓
-    Green = 10   // 10 ✓
-    Blue         // 2 ❌ (seharusnya 11)
-```
-
-**Sesudah:** Setelah nilai eksplisit `N`, `autoIndex` diatur ke `N` sehingga member berikutnya mendapat `N + 1`:
-```flux
-enum Color:
-    Red          // 0 ✓
-    Green = 10   // 10 ✓
-    Blue         // 11 ✓
-```
-
----
-
-#### Regresi
-
-Semua 4 perbaikan diverifikasi tidak merusak test yang ada:
-
-| Suite | Test | Hasil |
-|-------|------|-------|
-| `01_basics` — `09_ts_compat` | 53 test | ✅ Semua lulus |
-| `10_bugfixes` (baru) | 18 test | ✅ Semua lulus |
-| `prove_bugs.js` (bukti bug) | 7 test | ✅ Semua lulus |
-
----
-
-## Arsitektur Transpiler
+## Transpiler Architecture
 
 ```
 Flux Source (.flux)
     │
     ▼
-[CSS Preprocessor]     css`...` → string template
+[CSS Preprocessor]     css{} / css`...` → string template
     │
     ▼
-[JSX Preprocessor]     <div>...</div> → createElement(...)
+[JSX Preprocessor]     <div>...</div>   → createElement(...)
     │
     ▼
-[Lexer]                Source → Token stream
+[Lexer]                Source           → Token stream
     │
     ▼
-[Parser]               Tokens → AST (Abstract Syntax Tree)
+[Parser]               Tokens           → AST (Abstract Syntax Tree)
     │
     ├──▶ [Val Checker]      AST → immutability errors
     │
     ├──▶ [Type Checker]     AST → type errors & warnings
     │
     ▼
-[Code Generator]       AST → JavaScript output
+[Code Generator]       AST             → JavaScript output
     │
     ▼
-JavaScript (.js)       Siap dijalankan di Node.js / browser
+JavaScript (.js)       Ready to run in Node.js / browser
+```
+
+---
+
+## Self-Hosting
+
+Flux v3 is **100% self-hosted** — the compiler is written in Flux itself. The canonical source lives in `src/self/`:
+
+```
+src/self/lexer.flux          → compiled → src/lexer.js
+src/self/parser.flux         → compiled → src/parser.js
+src/self/codegen.flux        → compiled → src/codegen.js
+src/self/type-checker.flux   → compiled → src/type-checker.js
+src/self/transpiler.flux     → compiled → src/transpiler.js
+...
 ```
 
+Bootstrap the self-hosted compiler:
+
+```bash
+node scripts/bootstrap.js
+```
+
+This compiles all `.flux` source files into their `.js` counterparts using the existing JS stage of the compiler.
+
 ---
 
-## Perbedaan dengan TypeScript
-
-| Fitur                    | TypeScript         | Flux Lang                       |
-|--------------------------|--------------------|---------------------------------|
-| Sintaks                  | C-style `{}`       | Indentasi (Python-style)        |
-| Type annotations         | `x: string`        | `x: String`                     |
-| Return type              | `(): string {}`    | `() -> String:`                 |
-| Union types              | `string \| number` | `String \| Int`                 |
-| Nullable                 | `string \| null`   | `String?`                       |
-| Pattern matching         | Tidak ada          | `match / when`                  |
-| ADT                      | Tidak ada          | `type Result = Ok(v) \| Err(e)` |
-| Pipe operator            | Tidak ada          | `\|>` (F# style)               |
-| Template strings         | `` `${x}` ``       | `"{x}"`                         |
-| Format spec              | Tidak ada          | `"{n:.2f}"`, `"{n:,}"`         |
-| Val (immutable)          | `const`            | `val`                           |
-| Var (mutable)            | `let`              | `var`                           |
-| npm interop              | Ya                 | Ya (100% kompatibel)            |
-| Transpiler output        | `.js`              | `.js`                           |
+## Differences from TypeScript
+
+| Feature | TypeScript | Flux Lang |
+|---|---|---|
+| Syntax | C-style `{}` blocks | Indentation (Python-style) |
+| Type annotations | `x: string` | `x: String` |
+| Return type | `(): string {}` | `() -> String:` |
+| Union types | `string \| number` | `String \| Int` |
+| Nullable | `string \| null` | `String?` |
+| Pattern matching | none | `match / when` |
+| ADT | none | `type Result = Ok(v) \| Err(e)` |
+| Pipe operator | none | `\|>` (F# style) |
+| Template strings | `` `${x}` `` | `"{x}"` |
+| Format specs | none | `"{n:.2f}"`, `"{n:,}"` |
+| Decorators | `@decorator` (experimental) | `@decorator` (stable) |
+| Private fields | `#field` (manual) | `private var field` → `#field` |
+| Immutable binding | `const` | `val` |
+| Mutable binding | `let` | `var` |
+| npm interop | Yes | Yes (100% compatible) |
+| Output | `.js` | `.js` |
 
 ---
 
-## Contoh Lengkap — Server HTTP
+## Full Example — HTTP Server
 
 ```flux
 import express from 'express'
@@ -1044,8 +1336,8 @@ import express from 'express'
 type Result = Ok(data) | Err(message)
 
 interface User:
-    id: Int
-    name: String
+    id:    Int
+    name:  String
     email: String
 
 fn validateEmail(email: String) -> Bool:
@@ -1053,13 +1345,13 @@ fn validateEmail(email: String) -> Bool:
 
 fn createUser(id: Int, name: String, email: String) -> Result:
     if !validateEmail(email):
-        return Err("Email tidak valid: {email}")
+        return Err("Invalid email: {email}")
     return Ok({ id, name, email })
 
 val app = express()
 app.use(express.json())
 
-var users = []
+var users: Array<User> = []
 
 app.post("/users", fn(req, res):
     val { id, name, email } = req.body
@@ -1078,12 +1370,38 @@ app.get("/users", fn(req, res):
 )
 
 app.listen(3000, fn():
-    print("Server Flux berjalan di port 3000")
+    print("Flux server running on port 3000")
 )
 ```
 
 ---
 
-## Lisensi
+## Changelog
+
+### v3.2.0 — June 2026
+- **Decorators** — `@name` and `@name(args)` on `fn` and `class`
+- **Private fields** — `private var x` → JS `#x` syntax
+- **+58 stdlib functions** — array extras, math, objects, strings, type checks, async, functional
+- **Tree-shaking** — stdlib injects only what's used in each compiled file
+- Transpiler version header bumped to v3.2.0
+
+### v3.1.0 — June 2026
+- Multiline arrow block bodies
+- `for..of` loops, computed property keys
+- Class getter / setter, labeled break / continue
+- For-loop array destructuring
+- esbuild bundle (`dist/flux.cjs.js`, `dist/flux.esm.js`, `dist/flux.min.js`)
+- Test suite: 81 tests across 11 files
+
+### v3.0.0 — June 2026
+- TypeScript-parity type system
+- Self-hosting (compiler written in Flux)
+- Pattern matching, ADT, enums
+- Pipe operator, JSX, CSS preprocessor
+- `flux check`, `flux lint`, `flux fmt`
+
+---
+
+## License
 
-MIT — Flux Lang v3.0.0
+MIT © Flux Lang Contributors