A scripting language
built for the web.

# Hub: the shared broadcast channel for all connections (setup phase)
$hub = channel()
route("WS", "/chat", function($ws) use ($hub) {

    # One thread per connection: listen on the hub → write to this client
    parallel(function() use ($ws, $hub) {
        while (true) {
            $msg = receive($hub)
            if ($msg == null) { break }
            ws::send($ws, $msg)
        }
    })
    # On incoming message, push to the hub → every client hears it
    ws::on($ws, "message", function($data) use ($hub) {
        $p = json::decode($data)
        send($hub, json::encode(["from" => request::ip(), "msg" => $p["msg"]]))
    })
    ws::on($ws, "close", function() {
        log::info("Connection closed — active: " . ws::clients())
    })
})
# Keepalive ping — to all clients every 30 seconds
timer::every(30000, function() {
    ws::broadcast(json::encode(["type" => "ping"]))
})

$conn = db::connect("mysql://root:@127.0.0.1/shop")
route("GET", "/panel/summary", function() use ($conn) {

    $ch = channel(3)  # waiting for 3 results

    parallel(function() use ($ch, $conn) {
        send($ch, db::col($conn, "SELECT count(*) FROM orders", []))
    })
    parallel(function() use ($ch, $conn) {
        send($ch, db::col($conn, "SELECT sum(total) FROM orders WHERE status='paid'", []))
    })
    parallel(function() use ($ch, $conn) {
        send($ch, db::col($conn, "SELECT count(*) FROM users WHERE active=1", []))
    })
    # Won't continue until all parallel jobs finish
    $orders  = receive($ch)
    $revenue       = receive($ch)
    $users = receive($ch)
    response::json([
        "orders"   => $orders,
        "revenue"        => $revenue,
        "users" => $users
    ])
})

$conn = db::connect("mysql://root:@127.0.0.1/shop")
# SSE: once the browser connects, a continuous data stream is pushed
route("SSE", "/live/orders", function($sse) use ($conn) {

    # Check for new orders every 2 seconds
    $tick = timer::every(2000, function() use ($sse, $conn) {
        $new = db::query($conn,
            "SELECT * FROM orders WHERE created_at > date_sub(now(), interval 5 second)", [])
        if (count($new) > 0) {
            $ok = sse::send($sse, json::encode($new), "new_order")
            if (!$ok) { timer::cancel($tick) }   # connection closed
        }
    })
    # 30s keepalive — so the browser doesn't time out
    $ping = timer::every(30000, function() use ($sse) {
        sse::send($sse, "keepalive", "ping")
    })
    sse::on($sse, "close", function() use ($tick, $ping) {
        timer::cancel($tick)
        timer::cancel($ping)
        log::info("SSE closed — active: " . sse::clients())
    })
})

use jobs
use mail
# Route: respond instantly (1ms), enqueue the work
route("POST", "/signup", function() use ($conn) {
    $data = request::json()
    db::exec($conn, "INSERT INTO users (email,name) VALUES (?,?)",
             [$data["email"], $data["name"]])
    # max 3 attempts, process now (delay_sec=0)
    jobs::push("welcome_email", ["to" => $data["email"], "name" => $data["name"]], 3, 0)
    # reminder email after 10 minutes
    jobs::push("reminder_email", ["to" => $data["email"]], 3, 600)
    response::json(["ok" => true])
})
# worker.lk — separate process (runs as a systemd service)
jobs::recover("welcome_email")  # crash recovery

jobs::worker("welcome_email", function($job) {
    $r = mail::send($job["payload"]["to"], "Welcome!",
                    "Hi " . $job["payload"]["name"] . ", your account is ready.")
    return $r["ok"]  # false → retry (max 3), then dead-letter
})
jobs::run(5000)  # poll every 5 seconds

use template
# Struct — Go style, no methods, data only
struct Post {
    id
    title
    content
    date
    likes: 0
    published: true
}

$tpl = env("VIEWS_DIR", "/app/views")
route("GET", "/blog", function() use ($conn, $tpl) {
    $rows = db::query($conn, "SELECT * FROM posts WHERE published=1", [])
    print(template::render($tpl . "/blog/index", [
        "title"  => "Blog",
        "posts" => $rows
    ]))
})

# views/blog/index.html — server-side, no JS
# {#extends "views/layout/base"}
# {#block "content"}
# {#each $posts as $p}
#   <article>
#     <h2>{$p.title}</h2>
#     <p>{$p.date} · {$p.likes} likes</p>
#     <div>{!$p.content}</div>
#   </article>
# {/each}
# {#empty}<p>No posts yet.</p>{/each}
# {/block}

# Terminal: look install github.com/Codlook/look-packages
use "pkg/jwt/jwt.lk"
use auth
use crypto
$conn = db::connect(env("DB_DSN", "mysql://root:@127.0.0.1/app"))
# Login — issue a token
route("POST", "/api/login", function() use ($conn) {
    $email = request::post("email") ?? ""
    $password = request::post("password") ?? ""
    $rows = db::query($conn, "SELECT * FROM users WHERE email=?", [$email])
    if (count($rows) == 0 || !auth::verify($password, $rows[0]["password_hash"])) {
        response::error(401, "Invalid credentials")
        return
    }

    $token = jwt_sign(
        ["user_id" => $rows[0]["id"], "role" => $rows[0]["role"]],
        env("JWT_SECRET", ""),
        ["exp" => 86400]   # 24 hours
    )
    response::json(["ok" => true, "token" => $token])
})
# Protected endpoint — Bearer token required
function auth_required() {
    $header = request::header("Authorization") ?? ""
    $token  = string::substr($header, 7)  # strip "Bearer "
    $p = jwt_verify($token, env("JWT_SECRET", ""))
    if ($p == null) {
        response::json(["error" => "Invalid token"], 401)
        return null
    }
    return $p
}

route("GET", "/api/profile", function() use ($conn) {
    $user = auth_required()
    if ($user == null) { return }

    $rows = db::query($conn, "SELECT id,name,email FROM users WHERE id=?", [$user["user_id"]])
    response::json(["ok" => true, "data" => $rows[0]])
})
# Webhook verification — HMAC-SHA256 timing-safe
route("POST", "/webhook/payment", function() {
    $payload  = request::body()
    $given  = request::header("X-Signature") ?? ""
    $expected = "sha256=" . crypto::hmac_sha256($payload, env("WEBHOOK_SECRET", ""))
    if (!crypto::constant_compare($given, $expected)) {
        response::status(401) return
    }
    # Signature valid — process the payment...
    response::json(["ok" => true])
})