Standard Library: std.http

pub type Next {
    pub link: Link
    pub message: H2Message?
}

pub fn request(conn: Connection, headers: [Header], body: Bytes) -> H2Message ! H2Error uses Net

pub fn open(conn: Connection, headers: [Header], body: Bytes) -> Link ! H2Error uses Net

pub fn begin(conn: Connection, headers: [Header]) -> Link ! H2Error uses Net

pub fn send_data(link: Link, stream: Int, data: Bytes, end: Bool) -> Link ! H2Error uses Net

pub fn send_headers(link: Link, stream: Int, headers: [Header]) -> Link ! H2Error uses Net

pub fn send_trailers(link: Link, stream: Int, trailers: [Header]) -> Link ! H2Error uses Net

pub type Pulled {
    pub link: Link
    pub data: Bytes
    pub ended: Bool
    pub trailers: [String: String]
}

pub fn pull(link: Link) -> Pulled ! H2Error uses Net

pub fn accept(conn: Connection, data: Bytes) -> Link ! H2Error uses Net

pub fn next(link: Link) -> Next ! H2Error uses Net

pub type H2Event = StreamOpened(stream: Int, headers: [String: String]) |
    StreamData(stream: Int, data: Bytes) |
    StreamEnded(stream: Int) |
    ClientDone

pub type H2Watched {
    pub link: Link
    pub event: H2Event
}

pub fn watch(link: Link) -> H2Watched ! H2Error uses Net

pub fn respond(link: Link, stream: Int, headers: [Header], body: Bytes) -> Link ! H2Error uses Net

pub fn respond_with_trailers(
    link: Link,
    stream: Int,
    headers: [Header],
    body: Bytes,
    trailers: [Header],
) -> Link ! H2Error uses Net

pub type H2Client {
    /// The turn to send, with what sending needs.
    send_turn: Receiver<Sending>
    send_back: Sender<Sending>
    /// The connection's reading side, taken by the task that reads.
    read_turn: Receiver<Link>
    read_back: Sender<Link>
    /// What the server lets this side send, as the reader last saw it,
    /// and a signal the reader gives after each frame, for a sender
    /// waiting for credit while another task reads.
    credit: Shared<Credit>
    credit_signal: Receiver<Bool>
    signal_credit: Sender<Bool>
    /// Whether a task is reading, and where each answer still awaited
    /// goes: one task reads at a time and hands each answer to its task
    /// as soon as it is whole, in whatever order the server sends them.
    waiting: Shared<Waiting>
    leaving: Shared<Bool>
}

pub fn connect(conn: Connection) -> H2Client ! H2Error uses Net

pub fn serve(conn: Connection, data: Bytes, handler: fn(Request) -> Response, follow: Bool = true) ! H2Error uses Net

pub type H2Error = Network(error: NetError) |
    Protocol(reason: String) |
    Reset(stream: Int, code: Int)

pub type H2Message {
    pub stream: Int
    pub headers: [String: String]
    pub body: Bytes
}

pub type Link {
    pub conn: Connection
    /// Bytes read but not used yet.
    pub buffer: Bytes
    /// The header table for blocks the other side sends.
    pub table: Table
    /// How much this side may still send: on the connection, and per
    /// stream (`initial` for a stream not listed).
    pub window: Int
    pub windows: [Int: Int]
    pub initial: Int
    /// The largest frame the other side takes.
    pub max_frame: Int
    /// Messages being received, then complete ones, in order.
    pub partial: [Int: Partial]
    pub done: [H2Message]
    /// Streams the other side reset, with the reason's code.
    pub resets: [Int: Int]
    /// The stream a header block goes on with, or 0.
    pub continuing: Int
    /// The other side is going away (GOAWAY).
    pub leaving: Bool
    /// Streams `watch` has reported open and not yet ended.
    pub announced: [Int: Bool]
}

pub type Frame {
    pub kind: Int
    pub flags: Int
    pub stream: Int
    pub payload: Bytes
}

pub type Partial {
    pub headers: [String: String]
    pub body: Bytes
    /// A header block waiting for its CONTINUATION frames.
    pub block: Bytes
    pub has_headers: Bool
    /// The other side ends the stream with this header block.
    pub ending: Bool
}

pub type Credit {
    pub window: Int
    pub windows: [Int: Int]
    pub initial: Int
    pub max_frame: Int
    pub resets: [Int: Int]
}

pub fn credit_of(l: Link) -> Credit

pub fn most_streams() -> Int

pub fn block_frames(stream: Int, headers: [Header], end: Bool, most: Int) -> Bytes
    require stream >= 0 and stream <= 2_147_483_647
    require most >= 1

pub fn big_window() -> Int

pub fn preface() -> Bytes

pub fn start(conn: Connection, buffer: Bytes) -> Link

pub fn write(conn: Connection, data: Bytes) ! H2Error uses Net

pub fn frame(kind: Int, flags: Int, stream: Int, payload: Bytes) -> Bytes
    require kind >= 0 and kind <= 255
    require flags >= 0 and flags <= 255
    require stream >= 0 and stream <= 2_147_483_647
    require payload.len() <= 16_777_215

pub fn four(n: Int) -> Bytes
    require n >= 0 and n <= 4_294_967_295
    example four(258) == Bytes([0, 0, 1, 2])

pub fn number32(data: Bytes, at: Int) -> Int
    require at >= 0 and at <= data.len() - 4
    example number32(Bytes([0, 0, 1, 2]), 0) == 258

pub fn setting(id: Int, value: Int) -> Bytes
    require id >= 0 and id <= 65_535
    require value >= 0 and value <= 4_294_967_295

pub fn step(l: Link) -> Link? ! H2Error uses Net

pub fn handle(link: Link, f: Frame) -> Link ! H2Error uses Net

pub fn settings(link: Link, payload: Bytes) -> Link ! H2Error

pub fn header_frame(link: Link, f: Frame) -> Link ! H2Error uses Net

pub fn data_frame(link: Link, f: Frame) -> Link ! H2Error uses Net

pub fn unpad(f: Frame) -> Bytes ! H2Error

pub fn finish(link: Link, stream: Int) -> Link

pub fn send(link: Link, stream: Int, headers: [Header], body: Bytes, trailers: [Header]) -> Link ! H2Error uses Net

pub fn block(link: Link, stream: Int, headers: [Header], end: Bool) -> Link ! H2Error uses Net

pub fn data(link: Link, stream: Int, body: Bytes, end: Bool) -> Link ! H2Error uses Net

pub fn client_hello(conn: Connection) ! H2Error uses Net

pub type H3Error = Network(error: NetError) | Protocol(reason: String)

pub type H3Message {
    pub headers: [String: String]
    pub body: Bytes
}

pub fn request(conn: Connection, headers: [Header], body: Bytes) -> H3Message ! H3Error uses Net

pub fn encode(headers: [Header]) -> Bytes

pub fn decode(block: Bytes) -> [Header] ! H3Error

pub type Header {
    pub name: String
    pub value: String
}

pub type HpackError = Malformed(reason: String)

pub type Table {
    pub entries: [Header]
    pub size: Int
    pub limit: Int
}

pub type Decoded {
    pub headers: [Header]
    pub table: Table
}

pub fn new_table(limit: Int) -> Table

pub fn decode(block: Bytes, table: Table) -> Decoded ! HpackError

pub fn encode(headers: [Header]) -> Bytes

pub fn huffman(data: Bytes) -> Bytes ! HpackError

pub type Request {
    pub method: String
    pub path: String
    /// In the order they came, names in lower case, repeats kept.
    pub headers: [Header]
    /// The body, when it was read whole (spec 14.11); empty otherwise.
    pub body: Bytes
    /// A body too large to read whole, set by the server: read it with
    /// `read_body`.
    pub stream: BodyStream? = none
    /// The address of whoever opened the connection (`203.0.113.7:51234`),
    /// set by the server; empty for a request made by hand. Behind a proxy
    /// it is the proxy's.
    pub peer: String = ""
    /// With mutual TLS, the names of the certificate the client showed
    /// (decision 0099); `none` otherwise, and for a request made by hand.
    pub client_cert: ClientCert? = none
}

pub type BodyStream {
    pub conn: Connection
    /// What came with the request's head, not handed out yet.
    pub first: Shared<Bytes>
    /// How many bytes of the body are left.
    pub left: Shared<Int>
    /// What came after the body: the start of the next request.
    pub after: Shared<Bytes>
    /// How long one piece may take to come.
    pub wait: Duration
}

pub type Response {
    pub status: Int
    /// In the order they are sent, names in lower case; a name may come
    /// more than once (`set-cookie`).
    pub headers: [Header]
    pub body: Bytes
    /// Sent after `body` as it is read (spec 14.11): a reader of
    /// `fs.chunks`.
    pub stream: Chunks? = none
    /// What runs on the connection after the head: a WebSocket's
    /// session or an event stream's feed (`http.websocket`, `http.events`).
    pub take_over: TakeOver? = none
}

pub type ServeLimits {
    /// The most a request's line and headers may take: 431 past it.
    pub max_header_bytes: Int = 16_384
    /// The most a request's body may take: 413 past it, refused by its
    /// `content-length` before it is read.
    pub max_body_bytes: Int = 10_000_000
    /// How long a request's line and headers may take to come: 408 past
    /// it (a client sending them a byte at a time can't hold a task).
    pub header_timeout: Duration = 10.seconds
    /// The slowest a body may come, in bytes a second, after a second's
    /// grace: 408 when slower.
    pub min_body_rate: Int = 1_000
    /// How long a kept-open connection may wait for its next request.
    pub idle_timeout: Duration = 5.seconds
    /// The most connections at once: past it, 503 with `retry-after`.
    pub max_connections: Int = 10_000
    /// The most requests being answered at once: past it, 503.
    pub max_in_flight: Int = 1_000
    /// The largest request body read whole into `r.body`; a larger one is
    /// read by the handler with `r.read_body()`.
    pub buffered_body: Int = 1_000_000
    /// What `retry-after` says on a 503, in seconds.
    pub retry_after: Int = 1
    /// On a stop signal, how long to finish the requests under way
    /// (spec 5.8): `http.serve` holds the program's stop that long.
    pub drain_timeout: Duration = 10.seconds
    /// Whether a request's span continues the trace its `traceparent`
    /// names (spec 14.12); `false`, for a server the internet reaches
    /// directly, starts a trace of its own for each request.
    pub follow_trace: Bool = true
}

pub type HttpError = Network(error: NetError) |
    BadUrl(url: String) |
    BadMessage(reason: String) |
    Status(code: Int) |
    BadJson(error: JsonError)

pub fn text(status: Int, body: String) -> Response

pub fn request(method: String, url: String, headers: [Header] = [], body: Bytes = Bytes([])) -> Response ! HttpError uses Net

pub fn get(url: String) -> Response ! HttpError uses Net

pub fn post(url: String, body: Bytes) -> Response ! HttpError uses Net

pub fn get_json<T>(url: String) -> T ! HttpError uses Net

pub fn post_json<T>(url: String, body: Json) -> T ! HttpError uses Net

pub fn file(path: String) -> Response ! FsError uses Fs.read

pub type TakeOver {
    pub run: fn(Connection, Bytes, Int) ! NetError
}

pub fn websocket(r: Request, session: fn(WebSocket) ! NetError) -> Response

pub fn events(r: Request, feed: fn(EventStream) ! NetError) -> Response

pub fn websocket_connect(url: String) -> WebSocket ! HttpError uses Net

pub fn form(r: Request) -> Form ! HttpError

pub fn json_response(status: Int, value: Json) -> Response

pub fn read_json<T>(r: Request) -> T ! JsonError

pub fn get3(url: String) -> Response ! HttpError uses Net

pub type Session {
    conn: Connection
    host: String
}

pub fn open(url: String) -> Session ! HttpError uses Net

pub fn serve(listener: Listener, handler: fn(Request) -> Response, limits: ServeLimits = ServeLimits()) ! NetError uses Net

pub type Message {
    pub first: String
    pub headers: [Header]
    pub body: Bytes
}

pub fn first_header(headers: [Header], name: String) -> String?

pub fn all_headers(headers: [Header], name: String) -> [String]

pub fn head_end(data: Bytes) -> Int?

pub fn parse(data: Bytes) -> Message?

pub fn plain(headers: [String: String]) -> [Header]

pub fn chunked(headers: [Header]) -> Bool

pub fn dechunk(body: Bytes) -> Bytes?

pub fn whole(data: Bytes) -> (message: Message, used: Int)?

pub fn unchunk(body: Bytes) -> (data: Bytes, used: Int)?

pub fn crlf() -> String

pub fn reason(status: Int) -> String

pub fn content_type(path: String) -> String

pub fn hex(n: Int) -> String
    require n >= 0

pub fn hex_digit(b: UInt8) -> Int?

pub type Form {
    request: Request
    /// What divides the parts: a line end, `--` and the boundary.
    delimiter: Bytes
    /// What has come and not been handed out yet.
    held: Shared<Bytes>
    /// Whether `request.body` has been taken, for a body read whole.
    taken: Shared<Bool>
    /// Whether a part's data is being read.
    in_part: Shared<Bool>
    /// Whether the last part has ended.
    ended: Shared<Bool>
}

pub type FormPart {
    pub name: String
    /// The file's name; `none` for a plain field.
    pub filename: String?
    pub content_type: String
    form: Form
}

pub fn open(r: Request) -> Form ! HttpError

pub fn serve(listener: Listener, handler: fn(Request) -> Response, limits: ServeLimits) ! NetError uses Net

pub type WsMessage = Text(text: String) | Binary(data: Bytes)

pub type WebSocket {
    conn: Connection
    /// What has come and isn't read yet.
    held: Shared<Bytes>
    /// Whether this end is the client, which masks what it sends.
    client: Bool
    /// The largest message taken, in bytes.
    most: Int
    /// The turn to send: one slot, taken by each send while it writes
    /// its whole frame, so frames from several tasks never mix.
    turn: Receiver<Bool>
    turn_back: Sender<Bool>
}

pub fn server_end(conn: Connection, first: Bytes, most: Int) -> WebSocket

pub fn client_end(conn: Connection, first: Bytes, most: Int) -> WebSocket

pub type EventStream {
    conn: Connection
}

pub fn event_stream(conn: Connection) -> EventStream

pub fn accept(r: Request, session: fn(WebSocket) ! NetError) -> Response

pub fn events(feed: fn(EventStream) ! NetError) -> Response

pub fn connect(url: String) -> WebSocket ! HttpError uses Net