feat: Add type aliases and multi-file imports (#52)

Implements comprehensive type alias and import system for LUMOS, enabling
DRY schemas and multi-file organization.

FEATURES:
- Type aliases with Rust-style syntax (type UserId = PublicKey)
- JavaScript-style imports (import { Type1, Type2 } from "./file.lumos")
- Recursive type resolution with circular reference detection
- Multi-file schema support with automatic import discovery
- Cross-file type validation (three-pass architecture)

IMPLEMENTATION:
Core:
- Added Import and TypeAlias structs to AST with span tracking
- Implemented multi-line import parser using regex
- Created TypeAliasResolver with recursive alias resolution
- Implemented FileResolver (340 lines) for multi-file resolution
- Added TypeAliasDefinition to IR and TypeAlias variant
- Updated all generators (Rust pub type, TypeScript export type)
- Fixed 15+ non-exhaustive pattern matches across codebase

Dependencies:
- Added regex = "1.10" for import parsing

CLI:
- Updated generate command to use FileResolver
- Automatic multi-file import discovery and loading

Testing:
- Added 4 new file_resolver tests (single, circular, multiple, validation)
- All 202 tests passing (100% success rate)
- E2E compilation tests verified

EXAMPLES:
- examples/type_aliases.lumos (200+ lines, 23 type definitions)
- examples/imports/types.lumos (24 definitions + 2 enums)
- examples/imports/accounts.lumos (180+ lines, 5 account structs)
- examples/imports/instructions.lumos (240+ lines, 6 instruction enums)
- examples/imports/README.md (comprehensive documentation)

VALIDATION:
- Circular import detection with clear error messages
- Undefined type detection across all files
- Enum import support (fixed validation timing issue)
- Multi-line import syntax support

FILES MODIFIED:
- 21 files changed, +1500/-302 lines
- packages/core/src/file_resolver.rs (new, 340 lines)
- parser.rs, transform.rs, generators (major updates)
- All test files updated and passing

BREAKING CHANGES: None
BACKWARD COMPATIBLE: Yes

Phase 5.3 Advanced Type System: 60% complete (3/5 issues)

Author: rz1989s

Cargo.lock

@@ -25,9 +25,9 @@ LUMOS continues rapid evolution with IDE integration and schema versioning:
 - ✅ **Interactive playground** - Live code generation at docs.lumos-lang.org/playground
 - ✅ **Performance benchmarks** - Comprehensive Borsh comparison suite
 
-**Completed**: Phase 5.1 (Schema Evolution - 100%), Phase 6.3 (Security & Validation - 100%)
-**Active**: Phase 5.2 (IDE Integration - 80%)
-**Next**: Phase 5.3 (Advanced Type System), Phase 5.4 (Multi-Language Generation)
+**Completed**: Phase 5.1 (Schema Evolution - 100%), Phase 5.2 (IDE Integration - 100%), Phase 6.3 (Security & Validation - 100%)
+**Active**: Phase 5.3 (Advanced Type System - 60%)
+**Next**: Phase 5.4 (Multi-Language Generation), Phase 6.1 (Framework Integration)
 
 ---
 
@@ -182,13 +182,57 @@ Transform from schema DSL → full programming language for type-safe Solana wor
 
 **Goal**: Express complex Solana program constraints
 
-**Issues to create:**
-- [ ] Add custom derive macros support to LUMOS [#50]
-- [ ] Add const generics support for fixed-size arrays in LUMOS [#51]
-- [ ] Add type aliases and imports to LUMOS [#52]
+**Status**: 3/5 complete (60%)
+
+**Issues:**
+- [x] Add custom derive macros support to LUMOS [#50] ✅ **COMPLETE**
+- [x] Add const generics support for fixed-size arrays in LUMOS [#51] ✅ **COMPLETE**
+- [x] Add type aliases and imports to LUMOS [#52] ✅ **COMPLETE**
 - [ ] Add nested module support to LUMOS [#53]
 - [ ] Add generic struct/enum definitions to LUMOS [#54]
 
+**Completed**:
+- #50 (Nov 24, 2025) - Custom derive macros support
+  - Extended `AttributeValue` enum with `List(Vec<String>)` variant
+  - Added `#[derive(...)]` parser with comma-separated list support
+  - Added `custom_derives` field to IR `Metadata` struct
+  - Implemented intelligent derive deduplication with `merge_derives()`
+  - Context-aware generation: Anchor accounts get only custom derives
+  - Created comprehensive example at examples/custom_derives.lumos
+  - 17 new tests (parser, transform, generator, end-to-end)
+  - All 196 tests passing
+  - Future enhancement: TypeScript derive equivalents (#107)
+
+- #51 (Nov 24, 2025) - Fixed-size arrays (const generics)
+  - Added `FixedArray { element, size }` variant to AST and IR
+  - Parser extracts size from `[T; N]` syntax with validation (1-1024)
+  - Generates Rust `[T; N]` format correctly
+  - Generates TypeScript `T[]` with `borsh.array(element, size)` (no length prefix!)
+  - Size calculation: `element_size * count` (no 4-byte Vec prefix)
+  - Supports nested arrays: `[[u8; 10]; 10]`
+  - Example schema at examples/fixed_arrays.lumos
+  - Updated 10+ files across codebase (parser, transform, generators, CLI, etc.)
+  - All 116 tests passing
+  - Common Solana patterns now supported: `[u8; 32]` for hashes, `[PublicKey; N]` for authority lists
+
+- #52 (Nov 24, 2025) - Type aliases and imports
+  - Added `Import` and `TypeAlias` structs to AST with span tracking
+  - Implemented JavaScript-style import parser: `import { Type1, Type2 } from "./file.lumos"`
+  - Implemented Rust-style type alias parser: `type UserId = PublicKey`
+  - Added `TypeAliasDefinition` to IR and `TypeAlias` variant to `TypeDefinition`
+  - Created `TypeAliasResolver` with recursive alias resolution and circular reference detection
+  - Implemented multi-file `FileResolver` with automatic import discovery and circular import detection
+  - Three-pass validation: collect aliases → resolve recursively → transform → validate across all files
+  - Updated all generators to handle type aliases (Rust `pub type`, TypeScript `export type`)
+  - Fixed 15+ non-exhaustive pattern matches across codebase
+  - Updated CLI to use FileResolver for multi-file schema generation
+  - Added regex dependency for import parsing (multi-line support)
+  - Created comprehensive examples: `examples/type_aliases.lumos` (200+ lines, 23 types)
+  - Created multi-file import examples: `examples/imports/{types,accounts,instructions}.lumos`
+  - Added 4 new file_resolver tests (single file, circular imports, multiple files, validation)
+  - All 202 tests passing (including E2E compilation tests)
+  - **Feature complete**: Single-file type aliases + multi-file imports with full validation
+
 **Success Metric**: Support 95% of Anchor program patterns
 
 ### 5.4 Multi-Language Code Generation
@@ -647,7 +691,7 @@ Core language free forever, monetize via cloud platform and premium extensions
 
 ### Phase 5: Advanced Features 🚧 (In Progress - Nov 2025)
 
-**Overall Progress**: 12/23 features complete (52%)
+**Overall Progress**: 13/23 features complete (57%)
 
 **5.1 Schema Evolution (100% complete) ✅:**
 - [x] Schema versioning with #[version] attribute (#40)
@@ -656,14 +700,17 @@ Core language free forever, monetize via cloud platform and premium extensions
 - [x] Deprecation warnings for schema fields (#43)
 - [x] Schema diff tool: `lumos diff` (#44)
 
-**5.2 IDE Integration (80% complete):**
+**5.2 IDE Integration (100% complete) ✅:**
 - [x] Language Server Protocol implementation (#45)
 - [x] IntelliJ IDEA / Rust Rover plugin (#46)
 - [x] Neovim plugin with Tree-sitter grammar (#47)
 - [x] Emacs mode (#48)
+- [x] Sublime Text package (#49)
 
-**5.3 Advanced Type System (0% complete):**
-- No issues started yet
+**5.3 Advanced Type System (60% complete):**
+- [x] Custom derive macros support (#50)
+- [x] Fixed-size arrays (const generics) (#51)
+- [x] Type aliases and imports (#52)
 
 **5.4 Multi-Language Code Generation (0% complete):**
 - No issues started yet
@@ -779,6 +826,9 @@ See an opportunity to help? Check our [Contributing Guide](CONTRIBUTING.md) or:
 **Last Updated**: November 24, 2025
 
 **Recent Updates**:
+- Nov 24, 2025: **Type aliases and imports COMPLETE** (#52) - Phase 5.3 at 60% 🎉 - Multi-file schemas with automatic import discovery
+- Nov 24, 2025: **Fixed-size arrays COMPLETE** (#51) - Phase 5.3 at 40% 🎉 - Const generics support for `[T; N]` syntax
+- Nov 24, 2025: **Custom derive macros support COMPLETE** (#50) - Phase 5.3 begins (20% complete) 🎉
 - Nov 24, 2025: **PHASE 5.2 IDE INTEGRATION COMPLETE** 🎉🎉🎉 - All 5 editors supported!
 - Nov 24, 2025: **Sublime Text package COMPLETE** (#49) - Full syntax + LSP + snippets 🎉
 - Nov 24, 2025: **Emacs mode COMPLETE** (#48) - Phase 5.2 at 80% 🎉

ROADMAP.md

@@ -0,0 +1,270 @@
+# Multi-File Imports Example
+
+This example demonstrates **LUMOS's multi-file import system**, allowing you to organize large schemas across multiple files with shared type definitions.
+
+## 📁 File Structure
+
+```
+imports/
+├── types.lumos          # Common type aliases and enums
+├── accounts.lumos       # Account definitions (imports from types.lumos)
+├── instructions.lumos   # Instruction enums (imports from types.lumos)
+└── README.md           # This file
+```
+
+## 🎯 What This Demonstrates
+
+### 1. **Shared Type Definitions** (`types.lumos`)
+- Common type aliases (UserId, Lamports, TokenAmount, etc.)
+- Shared enums (AccountStatus, PermissionLevel)
+- Single source of truth for type definitions
+
+### 2. **Cross-File Imports** (`accounts.lumos`, `instructions.lumos`)
+- JavaScript-style import syntax
+- Multiple imports from same file
+- Automatic dependency resolution
+
+### 3. **Circular Import Detection**
+- LUMOS prevents circular dependencies
+- Files can't import from each other in a cycle
+
+## 🚀 Usage
+
+### Generate Code from Entry Point
+
+```bash
+# Generate from accounts.lumos (will auto-discover types.lumos)
+lumos generate imports/accounts.lumos --output generated/
+
+# Generate from instructions.lumos (will also discover types.lumos)
+lumos generate imports/instructions.lumos --output generated/
+```
+
+### What Gets Generated
+
+#### Rust Output (`generated.rs`)
+```rust
+// From types.lumos
+pub type UserId = solana_program::pubkey::Pubkey;
+pub type Lamports = u64;
+pub type TokenAmount = u64;
+// ... all type aliases
+
+#[derive(BorshSerialize, BorshDeserialize, Debug, Clone)]
+pub enum AccountStatus {
+    Uninitialized,
+    Active,
+    Frozen,
+    Closed,
+}
+
+// From accounts.lumos
+#[account]
+pub struct UserAccount {
+    pub user_id: UserId,           // Expands to Pubkey
+    pub balance: Lamports,         // Expands to u64
+    pub token_balance: TokenAmount, // Expands to u64
+    pub status: AccountStatus,
+    // ...
+}
+```
+
+#### TypeScript Output (`generated.ts`)
+```typescript
+// From types.lumos
+import { PublicKey } from '@solana/web3.js';
+
+export type UserId = PublicKey;
+export type Lamports = number;
+export type TokenAmount = number;
+// ... all type aliases
+
+export enum AccountStatus {
+    Uninitialized = 0,
+    Active = 1,
+    Frozen = 2,
+    Closed = 3,
+}
+
+// From accounts.lumos
+export interface UserAccount {
+    user_id: UserId;           // = PublicKey
+    balance: Lamports;         // = number
+    token_balance: TokenAmount; // = number
+    status: AccountStatus;
+    // ...
+}
+```
+
+## 📝 Import Syntax
+
+### Basic Import
+```rust
+import { UserId, Lamports } from "./types.lumos";
+```
+
+### Multiple Imports
+```rust
+import {
+    UserId,
+    WalletAddress,
+    Lamports,
+    TokenAmount,
+    AccountStatus
+} from "./types.lumos";
+```
+
+### Relative Paths
+```rust
+// Same directory
+import { Type } from "./types.lumos";
+
+// Parent directory
+import { Type } from "../types.lumos";
+
+// Subdirectory
+import { Type } from "./shared/types.lumos";
+```
+
+### Extension Optional
+```rust
+// Both work
+import { UserId } from "./types.lumos";
+import { UserId } from "./types";
+```
+
+## 🎓 Key Concepts
+
+### Type Resolution Order
+1. **Load**: LUMOS loads entry file and discovers imports
+2. **Parse**: All imported files are parsed
+3. **Collect**: Type aliases from ALL files are collected
+4. **Resolve**: Aliases are resolved recursively
+5. **Transform**: All files are transformed to IR with shared context
+6. **Generate**: Single output with all types
+
+### Circular Import Detection
+```rust
+// ❌ This will fail
+// a.lumos
+import { B } from "./b.lumos";
+struct A { b: B }
+
+// b.lumos
+import { A } from "./a.lumos";
+struct B { a: A }
+
+// Error: Circular import detected: a.lumos -> b.lumos -> a.lumos
+```
+
+### Type Alias Resolution
+```rust
+// types.lumos
+type UserId = PublicKey;
+type AccountId = UserId;       // Alias of an alias
+type Creator = AccountId;      // Nested alias
+
+// accounts.lumos
+import { Creator } from "./types.lumos";
+
+struct NFT {
+    creator: Creator,  // Fully resolved to PublicKey
+}
+```
+
+## ✅ Benefits
+
+### 1. **Better Organization**
+- Separate concerns: types, accounts, instructions
+- Smaller, focused files
+- Easier to navigate large projects
+
+### 2. **Reusability**
+- Define common types once
+- Import where needed
+- No duplication
+
+### 3. **Consistency**
+- Same type names across entire project
+- Single source of truth
+- Refactor once, updates everywhere
+
+### 4. **Type Safety**
+- Import validation at compile time
+- Undefined type errors caught early
+- Circular dependency detection
+
+### 5. **Team Collaboration**
+- Multiple developers can work on different files
+- Merge conflicts reduced
+- Clear module boundaries
+
+## 🏗️ Project Structure Best Practices
+
+### Small Projects
+```
+project/
+└── schema.lumos          # Single file is fine
+```
+
+### Medium Projects
+```
+project/
+├── types.lumos           # Common types
+└── main.lumos            # Main definitions
+```
+
+### Large Projects
+```
+project/
+├── types/
+│   ├── common.lumos      # Shared types
+│   ├── tokens.lumos      # Token types
+│   └── governance.lumos  # DAO types
+├── accounts/
+│   ├── user.lumos
+│   ├── vault.lumos
+│   └── dao.lumos
+└── instructions/
+    ├── token.lumos
+    ├── staking.lumos
+    └── governance.lumos
+```
+
+## 🐛 Common Issues
+
+### Import Not Found
+```
+Error: Failed to read file './types.lumos': No such file or directory
+```
+**Solution**: Check relative path is correct from the importing file.
+
+### Undefined Type
+```
+Error: Import error in 'accounts.lumos': type 'InvalidType' not found in './types.lumos'
+```
+**Solution**: Make sure the type is defined in types.lumos and is not just imported there.
+
+### Circular Import
+```
+Error: Circular import detected: a.lumos -> b.lumos -> a.lumos
+```
+**Solution**: Restructure to move shared types to a third file.
+
+## 📚 Related Examples
+
+- [`../type_aliases.lumos`](../type_aliases.lumos) - Single-file type alias patterns
+- [`../custom_derives.lumos`](../custom_derives.lumos) - Custom derive macros
+- [`../enums/`](../enums/) - Enum variant patterns
+
+## 💡 Next Steps
+
+1. Try generating code from these examples
+2. Modify types.lumos and see changes propagate
+3. Create your own multi-file project structure
+4. Add more modules following these patterns
+
+## 🤝 Contributing
+
+Found an issue or have a suggestion? Please open an issue at:
+https://github.com/getlumos/lumos/issues