lt-script 1.0.3 → 1.0.5

package/README.md

@@ -6,269 +6,561 @@
   <img src="https://img.shields.io/badge/FiveM-Ready-green" alt="FiveM Ready">
 </p>
 
-**LT** is a modern, developer-friendly language that compiles to FiveM Lua. It brings TypeScript-like syntax, modern JavaScript features, and FiveM-specific sugar to the Lua ecosystem — making your scripts cleaner, safer, and more enjoyable to write.
+**LT** is a modern, statically-typed superset of Lua designed specifically for **FiveM development**. It combines the elegance of TypeScript with the performance of Lua, adding FiveM-specific syntactic sugar to make your scripts robust, readable, and faster to write.
+
+> **Goodbye boilerplate, hello productivity.**  
+> Write clean, type-safe code that compiles to optimized 100% vanilla Lua.
+
+---
 
 ## ✨ Why LT?
 
-Writing vanilla Lua for FiveM can be tedious. LT fixes that with:
+*   **🛡️ Type Safety**: Catch type mismatches and `nil` errors *before* you run the game.
+*   **⚡ Modern Syntax**: Use Arrow Functions, Destructuring, Spread syntax, and more.
+*   **🎮 FiveM-First**: Built-in keywords like `netevent`, `addcmd`, `thread`, and `wait`.
+*   **🔌 Zero Overhead**: Compiles to pure, readable Lua with no runtime dependencies.
 
-- **Modern Syntax**: Arrow functions, destructuring, spread operator, optional chaining
-- **FiveM Sugar**: Built-in `thread`, `wait`, `netevent`, `addcmd`, `export` keywords
-- **Type Safety**: Static type checking catches errors at compile time
-- **Clean Code**: No more boilerplate — just write what you mean
+---
 
 ## 📦 Installation
 
+Prerequisites: [Node.js](https://nodejs.org/) (Version 16+)
+
 ```bash
+# Global installation (Recommended)
 npm install -g lt-script
+
+# OR run directly via npx
+npx lt-script build .
 ```
 
+---
+
 ## 🚀 Quick Start
 
-Create a file called `main.lt`:
+Create a `client.lt` file:
 
 ```typescript
-// Variables with modern scoping
-let health: number = 100
-const MAX_HEALTH = 200
+// Define a type for player data
+interface PlayerData {
+    id: number,
+    name: string,
+    health: number
+}
 
-// Arrow functions
-let double = (x) => x * 2
+// Variables with types
+let active: boolean = false
+const MAX_HEALTH = 100
 
-// String interpolation
-print("Health: $health / $MAX_HEALTH")
+// FiveM Command
+addcmd "heal" (source, args)
+    let amount = tonumber(args[1]) ?? MAX_HEALTH
+    SetEntityHealth(PlayerPedId(), amount)
+    print("Healed for ${amount}")
+end
 
-// FiveM thread with wait
+// Thread with loop
 thread
+    print("System active")
     loop (true)
         wait 1000
-        print("Tick...")
+        if LocalPlayer.state?.isDead then
+            print("Player is dead!")
+        end
     end
 end
-
-// Register a command easily
-addcmd "heal" (source, args)
-    health = MAX_HEALTH
-    print("Player healed!")
-end
-
-// Network events without boilerplate
-netevent "player:spawn" (data)
-    print("Player spawned: $data")
-end
 ```
 
-Compile it:
-
+**Compile it:**
 ```bash
 ltc build .
 ```
 
-Output `main.lua`:
-```lua
-local health = 100
-local MAX_HEALTH <const> = 200
+---
 
-local double = function(x) return x * 2 end
+## 📘 Language Reference
 
-print("Health: " .. tostring(health) .. " / " .. tostring(MAX_HEALTH))
+### 1. Variables & Types
 
-CreateThread(function()
-    while true do
-        Wait(1000)
-        print("Tick...")
-    end
-end)
+LT supports explicit typing with compile-time validation.
 
-RegisterCommand("heal", function(source, args)
-    health = MAX_HEALTH
-    print("Player healed!")
-end, false)
-
-RegisterNetEvent("player:spawn")
-AddEventHandler("player:spawn", function(data)
-    print("Player spawned: " .. tostring(data))
-end)
+```typescript
+// Mutable variables
+let score: number = 0
+var playerName: string = "John"     // Type inferred if omitted
+
+// Constants (Compiles to Lua 5.4 <const>)
+const MAX_PLAYERS = 32
+
+// Available primitive types
+let str: string = "hello"
+let num: number = 42
+let flag: boolean = true
+let data: table = { key: "value" }
+let pos: vector3 = <100.0, 200.0, 30.0>
+let callback: function = () => print("hi")
+
+// Arrays
+let inventory: string[] = ["Apple", "Water"]
+let numbers: number[] = [1, 2, 3]
 ```
 
-## 🛠️ CLI Commands
+### 2. Interfaces & Type Aliases
 
-| Command | Description |
-|---------|-------------|
-| `ltc build <dir>` | Compile all `.lt` files in directory |
-| `ltc watch <dir>` | Watch mode — auto-compile on save |
+Define complex data structures for compile-time validation.
 
-## 🎯 Feature Highlights
-
-### Variables & Constants
 ```typescript
-var globalVar = "I am global"     // Global variable
-let localVar = 10                 // Local variable
-const MAX = 100                   // Constant (Lua 5.4 <const>)
-```
+// Interface - Object shape definition
+interface VehicleConfig {
+    model: string,
+    price: number,
+    color: string
+}
 
-### Type System
-```typescript
-// Explicit types
-let name: string = "John"
-let age: number = 25
-let active: boolean = true
+// Type Alias - Alternative syntax
+type PlayerPos = { x: number, y: number, z: number }
 
-// Type Aliases
-interface PlayerData = {
-    name: string,
-    level: number,
-    isVip: boolean
+// Usage with validation
+const myCar: VehicleConfig = {
+    model: "sultan",
+    price: 50000,
+    color: "red"
 }
 
-func Calculate(a: number, b: number)
-    return a + b
-end
-```
+// Arrays of interfaces
+interface StoreConfig {
+    id: number,
+    position: vector3,
+    isOpen: boolean
+}
 
-### Arrow Functions
-```typescript
-let add = (a, b) => a + b
-let greet = (name) => print("Hello, $name!")
+const Stores: StoreConfig[] = [
+    { id: 1, position: <100.0, 200.0, 30.0>, isOpen: true },
+    { id: 2, position: <150.0, 250.0, 35.0>, isOpen: false }
+]
 ```
 
-### Destructuring
+> **Note:** Type validation ensures field types match. Assigning `number` to a `vector3` field will cause a compile error.
+
+### 3. Functions
+
 ```typescript
-let player = { name: "Alex", level: 50 }
-let { name, level } = player
+// Standard function with typed parameters
+func Add(a: number, b: number)
+    return a + b
+end
+
+// Default parameters
+func Greet(name: string, prefix = "Hello")
+    print("${prefix}, ${name}!")
+end
+
+// Local function (Lua local function)
+local function PrivateHelper()
+    return "internal"
+end
 
-let coords = [100, 200, 300]
-let [x, y, z] = coords
+// Arrow functions
+let double = (x: number) => x * 2
+let greet = (name) => print("Hello ${name}")
+
+// Multi-line arrow
+let process = (data) => {
+    let result = data * 2
+    return result
+}
 ```
 
-### Optional Chaining & Null Coalescing
+### 4. Control Flow
+
+#### If / Else
 ```typescript
-let job = player?.metadata?.job?.label ?? "Unemployed"
+// Note: 'then' keyword is required after condition
+if health < 20 then
+    print("Low health!")
+elseif health < 50 then
+    print("Medium health")
+else
+    print("Full health")
+end
 ```
 
-### Vector Literals
+#### Switch / Case
 ```typescript
-let pos = <100.0, 50.0, 20.0>   // vector3
-let rot = <0.0, 90.0>           // vector2
+let job = "police"
+
+switch job
+    case "police", "ambulance"
+        print("Government worker")
+    case "mechanic"
+        print("Service worker")
+    default
+        print("Civilian")
+end
 ```
 
-### Switch/Case
+#### Guard Clauses
+Clean up nested if-statements with early returns.
+
 ```typescript
-switch weather
-    case "RAIN", "THUNDER"
-        print("Stay inside!")
-    case "CLEAR"
-        print("Nice day!")
-    default
-        print("Unknown weather")
+func RevivePlayer(player)
+    // Returns immediately if player is nil
+    guard player return
+    
+    // Returns with custom logic if condition fails
+    guard player.isDead else
+        print("Player is already alive")
+        return
+    end
+
+    // Main logic
+    player.revive()
+end
+
+// Guard with return value
+func GetPlayer(id)
+    let player = GetPlayerById(id)
+    guard player return nil
+    return player
 end
 ```
 
-### For Loops
+#### For Loops
 ```typescript
-// Range loop
-for i in 1..10 do
+// Numeric for (start, end)
+for i = 1, 10 do
     print(i)
 end
 
-// Range with step
-for i in 10..1 by -1 do
+// Numeric for with step (start, end, step)
+for i = 0, 100, 5 do
     print(i)
 end
 
-// C-style loop
-for i = 0, 100, 5 do
+// Range for with step
+for i in 1..10 by 2 do
     print(i)
 end
+
+// For-in (pairs)
+for key, value in pairs(myTable) do
+    print("${key}: ${value}")
+end
+
+// For-in (ipairs)
+for index, item in ipairs(myArray) do
+    print("${index}: ${item}")
+end
+```
+
+#### While Loop
+```typescript
+let count = 0
+while count < 10 do
+    print(count)
+    count += 1
+end
+```
+
+### 5. Modern Operators
+
+#### Compound Assignment
+```typescript
+let x = 10
+x += 5
+x -= 3
+x *= 2
+x /= 4
+x %= 3
+```
+
+#### Null Coalescing (`??`)
+```typescript
+let name = playerName ?? "Unknown"
+let health = GetHealth() ?? 100
 ```
 
-### FiveM Specific
+#### Optional Chaining (`?.`)
+```typescript
+let state = LocalPlayer.state?.isDead
+let nested = obj?.deep?.value
+let arrItem = arr?[0]
+```
+
+#### Ternary Operator
+```typescript
+let status = isDead ? "Dead" : "Alive"
+let label = count > 0 ? "${count} items" : "Empty"
+```
+
+### 6. Destructuring & Spread
+
+```typescript
+// Object Destructuring
+let { x, y, z } = GetEntityCoords(ped)
+let { name, health } = playerData
+
+// Array Destructuring
+let [first, second] = GetValues()
+
+// Object Spread (tables only)
+let base = { a: 1, b: 2 }
+let extended = { ...base, c: 3 }
+```
+
+### 7. String Interpolation
+
+Use `${expression}` inside strings to embed values:
+
+```typescript
+let name = "John"
+let age = 25
+
+print("Hello, ${name}!")
+print("You are ${age} years old")
+print("Next year you'll be ${age + 1}")
+
+// Complex expressions
+let player = { health: 100 }
+print("Health: ${player.health}")
+```
+
+### 8. Vector Literals
+
+```typescript
+// Vector3 (FiveM native)
+let pos: vector3 = <100.0, 200.0, 30.0>
+
+// Vector2
+let screenPos: vector2 = <0.5, 0.5>
+
+// Vector4 (includes heading)
+let spawn: vector4 = <100.0, 200.0, 30.0, 90.0>
+```
+
+---
+
+## 🎮 FiveM Features
+
+### Thread & Loop
 
-#### Threads & Wait
 ```typescript
+// Create a thread (Citizen.CreateThread)
 thread
-    wait 1000
-    print("After 1 second")
+    print("Thread started")
+    
+    loop (true)
+        wait 0  // Run every frame
+        
+        // Game logic here
+        let ped = PlayerPedId()
+        let health = GetEntityHealth(ped)
+        
+        if health < 50 then
+            print("Low health warning!")
+        end
+    end
 end
 ```
 
-#### Events
+### Wait
+
 ```typescript
-netevent "myResource:sync" (data)
-    -- RegisterNetEvent + AddEventHandler
+// Wait in milliseconds
+wait 1000           // Wait 1 second
+wait 0              // Yield one frame
+```
+
+### Network Events
+
+```typescript
+// Register + Handle network event (Client <-> Server)
+netevent "bank:deposit" (amount)
+    print("Depositing ${amount}")
+    UpdateBankBalance(amount)
 end
 
-event "localEvent" (data)
-    -- AddEventHandler only
+// Local event handler
+event "onClientResourceStart" (resName)
+    guard resName == GetCurrentResourceName() return
+    print("Resource started!")
 end
 ```
 
-#### Commands
+### Emit Events
+
+```typescript
+// Emit to server
+emit "server:event:name" (arg1, arg2)
+
+// Explicit emit variants
+emitServer "myevent" (data)
+emitClient "myevent" (targetPlayer, data)
+```
+
+### Commands
+
 ```typescript
+// Register a command (RegisterCommand wrapper)
 addcmd "teleport" (source, args)
-    print("Teleporting...")
+    let x = tonumber(args[1]) ?? 0
+    let y = tonumber(args[2]) ?? 0
+    let z = tonumber(args[3]) ?? 0
+    
+    SetEntityCoords(PlayerPedId(), x, y, z)
+    print("Teleported to ${x}, ${y}, ${z}")
 end
 ```
 
-#### Exports
+### Exports
+
 ```typescript
-export func GetPlayerData(id)
-    return players[id]
+// Export a function
+export "GetPlayerMoney" ()
+    return playerMoney
 end
 ```
 
-#### Guard Statements
+### Timeout & Interval
+
 ```typescript
-guard player return              // Early return if nil/false
-guard player.job == "police" return print("Access denied")
+// Run once after delay
+timeout 5000
+    print("5 seconds passed!")
+end
 
-// Guard with else block
-guard isValid else
-    print("Invalid state")
-    return
+// Run repeatedly
+interval 1000
+    print("Every second")
 end
 ```
 
-#### Try/Catch
+### Try / Catch
+
 ```typescript
 try
-    riskyOperation()
+    RiskyOperation()
 catch err
-    print("Error: $err")
+    print("Error: ${err}")
+end
+```
+
+---
+
+## ⚡ Complete Example: Store Robbery System
+
+```typescript
+// 1. Type Definition
+interface StoreConfig {
+    id: number,
+    position: vector3,
+    reward: number,
+    isOpen: boolean
+}
+
+// 2. Configuration
+const Stores: StoreConfig[] = [
+    { id: 1, position: <120.5, -500.2, 30.0>, reward: 5000, isOpen: true },
+    { id: 2, position: <250.0, 300.0, 25.0>, reward: 10000, isOpen: true }
+]
+
+let isRobbing = false
+
+// 3. Main Game Loop
+thread
+    loop (true)
+        wait 0
+        
+        if isRobbing then
+            break
+        end
+        
+        let ped = PlayerPedId()
+        let pos = GetEntityCoords(ped)
+        
+        for _, store in ipairs(Stores) do
+            if not store.isOpen then
+                break
+            end
+            
+            let distance = #(pos - store.position)
+            if distance < 2.0 then
+                ShowHelpText("Press ~INPUT_CONTEXT~ to rob")
+                
+                if IsControlJustPressed(0, 38) then
+                    StartRobbery(store)
+                end
+            end
+        end
+    end
+end
+
+// 4. Robbery Function
+func StartRobbery(store: StoreConfig)
+    isRobbing = true
+    
+    // Notify server
+    emit "robbery:start" (store.id)
+    
+    // Play animation
+    TaskPlayAnim(PlayerPedId(), "anim_dict", "anim_name", 8.0, -8.0, -1, 0, 0, false, false, false)
+    
+    wait 5000
+    
+    ClearPedTasks(PlayerPedId())
+    isRobbing = false
+    
+    print("Robbery complete! Reward: ${store.reward}")
+end
+
+// 5. Server Sync Handler
+netevent "robbery:sync" (storeId, newState)
+    let store = Stores.find(s => s.id == storeId)
+    guard store return
+    
+    store.isOpen = newState
+    let stateStr = newState ? "open" : "closed"
+    print("Store ${storeId} is now ${stateStr}")
 end
 ```
 
-## 📁 Project Structure
+---
+
+## 🛠️ CLI Reference
+
+| Command | Usage | Description |
+|:--------|:------|:------------|
+| **Build** | `ltc build ./` | Compiles all `.lt` files in the folder to `.lua` |
+| **Watch** | `ltc watch ./` | Watches for file changes and recompiles instantly |
+| **Version** | `ltc -v` | Displays the current compiler version |
+
+### Project Structure
+
+LT automatically detects `src/` folders:
 
 ```
 my-resource/
 ├── src/
 │   ├── client.lt
 │   └── server.lt
-├── client.lua        (generated)
-├── server.lua        (generated)
-└── fxmanifest.lua
+├── client.lua      ← Generated
+└── server.lua      ← Generated
 ```
 
-Run `ltc watch .` in your resource folder for automatic compilation.
+---
 
 ## 🔧 VS Code Extension
 
-Get syntax highlighting and IntelliSense for `.lt` files:
-
-**[LT Language Extension](https://marketplace.visualstudio.com/items?itemName=laot.lt-language)**
-
-- Syntax Highlighting
-- IntelliSense for Variables & Functions
-- **Native FiveM Autocompletion** (GetHashKey, CreateVehicle, etc.)
-- Snippets for common patterns
-
-## 📜 License
+Get the official **[LT Language Extension](https://marketplace.visualstudio.com/items?itemName=laot.lt-language)** for the best experience.
 
-MIT © [LaotScripts](https://github.com/laot7490)
+**Features:**
+*   🎨 Full Syntax Highlighting
+*   🔍 Intelligent Autocompletion
+*   📦 **FiveM Native Intellisense**
+*   ✨ Real-time Error Checking
 
 ---
 
 <p align="center">
-  Made with ❤️ for the FiveM community
+    Made with ❤️ for the FiveM Community by <b>LaotScripts</b>
 </p>

package/dist/compiler/codegen/LuaEmitter.js

@@ -149,6 +149,7 @@ export class LuaEmitter {
                 this.emitCommandStmt(stmt);
                 break;
             case AST.NodeType.TypeDecl:
+            case AST.NodeType.TypeAliasDecl:
                 // Type declarations are compile-time only, no Lua output
                 break;
             default:

package/dist/compiler/parser/AST.d.ts

@@ -29,6 +29,7 @@ export declare enum NodeType {
     EventHandler = "EventHandler",
     ExportDecl = "ExportDecl",
     TypeDecl = "TypeDecl",
+    TypeAliasDecl = "TypeAliasDecl",
     BinaryExpr = "BinaryExpr",
     UnaryExpr = "UnaryExpr",
     UpdateExpr = "UpdateExpr",// ++, --
@@ -93,6 +94,11 @@ export interface TypeDecl extends Statement {
     name: Identifier;
     fields: TypeField[];
 }
+export interface TypeAliasDecl extends Statement {
+    kind: NodeType.TypeAliasDecl;
+    name: Identifier;
+    type: string;
+}
 export interface AssignmentStmt extends Statement {
     kind: NodeType.AssignmentStmt;
     targets: Expression[];

package/dist/compiler/parser/AST.js

@@ -35,6 +35,7 @@ export var NodeType;
     NodeType["ExportDecl"] = "ExportDecl";
     // Type System
     NodeType["TypeDecl"] = "TypeDecl";
+    NodeType["TypeAliasDecl"] = "TypeAliasDecl";
     // Expressions
     NodeType["BinaryExpr"] = "BinaryExpr";
     NodeType["UnaryExpr"] = "UnaryExpr";

package/dist/compiler/parser/Parser.d.ts

@@ -10,6 +10,8 @@ export declare class Parser {
     constructor(tokens: Token[]);
     parse(): AST.Program;
     private parseStatement;
+    private parseType;
+    private parseTypeAlias;
     private parseVariableDecl;
     private parseIfStmt;
     private parseForStmt;

package/dist/compiler/parser/Parser.js

@@ -19,6 +19,18 @@ export class Parser {
     }
     // ============ Statement Parsing ============
     parseStatement() {
+        // Ambiguity Check: 'type' Identifier = ... VS type(x)
+        if (this.at().type === TokenType.IDENTIFIER && this.at().value === 'type') {
+            // Lookahead to see if it's a declaration
+            const next = this.tokens[this.pos + 1];
+            if (next && next.type === TokenType.IDENTIFIER) {
+                const nextNext = this.tokens[this.pos + 2];
+                if (nextNext && nextNext.type === TokenType.EQUALS) {
+                    this.eat(); // consume 'type' pseudo-keyword
+                    return this.parseTypeAlias();
+                }
+            }
+        }
         switch (this.at().type) {
             case TokenType.VAR:
             case TokenType.LET:
@@ -77,6 +89,65 @@ export class Parser {
                 return this.parseExpressionStatement();
         }
     }
+    // ============ Type Parsing ============
+    parseType() {
+        // If we're parsing a type and hit a '{', it's an object type literal: value: { a: number }
+        if (this.at().type === TokenType.LBRACE) {
+            this.eat(); // {
+            let typeBody = "{ ";
+            while (!this.check(TokenType.RBRACE) && !this.isEOF()) {
+                const key = this.parseIdentifier().name;
+                let val = "any";
+                // Check for optional property
+                if (this.match(TokenType.QUESTION)) {
+                    key + "?";
+                }
+                if (this.match(TokenType.COLON)) {
+                    val = this.parseType();
+                }
+                typeBody += `${key}: ${val}`;
+                if (!this.check(TokenType.RBRACE)) {
+                    this.match(TokenType.COMMA) || this.match(TokenType.SEMICOLON);
+                    typeBody += ", ";
+                }
+            }
+            this.expect(TokenType.RBRACE);
+            typeBody += " }";
+            // Handle array of objects: { ... }[]
+            while (this.match(TokenType.LBRACKET)) {
+                this.expect(TokenType.RBRACKET);
+                typeBody += "[]";
+            }
+            return typeBody;
+        }
+        const typeToken = this.eat();
+        let typeName = typeToken.value;
+        // Handle generic types: List<string> (Basic support)
+        if (this.match(TokenType.LT_ANGLE)) { // <
+            typeName += "<";
+            typeName += this.parseType();
+            while (this.match(TokenType.COMMA)) {
+                typeName += ", ";
+                typeName += this.parseType();
+            }
+            this.expect(TokenType.GT_ANGLE); // >
+            typeName += ">";
+        }
+        // Handle array types: string[] or string[][]
+        while (this.match(TokenType.LBRACKET)) {
+            this.expect(TokenType.RBRACKET);
+            typeName += "[]";
+        }
+        return typeName;
+    }
+    parseTypeAlias() {
+        // 'type' is already consumed or handled by caller
+        const name = this.parseIdentifier();
+        this.expect(TokenType.EQUALS);
+        const typeStr = this.parseType();
+        return { kind: AST.NodeType.TypeAliasDecl, name, type: typeStr };
+    }
+    // ============ Statement Parsing ============
     parseVariableDecl() {
         const scopeToken = this.eat();
         const scope = scopeToken.value;
@@ -105,12 +176,12 @@ export class Parser {
         };
         names.push(parseName());
         if (this.match(TokenType.COLON)) {
-            typeAnnotations[0] = this.eat().value;
+            typeAnnotations[0] = this.parseType();
         }
         while (this.match(TokenType.COMMA)) {
             names.push(parseName());
             if (this.match(TokenType.COLON)) {
-                typeAnnotations[names.length - 1] = this.eat().value;
+                typeAnnotations[names.length - 1] = this.parseType();
             }
         }
         let values;
@@ -376,7 +447,7 @@ export class Parser {
         this.expect(TokenType.RPAREN);
         let returnType;
         if (this.match(TokenType.COLON)) {
-            returnType = this.eat().value;
+            returnType = this.parseType();
         }
         const body = this.parseBlockUntil(TokenType.END);
         this.expect(TokenType.END);
@@ -399,7 +470,7 @@ export class Parser {
         this.expect(TokenType.RPAREN);
         let returnType;
         if (this.match(TokenType.COLON)) {
-            returnType = this.eat().value;
+            returnType = this.parseType();
         }
         const body = this.parseBlockUntil(TokenType.END);
         this.expect(TokenType.END);
@@ -460,13 +531,12 @@ export class Parser {
     parseTypeDecl() {
         this.eat(); // interface
         const name = this.parseIdentifier();
-        this.expect(TokenType.EQUALS);
         this.expect(TokenType.LBRACE);
         const fields = [];
         while (!this.check(TokenType.RBRACE) && !this.isEOF()) {
             const fieldName = this.parseIdentifier().name;
             this.expect(TokenType.COLON);
-            const fieldType = this.eat().value; // Get the type as string
+            const fieldType = this.parseType(); // Get the type as string
             fields.push({ name: fieldName, type: fieldType });
             // Allow trailing comma
             if (!this.check(TokenType.RBRACE)) {
@@ -913,7 +983,7 @@ export class Parser {
         const name = this.parseIdentifierName();
         let typeAnnotation;
         if (this.match(TokenType.COLON)) {
-            typeAnnotation = this.eat().value;
+            typeAnnotation = this.parseType();
         }
         let defaultValue;
         if (this.match(TokenType.EQUALS)) {

package/dist/compiler/semantics/SemanticAnalyzer.d.ts

@@ -3,7 +3,9 @@ export declare class SemanticAnalyzer {
     private globalScope;
     private currentScope;
     private typeRegistry;
+    private typeAliasRegistry;
     private memberTypes;
+    private functionRegistry;
     analyze(program: AST.Program): void;
     private enterScope;
     private exitScope;
@@ -18,6 +20,9 @@ export declare class SemanticAnalyzer {
     private visitExpression;
     private inferType;
     private stringToType;
+    private visitTypeAliasDecl;
     private visitTypeDecl;
+    private validateTypeExists;
     private validateTableAgainstType;
+    private parseObjectLiteralType;
 }

package/dist/compiler/semantics/SemanticAnalyzer.js

@@ -23,14 +23,31 @@ class Scope {
 export class SemanticAnalyzer {
     globalScope = new Scope();
     currentScope = this.globalScope;
-    typeRegistry = new Map();
-    memberTypes = new Map(); // Tracks Table.Field -> type mapping
+    typeRegistry = new Map(); // Stores interface fields
+    typeAliasRegistry = new Map(); // Stores type alias strings
+    memberTypes = new Map(); // Tracks Table.Field -> type mappings
+    functionRegistry = new Map(); // Stores function signatures
     analyze(program) {
         // Reset scope for fresh analysis (though typically instance is fresh)
         this.currentScope = this.globalScope;
-        // Visit all statements
+        this.typeRegistry.clear();
+        this.typeAliasRegistry.clear();
+        this.memberTypes.clear();
+        this.functionRegistry.clear();
+        // First pass: Register types (to allow forward references)
         for (const stmt of program.body) {
-            this.visitStatement(stmt);
+            if (stmt.kind === AST.NodeType.TypeDecl) {
+                this.visitTypeDecl(stmt);
+            }
+            else if (stmt.kind === AST.NodeType.TypeAliasDecl) {
+                this.visitTypeAliasDecl(stmt);
+            }
+        }
+        // Second pass: Analyze code
+        for (const stmt of program.body) {
+            if (stmt.kind !== AST.NodeType.TypeDecl && stmt.kind !== AST.NodeType.TypeAliasDecl) {
+                this.visitStatement(stmt);
+            }
         }
     }
     enterScope() {
@@ -117,6 +134,29 @@ export class SemanticAnalyzer {
                     this.exitScope();
                 }
                 break;
+            case AST.NodeType.EventHandler:
+                {
+                    const s = stmt;
+                    this.enterScope();
+                    s.params.forEach(p => this.currentScope.define(p.name.name, 'param', 'any', s.line || 0));
+                    this.visitBlock(s.body);
+                    this.exitScope();
+                }
+                break;
+            case AST.NodeType.TryCatchStmt:
+                {
+                    const s = stmt;
+                    this.visitBlock(s.tryBody);
+                    this.enterScope();
+                    this.currentScope.define(s.catchParam.name, 'let', 'any', s.line || 0);
+                    this.visitBlock(s.catchBody);
+                    this.exitScope();
+                }
+                break;
+            // Handle expression statements (standalone function calls like ProcessNumber("hello"))
+            case AST.NodeType.CallExpr:
+                this.visitExpression(stmt);
+                break;
             // Basic fallback recursive visiting
             default:
                 // Identify other nodes that contain blocks/expressions to visit
@@ -171,8 +211,30 @@ export class SemanticAnalyzer {
             if (decl.values && decl.values[index]) {
                 const value = decl.values[index];
                 const inferred = this.inferType(value);
-                // If we have a custom type annotation and the value is a table, validate it
-                if (customTypeName && value.kind === AST.NodeType.TableLiteral) {
+                const annotation = decl.typeAnnotations && decl.typeAnnotations[index];
+                // If it's an array type (e.g., RobberyConfig[] or number[]) and value is a table, validate each element
+                if (annotation && annotation.endsWith('[]') && value.kind === AST.NodeType.TableLiteral) {
+                    const elementTypeName = annotation.slice(0, -2); // Remove []
+                    const expectedElementType = this.stringToType(elementTypeName);
+                    const tableValue = value;
+                    // Iterate through each element and validate
+                    for (let i = 0; i < tableValue.fields.length; i++) {
+                        const field = tableValue.fields[i];
+                        // If element is a TableLiteral and element type is an interface, validate against interface
+                        if (field.value.kind === AST.NodeType.TableLiteral && this.typeRegistry.has(elementTypeName)) {
+                            this.validateTableAgainstType(field.value, elementTypeName, decl.line || 0);
+                        }
+                        else {
+                            // For primitive types (number[], string[], etc.), check each element type
+                            const actualType = this.inferType(field.value);
+                            if (expectedElementType !== 'any' && actualType !== 'any' && expectedElementType !== actualType) {
+                                throw new Error(`Type mismatch in array at line ${decl.line}: Element ${i + 1} expected '${elementTypeName}', got '${actualType}'`);
+                            }
+                        }
+                    }
+                }
+                // If we have a custom type annotation and the value is a table (not array), validate it
+                else if (customTypeName && value.kind === AST.NodeType.TableLiteral) {
                     this.validateTableAgainstType(value, customTypeName, decl.line || 0);
                 }
                 // If we have an annotation, check compatibility
@@ -221,8 +283,36 @@ export class SemanticAnalyzer {
                     }
                 }
             }
-            // Handle member expression type checking (Config.Field: type = value)
+            // Handle member expression type checking
             if (t.kind === AST.NodeType.MemberExpr) {
+                const member = t;
+                // 1. Strict Property Existence Check
+                if (member.object.kind === AST.NodeType.Identifier && !member.computed) {
+                    const objName = member.object.name;
+                    const sym = this.currentScope.lookup(objName);
+                    const propName = member.property.name;
+                    if (sym && sym.type !== 'any' && sym.type !== 'table') {
+                        // Check if it's an interface or alias
+                        let fields;
+                        // Remove array suffix for type lookup if needed (though variable shouldn't be array if accessing prop directly)
+                        const baseType = sym.type.replace('[]', '');
+                        if (this.typeRegistry.has(baseType)) {
+                            fields = this.typeRegistry.get(baseType);
+                        }
+                        else if (this.typeAliasRegistry.has(baseType)) {
+                            const aliasStr = this.typeAliasRegistry.get(baseType);
+                            if (aliasStr.startsWith('{')) {
+                                fields = this.parseObjectLiteralType(aliasStr);
+                            }
+                        }
+                        if (fields) {
+                            const fieldExists = fields.some(f => f.name === propName);
+                            if (!fieldExists) {
+                                throw new Error(`Property '${propName}' does not exist on type '${sym.type}' at line ${stmt.line}`);
+                            }
+                        }
+                    }
+                }
                 const memberKey = this.getMemberExprKey(t);
                 // If this assignment has a type annotation, register it
                 if (stmt.typeAnnotation && index === 0) {
@@ -279,8 +369,22 @@ export class SemanticAnalyzer {
     }
     visitFunctionDecl(decl) {
         // Name is defined in CURRENT scope
+        let funcName;
         if (decl.name && decl.name.kind === AST.NodeType.Identifier) {
-            this.currentScope.define(decl.name.name, 'const', 'function', decl.line || 0);
+            funcName = decl.name.name;
+            this.currentScope.define(funcName, 'const', 'function', decl.line || 0);
+        }
+        // Register function signature for call validation
+        const paramTypes = [];
+        decl.params.forEach(p => {
+            let type = 'any';
+            if (p.typeAnnotation) {
+                type = this.stringToType(p.typeAnnotation);
+            }
+            paramTypes.push({ name: p.name.name, type });
+        });
+        if (funcName) {
+            this.functionRegistry.set(funcName, { params: paramTypes });
         }
         this.enterScope();
         decl.params.forEach(p => {
@@ -310,6 +414,41 @@ export class SemanticAnalyzer {
         // Mostly just traversing to find nested scopes in functions/arrows
         if (!expr)
             return;
+        // Check for undefined variable usage
+        if (expr.kind === AST.NodeType.Identifier) {
+            const id = expr;
+            const sym = this.currentScope.lookup(id.name);
+            // Skip globals/builtins - only check if it looks like a user variable
+            // FiveM/Lua has many globals, so we only warn for simple lowercase identifiers
+            // that are not common Lua globals
+            const luaGlobals = ['print', 'type', 'tostring', 'tonumber', 'pairs', 'ipairs',
+                'next', 'error', 'assert', 'pcall', 'xpcall', 'require',
+                'table', 'string', 'math', 'os', 'io', 'coroutine', 'debug',
+                'setmetatable', 'getmetatable', 'rawget', 'rawset', 'rawequal',
+                'collectgarbage', 'dofile', 'load', 'loadfile', 'select',
+                'unpack', '_G', '_VERSION', 'true', 'false', 'nil',
+                // FiveM common globals
+                'Citizen', 'CreateThread', 'Wait', 'GetGameTimer', 'vector3',
+                'vector2', 'vector4', 'GetCurrentResourceName', 'exports',
+                'PlayerPedId', 'GetPlayerPed', 'GetEntityCoords', 'TriggerEvent',
+                'TriggerServerEvent', 'TriggerClientEvent', 'RegisterNetEvent',
+                'AddEventHandler', 'RegisterCommand', 'IsControlJustPressed',
+                'AddEventHandler', 'RegisterCommand', 'LocalPlayer', 'PlayerId',
+                'GetPlayerServerId', 'source', 'SetEntityHealth', 'ESX', 'QBCore',
+                // Additional FiveM/Lua globals
+                'Config', 'Framework', 'MySQL', 'lib', 'cache', 'json',
+                'NetworkGetNetworkIdFromEntity', 'NetworkGetEntityFromNetworkId',
+                'GetPlayerPed', 'GetVehiclePedIsIn', 'IsPedInAnyVehicle',
+                'SetPedCanRagdoll', 'SetTimeout', 'SetInterval', 'ClearTimeout',
+                'GetHashKey', 'IsModelValid', 'RequestModel', 'HasModelLoaded'];
+            if (!sym && !luaGlobals.includes(id.name)) {
+                // Check if it's a type name (not a variable)
+                if (!this.typeRegistry.has(id.name) && !this.typeAliasRegistry.has(id.name)) {
+                    throw new Error(`Undefined variable '${id.name}' at line ${id.line ?? 0}`);
+                }
+            }
+            return;
+        }
         if (expr.kind === AST.NodeType.ArrowFunc) {
             const arrow = expr;
             this.enterScope();
@@ -335,8 +474,57 @@ export class SemanticAnalyzer {
             this.visitFunctionDecl(expr);
             return;
         }
-        // Recurse
-        this.visitChildren(expr);
+        // Handle TableLiteral - recurse into field values only
+        if (expr.kind === AST.NodeType.TableLiteral) {
+            const table = expr;
+            for (const field of table.fields) {
+                // Don't check keys - they are field names, not variable references
+                // Only check computed keys like [expression] or string keys
+                if (field.key && field.key.kind !== AST.NodeType.Identifier) {
+                    this.visitExpression(field.key);
+                }
+                this.visitExpression(field.value);
+            }
+            return;
+        }
+        // Handle BinaryExpr
+        if (expr.kind === AST.NodeType.BinaryExpr) {
+            const bin = expr;
+            this.visitExpression(bin.left);
+            this.visitExpression(bin.right);
+            return;
+        }
+        // Handle CallExpr - recurse into callee and args, validate argument types
+        if (expr.kind === AST.NodeType.CallExpr) {
+            const call = expr;
+            this.visitExpression(call.callee);
+            // Validate argument types if callee is a known function
+            if (call.callee.kind === AST.NodeType.Identifier) {
+                const funcName = call.callee.name;
+                const funcInfo = this.functionRegistry.get(funcName);
+                if (funcInfo) {
+                    // Check each argument against expected param type
+                    for (let i = 0; i < call.args.length && i < funcInfo.params.length; i++) {
+                        const expectedType = funcInfo.params[i].type;
+                        const argType = this.inferType(call.args[i]);
+                        if (expectedType !== 'any' && argType !== 'any' && expectedType !== argType) {
+                            throw new Error(`Type mismatch in function call '${funcName}' at line ${call.line || 0}: Argument ${i + 1} expects '${expectedType}', got '${argType}'`);
+                        }
+                    }
+                }
+            }
+            for (const arg of call.args) {
+                this.visitExpression(arg);
+            }
+            return;
+        }
+        // Handle MemberExpr - only check the object, not property (obj.property)
+        if (expr.kind === AST.NodeType.MemberExpr) {
+            const member = expr;
+            this.visitExpression(member.object);
+            // Don't check member.property - it's a field access, not a variable
+            return;
+        }
     }
     inferType(expr) {
         if (!expr)
@@ -361,29 +549,96 @@ export class SemanticAnalyzer {
         }
     }
     stringToType(str) {
-        switch (str) {
+        // Array types are tables
+        if (str.endsWith('[]'))
+            return 'table';
+        // Remove array notation for basic type check: string[] -> string
+        const baseStr = str.replace(/\[\]/g, '');
+        switch (baseStr) {
             case 'string': return 'string';
             case 'number': return 'number';
             case 'boolean': return 'boolean';
-            case 'vector': return 'vector';
+            case 'vector':
+            case 'vector2':
+            case 'vector3':
+            case 'vector4': return 'vector';
             case 'table': return 'table';
             case 'function': return 'function';
             case 'any': return 'any';
             default:
-                // Check if it's a custom type
-                if (this.typeRegistry.has(str)) {
-                    return 'table'; // Custom types are tables internally
+                // Check if it's a registered interface
+                if (this.typeRegistry.has(baseStr)) {
+                    return 'table';
+                }
+                // Check if it's a type alias
+                if (this.typeAliasRegistry.has(baseStr)) {
+                    // If alias resolves to a primitive, return that. If object literal, return 'table'
+                    const aliased = this.typeAliasRegistry.get(baseStr);
+                    if (aliased.startsWith('{'))
+                        return 'table';
+                    return this.stringToType(aliased);
                 }
                 return 'any';
         }
     }
+    visitTypeAliasDecl(decl) {
+        this.typeAliasRegistry.set(decl.name.name, decl.type);
+        // If it's an object literal type, validate field types
+        if (decl.type.startsWith('{')) {
+            const fields = this.parseObjectLiteralType(decl.type);
+            for (const field of fields) {
+                this.validateTypeExists(field.type, decl.name.line ?? 0, `type '${decl.name.name}'`);
+            }
+        }
+        else {
+            // It's a simple alias, validate the aliased type exists
+            this.validateTypeExists(decl.type, decl.name.line ?? 0, `type '${decl.name.name}'`);
+        }
+    }
     visitTypeDecl(decl) {
         const typeName = decl.name.name;
         // Register the type
         this.typeRegistry.set(typeName, decl.fields);
+        // Validate that all field types exist
+        for (const field of decl.fields) {
+            this.validateTypeExists(field.type, decl.name.line ?? 0, `interface '${typeName}'`);
+        }
+    }
+    validateTypeExists(typeStr, line, context) {
+        // Remove array brackets for base type check
+        const baseType = typeStr.replace(/\[\]/g, '').trim();
+        // Skip object literal types (they are inline definitions)
+        if (baseType.startsWith('{'))
+            return;
+        // Check primitive types (including FiveM vector types)
+        const primitives = ['string', 'number', 'boolean', 'nil', 'any', 'table', 'function', 'vector', 'void', 'vector2', 'vector3', 'vector4'];
+        if (primitives.includes(baseType))
+            return;
+        // Check type registry (interfaces)
+        if (this.typeRegistry.has(baseType))
+            return;
+        // Check type alias registry
+        if (this.typeAliasRegistry.has(baseType))
+            return;
+        // Type not found!
+        throw new Error(`Unknown type '${baseType}' in ${context} at line ${line}`);
     }
     validateTableAgainstType(table, typeName, line) {
-        const fields = this.typeRegistry.get(typeName);
+        let fields;
+        // Remove array brackets if present (e.g. validating a single object against MyType[])
+        // This shouldn't happen often in this function call context but good for safety
+        typeName = typeName.replace(/\[\]/g, '');
+        // 1. Check Interface Registry
+        if (this.typeRegistry.has(typeName)) {
+            fields = this.typeRegistry.get(typeName);
+        }
+        // 2. Check Type Aliases (specifically object literal aliases)
+        else if (this.typeAliasRegistry.has(typeName)) {
+            const aliasStr = this.typeAliasRegistry.get(typeName);
+            if (aliasStr.startsWith('{')) {
+                fields = this.parseObjectLiteralType(aliasStr);
+            }
+        }
         if (!fields)
             return; // Unknown type, skip validation
         const providedFields = new Map();
@@ -408,4 +663,20 @@ export class SemanticAnalyzer {
             }
         }
     }
+    parseObjectLiteralType(typeStr) {
+        const content = typeStr.trim().slice(1, -1);
+        if (!content)
+            return [];
+        const fields = [];
+        const parts = content.split(/,|;/);
+        for (const part of parts) {
+            if (!part.trim())
+                continue;
+            const [key, val] = part.split(':').map(s => s.trim());
+            if (key && val) {
+                fields.push({ name: key.replace('?', ''), type: val });
+            }
+        }
+        return fields;
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lt-script",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "type": "module",
   "description": "LT Language Compiler for FiveM",
   "main": "dist/index.js",