import std/http { Server }
import std/database { Connection }

fn main() {
  let server = Server.bind(":3000")
  let db = Connection.open("app.db")

  server.get("/", fn(req) {
    return "Hello from Home!"
  })

  server.get("/users", fn(req) -> async Response {
    let users = await db.query("SELECT * FROM users")
    return Response.json(users)
  })

  server.get("/user/:id", fn(req) -> async Response {
    let user = await fetch_user(db, req.param("id"))
    return Response.json(user)
  })

  print("Server running on http://localhost:3000")
  server.listen()
}

fn fetch_user(db: &Connection, id: string) -> async Result<User> {
  let stmt = db.prepare("SELECT * FROM users WHERE id = ?")
  stmt.bind(1, id)
  return stmt.execute().first()
}

struct User {
  id: i64
  name: string
  email: string
}

packages/
├── lexer/          # Tokenization and scanning
├── parser/         # AST generation from tokens
├── ast/            # Abstract Syntax Tree structures
├── types/          # Type system and inference
├── diagnostics/    # Error reporting with color output
├── interpreter/    # Direct code execution
├── codegen/        # Native x64 code generation
├── formatter/      # Code formatting
├── lsp/            # Language Server Protocol
├── pkg/            # Package manager
└── testing/        # Modern test framework (snapshots, mocks, benchmarks)

packages/
├── basics/         # Core standard library
│   ├── http_router # HTTP server with routing
│   └── zyte        # Desktop app integration
├── database/       # SQL database access (SQLite)
├── queue/          # Background job processing
├── async/          # Async runtime
├── build/          # Build system
├── cache/          # Caching utilities
└── tools/          # Development tools

packages/
├── comptime/       # Compile-time execution
├── generics/       # Generic type system
├── macros/         # Macro system
├── modules/        # Module system
├── patterns/       # Pattern matching
├── safety/         # Memory safety checks
├── traits/         # Trait system
└── acthome/         # GitHub Actions integration

packages/
└── vscode-home/     # VSCode extension with:
    ├── Language Server Protocol (LSP)
    ├── Debug Adapter Protocol (DAP)
    ├── Time-travel debugging
    ├── Memory profiling with leak detection
    ├── CPU profiling with flame graphs
    ├── Multi-threaded debugging (deadlock detection)
    ├── GC profiling with pressure analysis
    └── Chrome DevTools format export

import http_router { Router }

let router = Router.init()

// Route parameters
router.get("/user/:id", handler)

// Middleware
router.use(logger_middleware)
router.use(auth_middleware)

// Route groups
let api = router.group("/api")
api.get("/users", get_users)
api.post("/users", create_user)

// JSON responses
fn handler(req: Request) Response {
  return Response.json(.{ message = "Hello!" })
}

import database { Connection }

let conn = Connection.open(":memory:")

// Execute SQL
conn.exec("CREATE TABLE users (id INTEGER, name TEXT)")

// Prepared statements
let stmt = conn.prepare("INSERT INTO users VALUES (?, ?)")
stmt.bind_int(1, 42)
stmt.bind_text(2, "Alice")
stmt.step()

// Query with iteration
let result = conn.query("SELECT * FROM users")
while (result.next()) |row| {
  print("User: {s}", row.get_text(1))
}

// Query builder
let builder = QueryBuilder.init()
  .from("users")
  .where("age > 18")
  .order_by("name DESC")
  .limit(10)
let sql = builder.build()  // Generates SQL string

import queue { Queue, QueueConfig }

let config = QueueConfig.default()
let queue = Queue.init(config)

// Dispatch jobs
queue.dispatch("emails", "send_welcome_email")
queue.dispatch_sync("logs", "write_log")  // Execute immediately
queue.dispatch_after(60, "cleanup", "purge_cache")  // Delayed

// Process jobs
let worker = Worker.init(&queue)
worker.work(job_handler)

// Batch processing
let batch = Batch.init("batch_001")
batch.add(job1)
batch.add(job2)
batch.dispatch(&queue)

// Monitor queue
print("Pending: {}", queue.pending_count())
print("Failed: {}", queue.failed_count())
queue.retry_failed()  // Retry all failed jobs

import { test, expect, describe, mock, snapshot } from '@home/testing'

describe('User API', () => {
  test('creates user successfully', async () => {
    const user = await createUser({ name: 'Alice' })
    expect(user.name).toBe('Alice')
    expect(user).toMatchSnapshot()
  })

  test('handles validation errors', () => {
    const mockDb = mock(database)
    mockDb.save.mockReject(new Error('Invalid email'))

    expect(() => createUser({})).toThrow('Invalid email')
  })
})

Home: Start Debugging
Home: Start CPU Profiler
Home: Stop CPU Profiler
Home: Generate Flame Graph
Home: Export Chrome DevTools Profile
Home: Start Memory Profiler
Home: Stop Memory Profiler
Ion: Take Memory Snapshot
Home: Generate Memory Report
Home: Start GC Profiler
Home: Stop GC Profiler
Ion: Analyze GC Pressure
Ion: Time-Travel: Step Back
Ion: Time-Travel: Step Forward
Ion: Multi-thread: Show Deadlocks
Ion: Multi-thread: Show Race Conditions

// Ownership (implicit, no ceremony)
let data = read_file("config.home")  // data owns the string

// Automatic borrowing
fn process(data: string) {  // compiler infers &string
  print(data.len())
}

process(data)  // auto-borrow
print(data)    // still valid!

// Explicit ownership transfer
fn consume(data: string) {  // takes ownership
  // data is moved here
}

consume(data)
// print(data)  // Error: value moved

fn read_config() -> Result<Config> {
  let file = fs.read_file("config.home")?  // ? propagates errors
  let config = json.parse(file)?
  return Ok(config)
}

match read_config() {
  Ok(config) => app.start(config),
  Err(e) => log.error("Failed: {e}")
}

// Or unwrap with default
let config = read_config().unwrap_or(Config.default())

fn fetch_users() -> async []User {
  let tasks = [
    http.get("/users/1"),
    http.get("/users/2"),
    http.get("/users/3"),
  ]
  return await Promise.all(tasks)
}

// Concurrent database queries
fn get_dashboard_data() -> async Dashboard {
  let [users, posts, stats] = await Promise.all([
    db.query("SELECT * FROM users"),
    db.query("SELECT * FROM posts"),
    db.query("SELECT COUNT(*) FROM analytics"),
  ])

  return Dashboard { users, posts, stats }
}

// Run at compile time
comptime fn generate_routes() -> []Route {
  return fs.glob("routes/**/*.home")
    .map(|path| Route.from_path(path))
}

const ROUTES = generate_routes()  // executed during compilation

// Compile-time SQL validation
comptime fn validate_query(sql: string) {
  let parsed = sql_parser.parse(sql)
  if (!parsed.is_valid()) {
    @compile_error("Invalid SQL: " ++ sql)
  }
}

// Use at compile time
comptime validate_query("SELECT * FROM users WHERE id = ?")

match value {
  Ok(x) if x > 0 => print("Positive: {x}"),
  Ok(0) => print("Zero"),
  Ok(x) => print("Negative: {x}"),
  Err(e) => print("Error: {e}")
}

// Destructuring
match point {
  Point { x: 0, y: 0 } => print("Origin"),
  Point { x, y: 0 } => print("On x-axis at {x}"),
  Point { x: 0, y } => print("On y-axis at {y}"),
  Point { x, y } => print("Point ({x}, {y})")
}

// Enum matching
match response {
  HttpResponse.Ok(body) => send(body),
  HttpResponse.NotFound => send_404(),
  HttpResponse.Error(code, msg) => log_error(code, msg),
}

fn map<T, U>(items: []T, f: fn(T) -> U) -> []U {
  let result = []U.init(items.len)
  for (item, i in items) {
    result[i] = f(item)
  }
  return result
}

struct Result<T, E> {
  value: union {
    Ok(T),
    Err(E)
  }

  fn unwrap(self) -> T {
    match self.value {
      Ok(v) => return v,
      Err(e) => panic("Called unwrap on Err: {e}")
    }
  }

  fn unwrap_or(self, default: T) -> T {
    match self.value {
      Ok(v) => return v,
      Err(_) => return default
    }
  }
}

home/
├── src/
│   ├── main.zig          # CLI entry point
│   └── ion.zig           # Compiler library
├── packages/             # Core packages (27 total)
│   ├── lexer/           # Tokenization
│   ├── parser/          # AST generation
│   ├── ast/             # Syntax tree
│   ├── types/           # Type system
│   ├── interpreter/     # Code execution
│   ├── codegen/         # x64 generation
│   ├── diagnostics/     # Error reporting
│   ├── formatter/       # Code formatting
│   ├── testing/         # Modern test framework
│   ├── basics/          # Standard library
│   ├── database/        # SQLite access
│   ├── queue/           # Job processing
│   └── vscode-home/      # VSCode extension with advanced tooling
├── examples/            # Usage examples
│   ├── http_router_example.zig
│   ├── database_example.zig
│   ├── queue_example.zig
│   └── full_stack_zyte.zig
├── bench/               # Benchmarks
├── docs/                # Documentation
├── build.zig            # Build configuration
└── ion.toml             # Workspace configuration