Run agents like infrastructure.

type Rect:
    w: i64
    h: i64

msg Inscribe:
    w: i64
    h: i64

trait Shape:
    fn area(self) -> i64

actor Inscriber:
    @persistent var current_w: i64 = 0
    @persistent var current_h: i64 = 0

    on msg Inscribe:
        let r = Rect(msg.w, msg.h)
        current_w = r.w
        current_h = r.h
        response(area=current_w * current_h)

impl Shape for Inscriber:
    fn area(self) -> i64:
        ret current_w * current_h

import "std/string" as *
import "std/time"   as *

msg Greet:
    name: str

actor Greeter:
    @persistent var greet_count: i64 = 0

    @http(path="/greet")
    on msg Greet:
        greet_count = greet_count + 1
        let ts      = unix_now()
        let up      = to_upper(msg.name)
        let message = f"Hello, {up}! Served {greet_count} times. t={ts}"
        response(message)

msg SetScore:
    player: str
    score:  i64

msg GetScore:
    player: str

actor Scoreboard:
    @persistent var scores: Map[str, i64] = {}

    @http(method="POST", path="/score")
    on msg SetScore:
        scores[msg.player] = msg.score
        response(ok=1)

    @http(path="/score")
    on msg GetScore:
        let player = msg.player
        let score  = scores[player]
        response(player, score)

msg Push:
    value: i64

msg Pop: {}

msg Peek: {}

actor Stack:
    @persistent var items: List[i64] = []

    on msg Push:
        items.push(msg.value)
        response(items.len())

    on msg Pop:
        let value = items[items.len() - 1]
        items.pop()
        response(value)

    on msg Peek:
        response(items.len())

msg Classify:
    text: str

actor Classifier:
    @persistent var label: str = "unknown"

    @cli(command="ask", desc="Classify input")
    on msg Classify:
        infer:
            system: "Classify the topic in one word."
            user:   msg.text
            target: label
        response(label)

msg Compute:
    a: i64
    b: i64

actor Calculator:
    @persistent var calls: i64 = 0
    @persistent var items: List[i64] = []

    // Style 1: explicit — field name written out
    on msg Compute:
        response(total=msg.a + msg.b)

    // Style 2: shorthand — local var name becomes field name
    on msg Compute:
        let total = msg.a + msg.b
        response(total)              // → {total: ...}

    // Style 3: method call — last identifier inferred
    on msg Compute:
        items.push(msg.a)
        response(items.len())        // → {len: ...}

    // Style 4: member access — member name inferred
    on msg Compute:
        response(msg.a)              // → {a: ...}

    // Style 5: bare expression — single field gets "value"
    on msg Compute:
        calls = calls + 1
        response(msg.a + msg.b)      // → {value: ...}

    // Style 6: multiple bare — positional "value_N"
    on msg Compute:
        calls = calls + 1
        response(msg.a + msg.b, msg.a * msg.b, calls)
        // → {value_0: ..., value_1: ..., calls: ...}

msg Transfer:
    from_id: i64
    to_id:   i64
    amount:  i64

actor Bank:
    @persistent var a1: i64 = 100
    @persistent var a2: i64 = 100

    @http(method="POST", path="/transfer")
    on msg Transfer:
        if msg.from_id == 1:
            if a1 < msg.amount:
                fail(code=402, msg="insufficient")
            a1 = a1 - msg.amount
            a2 = a2 + msg.amount
        response(a1, a2)

import "std/bytes" as *

msg Roundtrip:
    input: str

actor Echo:
    @persistent var last_hex: str = ""
    @persistent var last_len: u64 = 0

    @http(method="POST", path="/roundtrip")
    on msg Roundtrip:
        let raw = bytes_from_hex(msg.input)
        let n   = len_b(raw)
        let hex = to_hex_b(raw)
        last_hex = hex
        last_len = n
        response(hex=hex, length=n)

import "std/bytes"  as *
import "std/bignum" as *
import "std/time"   as *

msg Check:
    hex: str

actor Smoke:
    @persistent var calls: i64 = 0

    @http(method="POST", path="/check")
    on msg Check:
        let raw = bytes_from_hex(msg.hex)
        let n   = len_b(raw)
        let now = wall_now_ms()
        let mul = decimal_mul(decimal_from_str("12.34"),
                              decimal_from_str("0.05"))
        let eur = decimal_round(mul, 2, "half_even")   # "0.62"
        calls = calls + 1
        response(bytes_len=n, eur=eur, now=now, calls=calls)