lt-script 1.0.3 → 1.0.6

package/dist/cli/ltc.js

@@ -2,13 +2,17 @@
 import { compile } from '../index.js';
 import * as fs from 'fs';
 import * as path from 'path';
-import { getAllFiles, ensureDirectoryExistence, style } from './utils.js';
+import { getAllFiles, ensureDirectoryExistence, style, getPackageVersion } from './utils.js';
 const args = process.argv.slice(2);
 const command = args[0];
 if (!command) {
     printUsage();
     process.exit(1);
 }
+if (command === '-v' || command === '--version') {
+    console.log(`v${getPackageVersion()}`);
+    process.exit(0);
+}
 switch (command) {
     case 'watch':
         handleWatch(args.slice(1));
@@ -23,7 +27,7 @@ switch (command) {
 }
 function printUsage() {
     console.log(`
-${style.bold('LT Language Compiler')} ${style.gray('(v1.0.0)')}
+${style.bold('LT Language Compiler')} ${style.gray(`(v${getPackageVersion()})`)}
 ${style.gray('----------------------------------------')}
 
 ${style.bold('Usage:')}

package/dist/cli/utils.d.ts

@@ -1,5 +1,6 @@
 export declare function getAllFiles(dir: string, extension: string, fileList?: string[]): string[];
 export declare function ensureDirectoryExistence(filePath: string): void;
+export declare function getPackageVersion(): string;
 export declare const colors: {
     reset: string;
     bright: string;

package/dist/cli/utils.js

@@ -24,6 +24,27 @@ export function ensureDirectoryExistence(filePath) {
     ensureDirectoryExistence(dirname);
     fs.mkdirSync(dirname);
 }
+export function getPackageVersion() {
+    try {
+        const __dirname = path.dirname(new URL(import.meta.url).pathname);
+        // Navigate up from dist/cli/utils.js to package.json
+        // dist/cli -> dist -> root
+        const packageJsonPath = path.resolve(__dirname, '../../package.json');
+        // Handle Windows path issues with URL pathname usually having leading slash
+        const adjustedPath = process.platform === 'win32' && packageJsonPath.startsWith('\\')
+            ? packageJsonPath.substring(1)
+            : packageJsonPath;
+        if (fs.existsSync(adjustedPath)) {
+            const content = fs.readFileSync(adjustedPath, 'utf-8');
+            const pkg = JSON.parse(content);
+            return pkg.version || '1.0.0';
+        }
+    }
+    catch (e) {
+        // Fallback or dev environment handling
+    }
+    return '1.0.5'; // Fallback to current known version
+}
 export const colors = {
     reset: "\x1b[0m",
     bright: "\x1b[1m",

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.6",
   "type": "module",
   "description": "LT Language Compiler for FiveM",
   "main": "dist/index.js",