http.bend relies on unsafe/foreign

raw source on the hub · import bend-kit-http@0.32.0.0/http.bend as Http

HTTP/1.1 and HTTP/2 client, with an HTTP/1.1 server. Source: https://github.com/paymog/bend-kit/tree/main/http

16 imports

import Base
import ./admission.bend as Admission
import ./completion.bend as Completion
import bend-kit-wire@0.4.6.1/wire.bend as Wire
import bend-kit-http2@0.2.0.0/http2.bend as H2
import bend-kit-http2@0.2.0.0/hpack.bend as Hpack
import bend-kit-bytes@0.3.1.0/bytes.bend as HBytes
import bend-kit-time@0.1.2.1/time.bend as Time
import bend-kit-int@0.2.0.0/int.bend as Int
import bend-kit-concurrency@0.2.0.0/concurrency.bend as Conc
import 0x1f2d80f53f971b16c6de6a65cb1918ae/url.bend as Url
import 0xcfc8be7b076f41f95c8e118383892d55/encoding.bend as Enc
import 0x584fc27920487ceab242392391418d7f/json.bend as Json
import 0x49814d83de8f70993a43e1002be29ecd/bytes.bend as Bytes
import bend-kit-dns@0.6.0.2/dns.bend as Dns
import bend-kit-zlib@0.2.0.1/zlib.bend as Zlib

Types

type Req source · line 27 · raw

Type

Req

@method:String -> @path:String -> @headers:Map<&2, List<&2, String>> -> @body:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> Req

type Res source · line 30 · raw

Type

Res

@status:U32 -> @headers:Map<&2, List<&2, String>> -> @body:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> Res

type Reply source · line 34 · raw

Type

A typed Data payload can be captured in receipt; the response remains affine.

Reply

@response:Res -> @receipt:0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Receipt -> Reply

type Err source · line 57 · raw

Data

Why fetch failed. Wire errors keep the errno and the text the effect already had. ponytail: 60 and 110 are ETIMEDOUT on macOS and Linux. Windows is out of scope.

ErrUrl
```
Err
```
ErrDns
```
Err
```
ErrConnect
```
@code:U32 -> @why:String -> Err
```
ErrTls
```
@code:U32 -> @why:String -> Err
```
ErrRead
```
@code:U32 -> @why:String -> Err
```
ErrWrite
```
@code:U32 -> @why:String -> Err
```
ErrTimeout
```
Err
```
ErrRedirect
```
Err
```
ErrBad
```
Err
```

type Fields source · line 81 · raw

Data

FieldsBad
```
Fields
```
FieldsOk
```
@m:Map<&2, List<&2, String>> -> Fields
```

type Hold source · line 413 · raw

Data

More: a valid prefix. Bad: cannot become a body. Body: a whole chunked body.

HoldMore
```
Hold
```
HoldBad
```
Hold
```
HoldBody
```
@b:String -> Hold
```
HoldUntil
```
@b:String -> Hold
```

type Dc source · line 427 · raw

Data

A chunked body decoder that reads each byte once, so a body fed in pieces costs O(bytes) in total. Tr{j}: j bytes of the closing CRLF CRLF matched.

DcSize
```
@acc:U32 -> @seen:Bool -> Dc
```
DcExt
```
@n:U32 -> Dc
```
DcSizeLf
```
@n:U32 -> Dc
```
DcData
```
@k:U32 -> Dc
```
DcDataCr
```
Dc
```
DcDataLf
```
Dc
```
DcTr
```
@j:U32 -> Dc
```
DcDone
```
Dc
```
DcBad
```
Dc
```

type Dco source · line 439 · raw

Data

st: where the decoder is. racc: the body so far, reversed. rest: bytes after a Done body.

Dco

@st:Dc -> @racc:String -> @rest:String -> Dco

type Cs source · line 676 · raw

Type

A chunked body decoded from piece[i..]: a data run is sliced whole, and every other byte steps dc.

Cs

@piece:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @i:U32 -> @st:Dc -> @parts:List<&1, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes> -> Cs

type Ck source · line 680 · raw

Type

st: where the decoder stopped. parts: the data so far, newest first. rest: the bytes after a Done body.

Ck

@st:Dc -> @parts:List<&1, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes> -> @rest:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> Ck

type Got source · line 801 · raw

Type

Bad: never a request. More: the head is not whole; read on. Head: the head is whole and valid, and the body is still coming (req.body is empty). Req: a whole request.

GotBad
```
Got
```
GotMore
```
Got
```
GotHead
```
@req:Req -> Got
```
GotReq
```
@req:Req -> Got
```

type Frame source · line 931 · raw

Type

Bad: never a message. More: a valid prefix; read on. Done: a whole response.

FrameBad
```
Frame
```
FrameMore
```
Frame
```
FrameDone
```
@res:Res -> Frame
```

type Lead source · line 1021 · raw

Data

LeadCut
```
Lead
```
LeadFinal
```
Lead
```
LeadSkip
```
@+rest:String -> Lead
```

type Rb source · line 1142 · raw

Data

The response body as it arrives. Len: bytes left. Chunk: the decoder. Close: until the server closes. Done: the body is whole. Bad: it cannot become a body.

RbLen
```
@left:U32 -> Rb
```
RbChunk
```
@st:Dc -> Rb
```
RbClose
```
Rb
```
RbDone
```
Rb
```
RbBad
```
Rb
```

type Bf source · line 1179 · raw

Type

rb: how the body goes on. parts: body bytes so far, newest first. rest: bytes past a Done body.

Bf

@rb:Rb -> @parts:List<&1, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes> -> @rest:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> Bf

type Hs source · line 1249 · raw

Type

The head scan. Seek: look for the blank line from byte from; k interim heads are behind. Wait: no blank line yet. Res: the final head, how its body ends, and the bytes after it.

HsSeek

@buf:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @from:U32 -> @k:U32 -> Hs

HsWait

@buf:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @k:U32 -> Hs

HsBad
```
Hs
```

HsRes

@res:Res -> @rb:Rb -> @rest:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> Hs

type Rv source · line 1349 · raw

Type

A response read in pieces. Head: the head is not whole yet. Body: it is, and parts is the body so far. Len: a Content-Length body in one buffer of that size, with left bytes still to come.

RvHead

@buf:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @k:U32 -> Rv

RvBody

@res:Res -> @rb:Rb -> @parts:List<&1, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes> -> Rv

RvLen

@res:Res -> @left:U32 -> @body:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> Rv

type Rt source · line 1355 · raw

Type

More: read on. Done: the response, and the bytes after it when the body is self-delimited.

RtMore
```
@rv:Rv -> Rt
```
RtBad
```
Rt
```

RtDone

@res:Res -> @rest:Maybe<&1, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes> -> Rt

type Reason source · line 1661 · raw

Data

RFC 9110 §15. An unknown code gets an empty reason, which RFC 9112 §4 allows.

Reason
```
@code:U32 -> @text:String -> Reason
```

type Hop source · line 1757 · raw

Type

One request to make: headers are already lowercased (see req.put).

Hop

@method:String -> @url:0x1f2d80f53f971b16c6de6a65cb1918ae/url.Abs -> @headers:Map<&2, List<&2, String>> -> @body:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> Hop

Data

A stored cookie. domain is lowercase, with no leading dot; host_only sends it to that host alone. expiry None is a session cookie. http_only and same_site ("strict", "lax", "none" or "default") are kept, not enforced: fetch has no browsing client, so its requests are same-site (§5.2).

Cookie

@name:String -> @value:String -> @domain:String -> @host_only:Bool -> @path:String -> @secure:Bool -> @http_only:Bool -> @same_site:String -> @expiry:Maybe<&2, 0xe00bbf72c3ff9dc6d7b077524522b3a8/time.Instant> -> Cookie

type Jar source · line 1821 · raw

Data

The cookies, oldest first, and the caller's clock. No cookie in it has expired by now.

Jar

@now:0xe00bbf72c3ff9dc6d7b077524522b3a8/time.Instant -> @cookies:List<&2, Cookie> -> Jar

type Hms source · line 1944 · raw

Data

Hms
```
@h:U32 -> @m:U32 -> @s:U32 -> Hms
```

type Cdate source · line 1948 · raw

Data

§5.1.1 cookie-date: the first time, day, month and year tokens found.

Cdate

@time:Maybe<&2, Hms> -> @day:Maybe<&2, U32> -> @month:Maybe<&2, U32> -> @year:Maybe<&2, U32> -> Cdate

type Cav source · line 2150 · raw

Data

§5.6.1–§5.6.7: the last of each attribute. expires is the date as sent; max_age is capped seconds. Neither is a time from now yet: a Cav with a Time.Instant and now beside it is too wide (bendlang/bend#1069).

Cav

@expires:Maybe<&2, 0xe00bbf72c3ff9dc6d7b077524522b3a8/time.Instant> -> @max_age:Maybe<&2, U32> -> @domain:String -> @path:Maybe<&2, String> -> @secure:Bool -> @http_only:Bool -> @same_site:String -> Cav

type Av source · line 2218 · raw

Data

AvExpires
```
Av
```
AvMaxAge
```
Av
```
AvDomain
```
Av
```
AvPath
```
Av
```
AvSecure
```
Av
```
AvHttpOnly
```
Av
```
AvSameSite
```
Av
```
AvOther
```
Av
```

type Out source · line 2510 · raw

Type

none: no response byte arrived, so an idempotent request may be retried (RFC 9112 §9.3.1). sock: the socket, when it can take another request.

OutDone

@res:Res -> @sock:Maybe<&1, Socket> -> @rest:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> Out

OutFail
```
@e:Err -> @none:Bool -> Out
```

type Fl source · line 2551 · raw

Type

Read state: the response so far and the bytes read, or how it ended. none: no byte arrived, so an idempotent request may be retried.

FlMore
```
@rv:Rv -> @n:U32 -> Fl
```
FlBad
```
@err:Maybe<&2, Err> -> @none:Bool -> Fl
```

FlDone

@res:Res -> @rest:Maybe<&1, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes> -> Fl

type Cert source · line 2630 · raw

Data

Paths to a PEM client chain and its private key for mutual TLS.

Cert
```
@chain:String -> @key:String -> Cert
```

type Proxy source · line 2633 · raw

Data

ProxyDirect
```
Proxy
```

ProxyVia

@host:String -> @port:U32 -> @authorization:String -> Proxy

type Route source · line 2637 · raw

Data

RouteDirect

@tls:Bool -> @host:String -> @port:U32 -> @cert:Maybe<&2, Cert> -> @ca:String -> Route

RouteProxy

@tls:Bool -> @host:String -> @port:U32 -> @sni:String -> @authority:String -> @authorization:String -> @cert:Maybe<&2, Cert> -> @ca:String -> Route

type Conn source · line 2645 · raw

Type

Conn
```
@tls:Bool -> @s:Socket -> Conn
```

ConnH2

@s:Socket -> @client:0xc0a30c11b68a9aafb25795f94a58eba5/http2.Client -> Conn

type Send source · line 2649 · raw

Type

Send

@method:String -> @target:String -> @authority:String -> @headers:Map<&2, List<&2, String>> -> @body:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> Send

type H2Step source · line 2653 · raw

Type

H2Reply

@s:Socket -> @reply:0xc0a30c11b68a9aafb25795f94a58eba5/http2.Reply -> H2Step

H2Sent

@client:0xc0a30c11b68a9aafb25795f94a58eba5/http2.Client -> @events:List<&1, 0xc0a30c11b68a9aafb25795f94a58eba5/http2.ClientEvent> -> @sent:Result<&1, &1, Err, Socket> -> H2Step

H2Events

@s:Socket -> @client:0xc0a30c11b68a9aafb25795f94a58eba5/http2.Client -> @result:Result<&1, &1, Err, Maybe<&1, Res>> -> H2Step

H2Received

@client:0xc0a30c11b68a9aafb25795f94a58eba5/http2.Client -> @answer:Pair(Socket, Result<&1, &1, Pair(U32, String), Pair(U32, Array<U32>)>) -> H2Step

type TunnelStep source · line 2661 · raw

Type

TunnelRead
```
@s:Socket -> @raw:String -> TunnelStep
```

TunnelHead

@s:Socket -> @raw:String -> @frame:Frame -> TunnelStep

TunnelGot

@raw:String -> @answer:Pair(Socket, Result<&1, &1, Pair(U32, String), Pair(U32, Array<U32>)>) -> TunnelStep

type Pool source · line 2667 · raw

Type

Pool

@cap:U32 -> @idle:Map<&1, List<&1, Conn>> -> Pool

type Dial source · line 2892 · raw

Type

ponytail: addresses are tried in order, not raced; a broken first route can consume the step timeout.

Dial

@port:U32 -> @ms:U32 -> @deadline:Nat -> @action:IO(Result<&1, &1, Pair(U32, String), Socket>) -> Dial

type Next source · line 3783 · raw

Type

NDone
```
@res:Result<&1, &1, Err, Res> -> Next
```
NStop
```
Next
```
NGo
```
@left:Nat -> @hop:Hop -> Next
```

type Mode source · line 3788 · raw

Data

ModeFollow
```
Mode
```
ModeManual
```
Mode
```
ModeError
```
Mode
```

type Hops source · line 3855 · raw

Type

The redirect loop's state: the pool, what to do next, the client identity, the jar, and the CA file.

Hops

@p:Pool -> @next:Next -> @cert:Maybe<&2, Cert> -> @jar:Maybe<&2, Jar> -> @ca:String -> Hops

type Dec source · line 3926 · raw

Data

Ok: decoded so far. Bad: a coding failed. Skip: a coding we cannot decode, so the body stays as sent.

DecOk
```
@b:String -> Dec
```
DecBad
```
Dec
```
DecSkip
```
Dec
```

type Fetch source · line 4195 · raw

Type

One request for fetch.all: the arguments of fetch, as a record.

Fetch

@method:String -> @url:String -> @headers:Map<&2, List<&2, String>> -> @body:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> Fetch

type Po source · line 4490 · raw

Type

Streaming (a body read or sent in pieces). A decoded stream owns its decoders. What the next read returns: read more, a raw piece, a decoded piece, the end, or an error.

PoNone
```
Po
```

PoPiece

@b:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> Po

PoReady

@b:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> Po

PoEnd
```
Po
```
PoBad
```
@e:Err -> Po
```

type Stream source · line 4497 · raw

Type

Stream

@tls:Bool -> @s:Socket -> @ms:U32 -> @res:Res -> @rb:Rb -> @out:Po -> @decs:List<&1, 0xcc180113489c489d3f5cdc852e6806f9/zlib.Decoder> -> Stream

type Pc source · line 4500 · raw

Type

Pc
```
@rb:Rb -> @out:Po -> Pc
```

type Fed source · line 4576 · raw

Type

Fed

@decs:List<&1, 0xcc180113489c489d3f5cdc852e6806f9/zlib.Decoder> -> @body:Result<&1, &1, Err, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes> -> Fed

type Sh source · line 4702 · raw

Type

Head read state: still scanning, cut short or bad, or the head with the bytes after it.

ShMore

@buf:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @k:U32 -> Sh

ShBad
```
@err:Maybe<&2, Err> -> Sh
```

ShRes

@res:Res -> @rb:Rb -> @rest:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> Sh

type Sn source · line 4803 · raw

Type

Go: the next request. Drop: close this stream, then go on. Done: the answer.

SnGo
```
@left:Nat -> @hop:Hop -> Sn
```
SnDrop
```
@st:Stream -> @next:Next -> Sn
```
SnDone
```
@r:Result<&1, &1, Err, Stream> -> Sn
```

type Opened source · line 4856 · raw

Type

Opened

@decs:List<&1, 0xcc180113489c489d3f5cdc852e6806f9/zlib.Decoder> -> @bad:Bool -> Opened

type Up source · line 4977 · raw

Type

Upload: the request body sent in chunks (RFC 9112 §7.1). err: the first failed write.

Up

@tls:Bool -> @s:Socket -> @ms:U32 -> @head:Bool -> @err:Maybe<&2, Err> -> Up

type ServerConfig source · line 5096 · raw

Data

ServerConfig

@host:String -> @port:U32 -> @body_bytes:U32 -> @header_bytes:U32 -> @connections:U32 -> @requests:U32 -> @buffered:U32 -> @header_ms:U32 -> @body_ms:U32 -> @idle_ms:U32 -> @write_ms:U32 -> ServerConfig

type Limits source · line 5102 · raw

Data

Shared framing settings; all live readers reserve admission before allocation.

Limits

@body:Nat -> @headers:U32 -> @header_ms:U32 -> @body_ms:U32 -> @idle_ms:U32 -> @write_ms:U32 -> Limits

type Phase source · line 5128 · raw

Data

One absolute deadline, never replenished by progress.

Phase

@kind:U32 -> @until:0xe00bbf72c3ff9dc6d7b077524522b3a8/time.Duration -> Phase

type Sv source · line 5229 · raw

Type

The head is parsed once, when it is whole. Body pieces are kept as they come and joined once.

SvHead

@buf:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> Sv

SvLen

@req:Req -> @v11:Bool -> @left:U32 -> @parts:List<&1, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes> -> Sv

SvChunk

@req:Req -> @v11:Bool -> @n:U32 -> @st:Dc -> @parts:List<&1, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes> -> Sv

type InputOperation source · line 5234 · raw

Data

ReadInput
```
InputOperation
```
SendContinue
```
InputOperation
```

type Turn source · line 5239 · raw

Type

More: read on, first answering 100 Continue when cont is set.

TurnClose
```
Turn
```

TurnInputFailed

@operation:InputOperation -> @code:U32 -> @message:String -> Turn

TurnFail
```
@status:U32 -> Turn
```

TurnReq

@req:Req -> @rest:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @v11:Bool -> Turn

TurnMore
```
@sv:Sv -> @cont:Bool -> Turn
```

type ReadStep source · line 5667 · raw

Type

ReadChecking

@socket:Socket -> @state:Sv -> @phase:Phase -> ReadStep

ReadAllowed

@running:Bool -> @socket:Socket -> @state:Sv -> @phase:Phase -> ReadStep

ReadBudget

@ms:U32 -> @socket:Socket -> @state:Sv -> @phase:Phase -> ReadStep

ReadReceived

@state:Sv -> @phase:Phase -> @now:0xe00bbf72c3ff9dc6d7b077524522b3a8/time.Duration -> @result:Pair(Socket, Result<&1, &1, Pair(U32, String), Pair(U32, Array<U32>)>) -> ReadStep

ReadFailed

@retry:Bool -> @socket:Socket -> @state:Sv -> @phase:Phase -> @now:0xe00bbf72c3ff9dc6d7b077524522b3a8/time.Duration -> @error:Pair(U32, String) -> ReadStep

type Serving source · line 5744 · raw

Type

Serving

@connection:Pair(Socket, Turn) -> @phase:Maybe<&2, Phase> -> Serving

type StartupError source · line 5860 · raw

Data

Finite positive settings, not zero/unlimited sentinels.

InvalidConfig
```
StartupError
```

BindError

@code:U32 -> @message:String -> StartupError

type Server source · line 5865 · raw

@-C:Data -> Type

Application-owned affine dependencies never enter this transport owner.

Server

@-C:Data -> @listener:Listener -> @context:C -> @config:ServerConfig -> @admission:Chan(0x6a946b742ab6f76f0ba5b90b14da52ad/admission.Command) -> @drained:Chan(0x6a946b742ab6f76f0ba5b90b14da52ad/admission.Counts) -> Server<C>

type ServerStats source · line 5919 · raw

Data

Copyable read-only observations remain usable while server.run owns the listener.

ServerStats

@inbox:Chan(0x6a946b742ab6f76f0ba5b90b14da52ad/admission.Command) -> ServerStats

type ServerCounts source · line 5922 · raw

Data

ServerCounts

@connections:U32 -> @active:U32 -> @buffered:U32 -> @connection_high:U32 -> @active_high:U32 -> @buffered_high:U32 -> @connection_rejected:Nat -> @active_rejected:Nat -> @buffered_rejected:Nat -> ServerCounts

type ServerControl source · line 5946 · raw

Data

ServerControl

@inbox:Chan(0x6a946b742ab6f76f0ba5b90b14da52ad/admission.Command) -> ServerControl

type ServerExit source · line 5973 · raw

Data

ServerStopped
```
@counts:ServerCounts -> ServerExit
```

ServerAcceptFailed

@code:U32 -> @message:String -> @counts:ServerCounts -> ServerExit

type AcceptStep source · line 6012 · raw

@-C:Data -> Type

One accepting step, so the caller retains explicit listener ownership.

AcceptChecking

@-C:Data -> @server:Server<C> -> AcceptStep<C>

AcceptAllowed

@-C:Data -> @running:Bool -> @server:Server<C> -> AcceptStep<C>

AcceptReceived

@-C:Data -> @result:Pair(Server<C>, Result<&1, &1, Pair(U32, String), Chan(Unit)>) -> AcceptStep<C>

AcceptFailed

@-C:Data -> @retry:Bool -> @server:Server<C> -> @error:Pair(U32, String) -> AcceptStep<C>

type ServerLoop source · line 6063 · raw

@-C:Data -> Type

ServerListening

@-C:Data -> @server:Server<C> -> ServerLoop<C>

ServerAccepted

@-C:Data -> @result:Pair(Server<C>, Result<&1, &1, Pair(U32, String), Chan(Unit)>) -> ServerLoop<C>

ServerFailed

@-C:Data -> @retry:Bool -> @server:Server<C> -> @error:Pair(U32, String) -> ServerLoop<C>

type StreamServing source · line 6185 · raw

@-S:Type -> Type

StreamCheck

@-S:Type -> @held:Bool -> @connection:Serving -> @state:Maybe<&1, Pair(S, Bool)> -> StreamServing<S>

StreamReady

@-S:Type -> @held:Bool -> @ready:Bool -> @connection:Serving -> @state:Maybe<&1, Pair(S, Bool)> -> StreamServing<S>

StreamChecked

@-S:Type -> @held:Bool -> @admitted:Bool -> @connection:Serving -> @state:Maybe<&1, Pair(S, Bool)> -> StreamServing<S>

StreamDone
```
@-S:Type -> StreamServing<S>
```

type StreamAbort source · line 6210 · raw

Data

StreamClosed
```
StreamAbort
```
StreamFailed
```
@status:U32 -> StreamAbort
```

StreamInputFailed

@operation:InputOperation -> @code:U32 -> @message:String -> StreamAbort

type WriterMode source · line 6341 · raw

Data

WriteKnown
```
@left:U32 -> WriterMode
```
WriteChunk
```
WriterMode
```
WriteNone
```
WriterMode
```

type Writer source · line 6346 · raw

Type

Writer

@s:Maybe<&1, Socket> -> @mode:WriterMode -> @until:0xe00bbf72c3ff9dc6d7b077524522b3a8/time.Duration -> @outcome:0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Outcome -> Writer

type WriteHead source · line 6349 · raw

@-S:Type -> Type

WriteHead

@-S:Type -> @status:U32 -> @headers:Map<&2, List<&2, String>> -> @length:Maybe<&2, U32> -> @state:S -> @receipt:0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Receipt -> WriteHead<S>

Definitions

def Body source · line 42 · raw

Type

The body type and its conversions, so a caller needs no bytes import.

def from_string source · line 46 · raw

@+s:String -> 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes

A byte string (one Char per octet) to a body, and back.

def to_string source · line 49 · raw

@b:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> String

def length source · line 52 · raw

@b:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> Pair(0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes, U32)

def err.late source · line 68 · raw

@+code:U32 -> Bool

def err.pick source · line 71 · raw

@e:Err -> @late:Bool -> Err

def err.or_late source · line 78 · raw

@code:U32 -> @e:Err -> Err

def empty source · line 87 · raw

Map<&2, List<&2, String>>

One list per field name, in arrival order. header() is the first value. Set-Cookie is never joined. Encode writes one line per value.

def fields.of source · line 90 · raw

@r:Pair(Map<&2, List<&2, String>>, List<&2, String>) -> List<&2, String>

def fields source · line 94 · raw

@+h:Map<&2, List<&2, String>> -> @k:String -> List<&2, String>

@xs:List<&2, String> -> String

def header source · line 104 · raw

@+h:Map<&2, List<&2, String>> -> @k:String -> String

def field.last source · line 107 · raw

@xs:List<&2, String> -> String

@+h:Map<&2, List<&2, String>> -> @k:String -> String

Transfer-Encoding is a list; chunked, when present, is the last coding.

def snoc source · line 120 · raw

@xs:List<&2, String> -> @v:String -> List<&2, String>

def set source · line 127 · raw

@m:Map<&2, List<&2, String>> -> @k:String -> @v:String -> Map<&2, List<&2, String>>

def add source · line 130 · raw

@+m:Map<&2, List<&2, String>> -> @+k:String -> @v:String -> Map<&2, List<&2, String>>

def sanitize.cons source · line 133 · raw

@ch:Char -> @rest:String -> @drop:Bool -> String

def sanitize source · line 140 · raw

@s:String -> String

def drop_cr.last.if source · line 147 · raw

@cr:Bool -> @c:U32 -> String

def drop_cr.last source · line 154 · raw

@+c:U32 -> String

def drop_cr.go source · line 158 · raw

@s:String -> @prev:U32 -> String

prev is the char before s; it is kept unless it is a final CR.

def drop_cr source · line 165 · raw

@s:String -> String

def blank_end.go source · line 173 · raw

@s:String -> @w:U32 -> Bool

w holds the last four octets; a char past 255 clears it.

def blank_end source · line 181 · raw

@s:String -> Bool

String.ends_with(s, "\r\n\r\n") in one pass, with no reversed copy.

def trim_end.cons source · line 184 · raw

@h:Char -> @r:String -> @space:Bool -> String

def trim_end source · line 196 · raw

@s:String -> String

String.trim_end without the two reversed copies.

def trim source · line 203 · raw

@s:String -> String

def take.cut source · line 207 · raw

@acc:String -> @rest:String -> Pair(String, String)

Bool.pick evaluates both arms; a split that recursed inside it would reverse acc at every byte.

def take_sp.go source · line 211 · raw

@s:String -> @acc:String -> @hit:Bool -> Pair(String, String)

hit: the last char pushed onto acc was the stop char.

def take_sp source · line 226 · raw

@s:String -> Pair(String, String)

def start_line.ver source · line 229 · raw

@m:String -> @pv:Pair(String, String) -> Pair(String, Pair(String, String))

def start_line.rest source · line 233 · raw

@mr:Pair(String, String) -> Pair(String, Pair(String, String))

def start_line source · line 237 · raw

@s:String -> Pair(String, Pair(String, String))

def split_at_blank.go source · line 240 · raw

@s:String -> @e:Bool -> @w:U32 -> @acc:String -> Pair(String, String)

def split_at_blank.flag.go source · line 253 · raw

@+raw:String -> @s:String -> @off:Nat -> @w:U32 -> @e:Bool -> Pair(String, Pair(String, Bool))

split_at_blank, plus whether the head ends in the blank line.

def split_at_blank.pair source · line 266 · raw

@r:Pair(String, Pair(String, Bool)) -> Pair(String, String)

def split_at_blank source · line 270 · raw

@+s:String -> Pair(String, String)

def split_colon.go source · line 273 · raw

@s:String -> @acc:String -> @hit:Bool -> Pair(String, String)

def split_colon source · line 288 · raw

@+s:String -> Pair(String, String)

def has_header.of source · line 291 · raw

@r:Pair(Map<&2, List<&2, String>>, Bool) -> Bool

def has_header source · line 295 · raw

@+h:Map<&2, List<&2, String>> -> @k:String -> Bool

def folded source · line 298 · raw

@+line:String -> Bool

def tracked source · line 301 · raw

@+k:String -> Bool

def fields_put.dup source · line 304 · raw

@m:Map<&2, List<&2, String>> -> @k:String -> @v:String -> @bad:Bool -> Fields

def fields_put.tracked source · line 311 · raw

@+m:Map<&2, List<&2, String>> -> @+k:String -> @v:String -> @t:Bool -> Fields

def fields_put.key source · line 318 · raw

@+m:Map<&2, List<&2, String>> -> @+k:String -> @v:String -> Fields

def fields_put.kv source · line 321 · raw

@m:Map<&2, List<&2, String>> -> @kv:Pair(String, String) -> Fields

def fields_put.fold source · line 325 · raw

@m:Map<&2, List<&2, String>> -> @line:String -> @fold:Bool -> Fields

def fields_put.empty source · line 332 · raw

@m:Map<&2, List<&2, String>> -> @+line:String -> @e:Bool -> Fields

def fields_put.ok source · line 339 · raw

@m:Map<&2, List<&2, String>> -> @+line:String -> Fields

def fields_put source · line 342 · raw

@acc:Fields -> @line:String -> Fields

def parse.headers.done source · line 349 · raw

@acc:Fields -> Maybe<&2, Map<&2, List<&2, String>>>

def parse.headers.scan.line source · line 357 · raw

@acc:String -> @fields:Fields -> Fields

def parse.headers.scan source · line 364 · raw

@s:String -> @acc:String -> @fields:Fields -> Fields

def parse.headers.raw source · line 373 · raw

@s:String -> Maybe<&2, Map<&2, List<&2, String>>>

def parse.first source · line 376 · raw

@s:String -> @acc:String -> Pair(String, String)

def parse_u32.digit source · line 385 · raw

@+c:U32 -> Bool

def parse_u32.add source · line 388 · raw

@acc:U32 -> @c:U32 -> U32

def parse_u32.done source · line 391 · raw

@acc:U32 -> @bad:Bool -> Maybe<&2, U32>

def parse_u32.go source · line 398 · raw

@s:String -> @acc:U32 -> @bad:Bool -> Maybe<&2, U32>

def parse_u32 source · line 405 · raw

@s:String -> Maybe<&2, U32>

def is_hex source · line 419 · raw

@+c:U32 -> Bool

def hexv source · line 422 · raw

@+c:U32 -> U32

def dc.start source · line 442 · raw

Dc

def dc.size.semi source · line 445 · raw

@+n:U32 -> @semi:Bool -> Dc

def dc.size.cr source · line 452 · raw

@+n:U32 -> @+c:U32 -> @cr:Bool -> Dc

def dc.size.end source · line 459 · raw

@+n:U32 -> @+c:U32 -> @seen:Bool -> Dc

def dc.size source · line 467 · raw

@+acc:U32 -> @seen:Bool -> @+c:U32 -> @digit:Bool -> Dc

A size that would overflow 32 bits ends the digits, and size.end then refuses it.

def dc.ext.lf source · line 475 · raw

@+n:U32 -> @lf:Bool -> Dc

RFC 9112 §7.1.1: recipients ignore unknown chunk extensions; a bare LF is not CRLF.

def dc.ext source · line 482 · raw

@+n:U32 -> @+c:U32 -> @cr:Bool -> Dc

def dc.sized source · line 489 · raw

@+n:U32 -> @zero:Bool -> Dc

def dc.size.lf source · line 496 · raw

@+n:U32 -> @lf:Bool -> Dc

def dc.data source · line 504 · raw

@+k:U32 -> @+m:U32 -> Dc

k data bytes are left and m of them were just read.

def dc.pick source · line 507 · raw

@ok:Bool -> @next:Dc -> Dc

def dc.tr.hit source · line 515 · raw

@+j:U32 -> Dc

ponytail: trailer fields are dropped unparsed (§7.1.2 allows discarding)

def dc.tr source · line 518 · raw

@+j:U32 -> @+c:U32 -> @hit:Bool -> Dc

def dc.tr.want source · line 525 · raw

@+j:U32 -> U32

def dc.byte source · line 528 · raw

@h:Char -> U32

def dc.step source · line 533 · raw

@st:Dc -> @+c:U32 -> Dc

One byte c. Done and Bad never look at it, and a data byte is not inspected.

def dc.live source · line 554 · raw

@st:Dc -> Bool

def dc.feed source · line 575 · raw

@s:String -> @st:Dc -> @racc:String -> Dco

def chunk.hold source · line 600 · raw

@o:Dco -> Hold

def chunk.live source · line 622 · raw

@s:String -> Hold

def chunk.rest source · line 625 · raw

@o:Dco -> Maybe<&2, String>

def chunk.suffix source · line 647 · raw

@s:String -> Maybe<&2, String>

def chunk.decode.hold source · line 650 · raw

@h:Hold -> Maybe<&2, String>

def chunk.decode source · line 661 · raw

@s:String -> Maybe<&2, String>

def bytes.snd source · line 664 · raw

@r:Pair(0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes) -> 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes

def found.at source · line 668 · raw

@+from:U32 -> @m:Maybe<&2, U32> -> Maybe<&2, U32>

def ck.next source · line 683 · raw

@+len:U32 -> @+i:U32 -> @+st:Dc -> @piece:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @parts:List<&1, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes> -> Pair(Bool, Cs)

def ck.data source · line 686 · raw

@+len:U32 -> @+i:U32 -> @+k:U32 -> @+m:U32 -> @parts:List<&1, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes> -> @r:Pair(0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes) -> Pair(Bool, Cs)

def ck.byte source · line 690 · raw

@+len:U32 -> @+i:U32 -> @st:Dc -> @parts:List<&1, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes> -> @r:Pair(0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes, Maybe<&2, U32>) -> Pair(Bool, Cs)

def ck.step source · line 698 · raw

@+len:U32 -> @cs:Cs -> Pair(Bool, Cs)

def ck.rest source · line 721 · raw

@st:Dc -> @parts:List<&1, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes> -> @r:Pair(0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes) -> Ck

def ck.end source · line 725 · raw

@+len:U32 -> @cs:Cs -> Ck

def ck.feed source · line 730 · raw

@f:Nat -> @+len:U32 -> @r:Pair(Bool, Cs) -> Ck

Each step reads at least one byte, so len steps are enough.

def ck source · line 743 · raw

@piece:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @+st:Dc -> @parts:List<&1, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes> -> Ck

def parse.res.cl.have source · line 747 · raw

@+rest:String -> @+k:Nat -> @short:Bool -> Hold

def parse.res.cl.k source · line 754 · raw

@+rest:String -> @+k:Nat -> Hold

def parse.res.cl.n source · line 757 · raw

@rest:String -> @n:Maybe<&2, U32> -> Hold

def parse.body.cl source · line 764 · raw

@+h:Map<&2, List<&2, String>> -> @rest:String -> @hascl:Bool -> Hold

def parse.body.chunked.eq source · line 772 · raw

@rest:String -> @ok:Bool -> Hold

RFC 9112 §6.3 (4): a request coding other than chunked cannot be framed.

def parse.body.chunked.val source · line 779 · raw

@te:String -> @rest:String -> Hold

def parse.body.chunked source · line 782 · raw

@+h:Map<&2, List<&2, String>> -> @rest:String -> @hascl:Bool -> Hold

def parse.body.te source · line 789 · raw

@+h:Map<&2, List<&2, String>> -> @rest:String -> @te:Bool -> Hold

def parse.body source · line 796 · raw

@+h:Map<&2, List<&2, String>> -> @rest:String -> Hold

def parse.finish source · line 807 · raw

@method:String -> @path:String -> @h:Map<&2, List<&2, String>> -> @body:Hold -> Got

def parse.host source · line 818 · raw

@method:String -> @path:String -> @+h:Map<&2, List<&2, String>> -> @rest:String -> @has:Bool -> Got

def parse.fields source · line 826 · raw

@method:String -> @path:String -> @rest:String -> @v11:Bool -> @fs:Maybe<&2, Map<&2, List<&2, String>>> -> Got

RFC 9112 §3.2: only HTTP/1.1 requires Host.

def target_ok source · line 833 · raw

@+p:String -> Bool

def parse.target source · line 836 · raw

@method:String -> @+path:String -> @headers:String -> @rest:String -> @v11:Bool -> @ok:Bool -> Got

def parse.ver source · line 843 · raw

@method:String -> @+path:String -> @+v:String -> @headers:String -> @rest:String -> @ok:Bool -> Got

def parse.empty_method source · line 850 · raw

@method:String -> @path:String -> @+v:String -> @headers:String -> @rest:String -> @empty:Bool -> Got

def parse.start3 source · line 857 · raw

@mpv:Pair(String, Pair(String, String)) -> @headers:String -> @rest:String -> Got

def parse.lines source · line 861 · raw

@lr:Pair(String, String) -> @rest:String -> Got

def parse.head source · line 866 · raw

@+head:String -> @rest:String -> @whole:Bool -> Got

def parse.of source · line 873 · raw

@hb:Pair(String, Pair(String, Bool)) -> Got

def parse.got source · line 878 · raw

@+raw:String -> Got

serve reads until this is not GotMore.

def parse.req source · line 882 · raw

@g:Got -> Maybe<&1, Req>

def parse source · line 893 · raw

@raw:String -> Maybe<&1, Req>

def parse.res.cl source · line 896 · raw

@+h:Map<&2, List<&2, String>> -> @rest:String -> @hascl:Bool -> Hold

def parse.res.chunked.eq source · line 903 · raw

@rest:String -> @ok:Bool -> Hold

def parse.res.chunked.val source · line 910 · raw

@te:String -> @rest:String -> Hold

def parse.res.chunked source · line 913 · raw

@+h:Map<&2, List<&2, String>> -> @rest:String -> @hascl:Bool -> Hold

def parse.res.te source · line 920 · raw

@+h:Map<&2, List<&2, String>> -> @rest:String -> @te:Bool -> Hold

def parse.res.body source · line 927 · raw

@+h:Map<&2, List<&2, String>> -> @rest:String -> Hold

def frame.cut source · line 937 · raw

@closed:Bool -> Frame

RFC 9112 §8: a message cut short by close is incomplete, not valid.

def frame.wait source · line 944 · raw

@res:Res -> @wait:Bool -> Frame

def frame.done source · line 951 · raw

@status:U32 -> @h:Map<&2, List<&2, String>> -> @body:Hold -> @+closed:Bool -> @open:Bool -> Frame

def frame.open source · line 963 · raw

@+h:Map<&2, List<&2, String>> -> Bool

RFC 9112 §6.3 (8): no TE and no CL ⇒ the body runs until the server closes.

def frame.nobody source · line 967 · raw

@+status:U32 -> @head:Bool -> Bool

RFC 9112 §6.3 (1): HEAD, 1xx, 204 and 304 responses end at the blank line.

def frame.interim source · line 971 · raw

@+status:U32 -> Bool

101 is the final response. Other 1xx are interim; a final response follows.

def frame.status source · line 974 · raw

@status:U32 -> @+h:Map<&2, List<&2, String>> -> @rest:String -> @closed:Bool -> @nobody:Bool -> Frame

def parse.res.fields source · line 981 · raw

@+status:U32 -> @rest:String -> @fs:Maybe<&2, Map<&2, List<&2, String>>> -> @closed:Bool -> @head:Bool -> Frame

def parse.res.num source · line 988 · raw

@code:Maybe<&2, U32> -> @headers:String -> @rest:String -> @closed:Bool -> @head:Bool -> Frame

def parse.res.ver source · line 995 · raw

@code:String -> @headers:String -> @rest:String -> @closed:Bool -> @head:Bool -> @ok:Bool -> Frame

def parse.res.start3 source · line 1002 · raw

@mpv:Pair(String, Pair(String, String)) -> @headers:String -> @rest:String -> @closed:Bool -> @head:Bool -> Frame

def parse.res.lines source · line 1006 · raw

@lr:Pair(String, String) -> @rest:String -> @closed:Bool -> @head:Bool -> Frame

def parse.res.blank source · line 1010 · raw

@hd:String -> @rest:String -> @+closed:Bool -> @head:Bool -> @ok:Bool -> Frame

def parse.res.of source · line 1017 · raw

@hb:Pair(String, String) -> @closed:Bool -> @head:Bool -> Frame

def frame.lead.if source · line 1026 · raw

@rest:String -> @interim:Bool -> Lead

def frame.lead.num source · line 1033 · raw

@n:Maybe<&2, U32> -> @rest:String -> Lead

def frame.lead.code source · line 1040 · raw

@mpv:Pair(String, Pair(String, String)) -> @rest:String -> Lead

def frame.lead.lines source · line 1044 · raw

@xs:List<&2, String> -> @rest:String -> Lead

def frame.lead.blank source · line 1051 · raw

@+hd:String -> @rest:String -> @ok:Bool -> Lead

def frame.lead source · line 1058 · raw

@hb:Pair(String, String) -> Lead

def frame.at.cont source · line 1062 · raw

@+raw:String -> @lead:Lead -> String

def frame.at.zero.go source · line 1071 · raw

@+raw:String -> @closed:Bool -> @head:Bool -> @lead:Lead -> Frame

def frame.at.zero.of source · line 1080 · raw

@+raw:String -> @closed:Bool -> @head:Bool -> Frame

def frame.at.pos.do source · line 1083 · raw

@f:Nat -> @+raw:String -> @closed:Bool -> @head:Bool -> @hb:Pair(String, String) -> @lead:Lead -> Frame

def frame.at.zero source · line 1102 · raw

@+raw:String -> @closed:Bool -> @head:Bool -> Frame

def frame.at source · line 1106 · raw

@fuel:Nat -> @+raw:String -> @closed:Bool -> @head:Bool -> Frame

ponytail: 8 interim responses; raise the fuel if a server sends more

def frame source · line 1114 · raw

@raw:String -> @closed:Bool -> @head:Bool -> Frame

frame(bytes so far, server closed?, request was HEAD?)

def frame.res source · line 1117 · raw

@f:Frame -> Maybe<&1, Res>

def parse_res source · line 1126 · raw

@raw:String -> Maybe<&1, Res>

def res_fields.res source · line 1129 · raw

@res:Res -> @k:String -> List<&2, String>

def res_fields source · line 1133 · raw

@m:Maybe<&1, Res> -> @k:String -> List<&2, String>

def rb.cl source · line 1149 · raw

@n:Maybe<&2, U32> -> Maybe<&2, Rb>

def rb.te source · line 1156 · raw

@+h:Map<&2, List<&2, String>> -> @cl:Bool -> Maybe<&2, Rb>

def rb.len source · line 1163 · raw

@+h:Map<&2, List<&2, String>> -> @te:Bool -> Maybe<&2, Rb>

def rb.of source · line 1171 · raw

@+h:Map<&2, List<&2, String>> -> @nobody:Bool -> Maybe<&2, Rb>

RFC 9112 §6.3: how the body of this response ends. None: it cannot be framed.

def rb.len.cut source · line 1182 · raw

@parts:List<&1, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes> -> @+len:U32 -> @+left:U32 -> @r:Pair(0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes) -> Bf

def rb.len.have source · line 1186 · raw

@short:Bool -> @+left:U32 -> @parts:List<&1, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes> -> @+len:U32 -> @piece:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> Bf

def rb.chunk source · line 1193 · raw

@c:Ck -> Bf

def rb.feed source · line 1216 · raw

@rb:Rb -> @parts:List<&1, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes> -> @piece:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> Bf

The body bytes in piece, added to parts.

def rb.eof source · line 1231 · raw

@rb:Rb -> Bool

RFC 9112 §8: only a close-delimited body may end at close.

def rb.body source · line 1244 · raw

@parts:List<&1, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes> -> 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes

def hs.final source · line 1255 · raw

@+status:U32 -> @+h:Map<&2, List<&2, String>> -> @rest:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @m:Maybe<&2, Rb> -> Hs

def hs.skip source · line 1262 · raw

@more:Bool -> @+k:U32 -> @rest:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> Hs

def hs.pick source · line 1269 · raw

@interim:Bool -> @+head:Bool -> @+k:U32 -> @+status:U32 -> @+h:Map<&2, List<&2, String>> -> @rest:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> Hs

def hs.res source · line 1276 · raw

@+head:Bool -> @+k:U32 -> @rest:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @res:Res -> Hs

def hs.parsed source · line 1281 · raw

@+head:Bool -> @+k:U32 -> @rest:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @f:Frame -> Hs

The head alone, framed as a HEAD response so it stops at the blank line.

def hs.split source · line 1290 · raw

@+head:Bool -> @+k:U32 -> @+hlen:U32 -> @+len:U32 -> @r:Pair(0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes) -> Hs

def hs.hit source · line 1294 · raw

@+head:Bool -> @+k:U32 -> @+len:U32 -> @buf:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @at:Maybe<&2, U32> -> Hs

def hs.seek.of source · line 1302 · raw

@+head:Bool -> @+k:U32 -> @+len:U32 -> @+from:U32 -> @buf:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @r:Pair(0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes, Maybe<&2, U32>) -> Hs

def hs.seek source · line 1306 · raw

@+head:Bool -> @+k:U32 -> @+len:U32 -> @+from:U32 -> @r:Pair(0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes) -> Hs

def hs.step source · line 1310 · raw

@+head:Bool -> @st:Hs -> Hs

def hs.scan source · line 1323 · raw

@fuel:Nat -> @+head:Bool -> @st:Hs -> Hs

Each step ends the scan or passes one interim head, and at most 8 interim heads pass.

def hs.more source · line 1339 · raw

@+head:Bool -> @+k:U32 -> @buf:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @piece:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> Hs

piece joins buf; only the new bytes, and the 3 before them, can finish the blank line.

def fetch.max source · line 1344 · raw

Nat

Untrusted servers must not grow the buffer without bound.

def rv.start source · line 1360 · raw

Rv

def rv.whole source · line 1363 · raw

@res:Res -> @b:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @rest:Maybe<&1, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes> -> Rt

def rv.done source · line 1367 · raw

@res:Res -> @parts:List<&1, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes> -> @rest:Maybe<&1, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes> -> Rt

def rl.put.of source · line 1370 · raw

@+total:U32 -> @+len:U32 -> @r:Pair(Array<U32>, Array<U32>) -> Pair(0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes)

def rl.put source · line 1375 · raw

@+m:U32 -> @+left:U32 -> @body:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @piece:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> Pair(0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes)

The first m bytes of piece, written into body after the total - left bytes already there.

def rl.fed source · line 1380 · raw

@short:Bool -> @res:Res -> @+left:U32 -> @+len:U32 -> @r:Pair(0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes) -> Rt

def rl.feed source · line 1389 · raw

@res:Res -> @+left:U32 -> @body:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @piece:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> Rt

def rv.fed source · line 1393 · raw

@res:Res -> @bf:Bf -> Rt

def rb.buf source · line 1408 · raw

@rb:Rb -> Maybe<&2, U32>

Some{left}: a Content-Length body small enough to allocate up front. Larger ones fail at the fetch cap.

def rv.body source · line 1421 · raw

@m:Maybe<&2, U32> -> @res:Res -> @rb:Rb -> @rest:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> Rt

def rv.head source · line 1428 · raw

@hs:Hs -> Rt

def rv.eof source · line 1439 · raw

@res:Res -> @parts:List<&1, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes> -> @ok:Bool -> Rt

def rv.step source · line 1447 · raw

@closed:Bool -> @+head:Bool -> @rv:Rv -> @piece:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> Rt

One read: piece, or the server closed (RFC 9112 §8: a message cut short is not a message).

def rv.end source · line 1466 · raw

@closed:Bool -> @+head:Bool -> @t:Rt -> Rt

def rv.go source · line 1479 · raw

@xs:List<&2, String> -> @closed:Bool -> @+head:Bool -> @t:Rt -> Rt

def rt.frame source · line 1492 · raw

@t:Rt -> Frame

def res.frame source · line 1502 · raw

@xs:List<&2, String> -> @closed:Bool -> @+head:Bool -> Frame

What the read loop makes of these pieces, then a close when closed is set.

def rt.rest source · line 1505 · raw

@t:Rt -> Maybe<&1, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes>

def after.of source · line 1514 · raw

@m:Maybe<&1, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes> -> Maybe<&2, String>

def after source · line 1522 · raw

@+raw:String -> @+head:Bool -> Maybe<&2, String>

Bytes after a complete self-delimited message. None if it is not one yet.

def req.v11.ver source · line 1525 · raw

@mpv:Pair(String, Pair(String, String)) -> Bool

def req.v11.line source · line 1529 · raw

@+line:String -> Bool

def req.v11.lines source · line 1532 · raw

@xs:List<&2, String> -> Bool

def req.v11.pick source · line 1539 · raw

@+head:String -> @ok:Bool -> Bool

def req.v11.of source · line 1546 · raw

@hb:Pair(String, String) -> Bool

def req.v11 source · line 1550 · raw

@+raw:String -> Bool

def req.conn_close source · line 1553 · raw

@+headers:Map<&2, List<&2, String>> -> Bool

def res.conn_close source · line 1556 · raw

@+headers:Map<&2, List<&2, String>> -> Bool

def serve.fail_close source · line 1559 · raw

@+status:U32 -> Bool

def serve.keep.ok source · line 1562 · raw

@fail:Bool -> @res_close:Bool -> Bool

def serve.keep.v11 source · line 1569 · raw

@v11:Bool -> @+req_close:Bool -> @+status:U32 -> @res_close:Bool -> Bool

def serve.keep source · line 1580 · raw

@+headers:Map<&2, List<&2, String>> -> @v11:Bool -> @+status:U32 -> @+res:Map<&2, List<&2, String>> -> Bool

def again.keep source · line 1584 · raw

@close:Bool -> @x:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> Maybe<&1, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes>

def again.rest source · line 1591 · raw

@close:Bool -> @rest:Maybe<&1, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes> -> Maybe<&1, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes>

def again source · line 1600 · raw

@close:Bool -> @+h:Map<&2, List<&2, String>> -> @rest:Maybe<&1, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes> -> Maybe<&1, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes>

The bytes past the response when the socket can take another request: the request did not ask to close, the response is self-delimited, and the peer did not say close.

def res_body.res source · line 1607 · raw

@res:Res -> 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes

def res_body source · line 1611 · raw

@m:Maybe<&1, Res> -> 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes

def text source · line 1618 · raw

@res:Res -> String

def json source · line 1622 · raw

@res:Res -> Maybe<&1, 0x584fc27920487ceab242392391418d7f/json.Val>

UTF-8 is checked, not repaired: bad UTF-8 in a string gives None (RFC 8259 §8.1).

def got_body.req source · line 1625 · raw

@req:Req -> 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes

def got_body source · line 1629 · raw

@m:Maybe<&1, Req> -> 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes

def body.of source · line 1636 · raw

@hb:Pair(String, String) -> String

def body source · line 1640 · raw

@s:String -> String

def headers_lines source · line 1643 · raw

@+k:String -> @vs:List<&2, String> -> @acc:String -> String

def headers_block.go source · line 1650 · raw

@xs:List<&2, Sigma<&2, &2, String, _ => List<&2, String>>> -> @acc:String -> String

def headers_block source · line 1657 · raw

@h:Map<&2, List<&2, String>> -> String

def reasons source · line 1664 · raw

List<&2, Reason>

def reason.go source · line 1671 · raw

@xs:List<&2, Reason> -> @+status:U32 -> String

def reason source · line 1678 · raw

@+status:U32 -> String

def response source · line 1681 · raw

@+status:U32 -> @headers:Map<&2, List<&2, String>> -> @body:String -> String

def encode.body source · line 1684 · raw

@head:Bool -> @top:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @body:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes

def encode.len source · line 1691 · raw

@+status:U32 -> @headers:Map<&2, List<&2, String>> -> @head:Bool -> @body:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes

def encode.pick source · line 1696 · raw

@+status:U32 -> @headers:Map<&2, List<&2, String>> -> @body:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @head:Bool -> @nobody:Bool -> 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes

RFC 9110 §6.4.1, §8.6: 1xx, 204 and 304 have no body; HEAD gets the length but no body.

def encode.on source · line 1703 · raw

@r:Res -> @head:Bool -> 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes

def encode source · line 1707 · raw

@r:Res -> 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes

def request source · line 1710 · raw

@method:String -> @path:String -> @headers:Map<&2, List<&2, String>> -> @body:String -> String

def req.reserved source · line 1713 · raw

@+k:String -> Bool

def req.put.one source · line 1716 · raw

@m:Map<&2, List<&2, String>> -> @+k:String -> @vs:List<&2, String> -> @skip:Bool -> Map<&2, List<&2, String>>

def req.put source · line 1723 · raw

@xs:List<&2, Sigma<&2, &2, String, _ => List<&2, String>>> -> @m:Map<&2, List<&2, String>> -> Map<&2, List<&2, String>>

def req.cl source · line 1732 · raw

@+m:Map<&2, List<&2, String>> -> @+method:String -> @+len:U32 -> Map<&2, List<&2, String>>

RFC 9110 §8.6: no Content-Length on a bodiless request whose method gives a body no meaning.

def encode_req.word source · line 1738 · raw

@close:Bool -> String

Caller headers are lowercased so they cannot duplicate ours; host, connection, content-length and transfer-encoding are always ours (no smuggling through them).

def encode_req.on source · line 1745 · raw

@+method:String -> @target:String -> @host:String -> @headers:Map<&2, List<&2, String>> -> @body:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @close:Bool -> 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes

def encode_req source · line 1750 · raw

@+method:String -> @target:String -> @host:String -> @headers:Map<&2, List<&2, String>> -> @body:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes

def redirect.code source · line 1760 · raw

@+s:U32 -> Bool

def redirect.origin source · line 1763 · raw

@a:0x1f2d80f53f971b16c6de6a65cb1918ae/url.Abs -> String

def redirect.del source · line 1767 · raw

@ks:List<&2, String> -> @m:Map<&2, List<&2, String>> -> Map<&2, List<&2, String>>

def redirect.hdrs source · line 1774 · raw

@+h:Map<&2, List<&2, String>> -> @drop:Bool -> @cross:Bool -> Map<&2, List<&2, String>>

def redirect.body source · line 1781 · raw

@drop:Bool -> @body:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes

303 turns any method but HEAD into GET; 301 and 302 turn POST into GET; 307 and 308 keep method and body. A GET carries no body or body headers. Credentials do not follow a hop to another origin.

def redirect.to source · line 1788 · raw

@+status:U32 -> @+method:String -> @+from:0x1f2d80f53f971b16c6de6a65cb1918ae/url.Abs -> @headers:Map<&2, List<&2, String>> -> @body:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @next:Maybe<&2, 0x1f2d80f53f971b16c6de6a65cb1918ae/url.Abs> -> Maybe<&1, Hop>

def redirect.hop source · line 1796 · raw

@status:U32 -> @h:Hop -> @loc:String -> Maybe<&1, Hop>

def redirect.if source · line 1800 · raw

@status:U32 -> @h:Hop -> @loc:String -> @ok:Bool -> Maybe<&1, Hop>

def redirect source · line 1808 · raw

@+status:U32 -> @+headers:Map<&2, List<&2, String>> -> @h:Hop -> Maybe<&1, Hop>

The next request after a response, or None when it is not a redirect we follow.

def jar.new source · line 1824 · raw

@now:0xe00bbf72c3ff9dc6d7b077524522b3a8/time.Instant -> Jar

def jar.cookies source · line 1827 · raw

@j:Jar -> List<&2, Cookie>

@+now:0xe00bbf72c3ff9dc6d7b077524522b3a8/time.Instant -> @e:Maybe<&2, 0xe00bbf72c3ff9dc6d7b077524522b3a8/time.Instant> -> Bool

@+now:0xe00bbf72c3ff9dc6d7b077524522b3a8/time.Instant -> @c:Cookie -> Bool

Alive at now: no expiry, or an expiry after now.

def jar.live source · line 1843 · raw

@cs:List<&2, Cookie> -> @+now:0xe00bbf72c3ff9dc6d7b077524522b3a8/time.Instant -> List<&2, Cookie>

def jar.at source · line 1851 · raw

@j:Jar -> @+now:0xe00bbf72c3ff9dc6d7b077524522b3a8/time.Instant -> Jar

The jar at a later time: cookies expired by now are evicted (§5.7).

@r:Pair(String, String) -> Pair(String, Pair(String, Bool))

@s:String -> @+c:U32 -> @acc:String -> @hit:Bool -> Pair(String, Pair(String, Bool))

hit: the last char pushed onto acc was c.

@s:String -> @+c:U32 -> Pair(String, Pair(String, Bool))

s split at its first c: before, after, and whether c was there.

@r:Pair(String, Pair(String, Bool)) -> String

@t:String -> String

The path of an origin-form target: the part before "?".

@s:String -> @+n:U32 -> Bool

Longer than n octets.

@s:String -> Bool

%x00-08 / %x0A-1F / %x7F: control characters other than HTAB.

@s:String -> Bool

@s:String -> Bool

@+h:String -> Bool

An IP literal rather than a host name: IPv6 has a colon, IPv4 is digits and dots.

@+s:String -> @+d:String -> Bool

§5.1.3: s is d, or a host name under d on a label boundary.

@rs:String -> String

A reversed path with its last segment and slash dropped.

@+p:String -> String

§5.1.4: the request path up to its last "/", or "/".

@+p:String -> @+c:String -> Bool

§5.1.4: request path p path-matches cookie path c.

@+c:U32 -> Bool

@acc:String -> @ts:List<&2, String> -> List<&2, String>

@d:Bool -> @+c:U32 -> @acc:String -> @ts:List<&2, String> -> Pair(String, List<&2, String>)

@s:String -> @st:Pair(String, List<&2, String>) -> List<&2, String>

The date-tokens, last first. st: the token so far (reversed) and the tokens before it.

@+s:String -> Bool

@s:String -> @d:Bool -> @+n:U32 -> @+acc:U32 -> Pair(U32, Pair(U32, String))

The digits at the start of s: (count, value, rest). d: s starts with a digit.

@r:Pair(U32, Pair(U32, String)) -> @+lo:U32 -> @+hi:U32 -> Maybe<&1, Pair(U32, String)>

@+s:String -> @+lo:U32 -> @+hi:U32 -> Maybe<&1, Pair(U32, String)>

lo to hi digits and what follows them, which does not start with a digit.

@m:Maybe<&1, Pair(U32, String)> -> Maybe<&2, U32>

@s:String -> Maybe<&2, String>

@+h:U32 -> @+m:U32 -> @r:Maybe<&1, Pair(U32, String)> -> Maybe<&2, Hms>

@+h:U32 -> @+m:U32 -> @c:Maybe<&2, String> -> Maybe<&2, Hms>

@+h:U32 -> @r:Maybe<&1, Pair(U32, String)> -> Maybe<&2, Hms>

@+h:U32 -> @c:Maybe<&2, String> -> Maybe<&2, Hms>

@r:Maybe<&1, Pair(U32, String)> -> Maybe<&2, Hms>

@+tok:String -> Maybe<&2, Hms>

hms-time: 1*2DIGIT ":" 1*2DIGIT ":" 1*2DIGIT, then anything but a digit.

@xs:List<&2, String> -> @+w:String -> @+i:U32 -> Maybe<&2, U32>

@+tok:String -> Maybe<&2, U32>

The month named by the first three letters, from 1.

@y:Maybe<&2, U32> -> @+tok:String -> @t:Maybe<&2, Hms> -> @d:Maybe<&2, U32> -> @m:Maybe<&2, U32> -> Cdate

Each try* below: the flag is set, so go on; or the token matches, so stop; or go on.

@g:Maybe<&2, U32> -> @+tok:String -> @t:Maybe<&2, Hms> -> @d:Maybe<&2, U32> -> @y:Maybe<&2, U32> -> Cdate

@m:Maybe<&2, U32> -> @+tok:String -> @t:Maybe<&2, Hms> -> @d:Maybe<&2, U32> -> @y:Maybe<&2, U32> -> Cdate

@g:Maybe<&2, U32> -> @+tok:String -> @t:Maybe<&2, Hms> -> @m:Maybe<&2, U32> -> @y:Maybe<&2, U32> -> Cdate

@d:Maybe<&2, U32> -> @+tok:String -> @t:Maybe<&2, Hms> -> @m:Maybe<&2, U32> -> @y:Maybe<&2, U32> -> Cdate

@g:Maybe<&2, Hms> -> @+tok:String -> @d:Maybe<&2, U32> -> @m:Maybe<&2, U32> -> @y:Maybe<&2, U32> -> Cdate

@t:Maybe<&2, Hms> -> @+tok:String -> @d:Maybe<&2, U32> -> @m:Maybe<&2, U32> -> @y:Maybe<&2, U32> -> Cdate

@ts:List<&2, String> -> @st:Cdate -> Cdate

@+y:U32 -> U32

70–99 are 19xx, 0–69 are 20xx.

@+y:U32 -> @+d:U32 -> @mo:U32 -> @h:U32 -> @mi:U32 -> @s:U32 -> Maybe<&2, 0xe00bbf72c3ff9dc6d7b077524522b3a8/time.Instant>

@st:Cdate -> Maybe<&2, 0xe00bbf72c3ff9dc6d7b077524522b3a8/time.Instant>

@s:String -> Maybe<&2, 0xe00bbf72c3ff9dc6d7b077524522b3a8/time.Instant>

§5.1.1: a cookie-date such as "Sun, 06 Nov 1994 08:49:37 GMT" or "Thu, 01-Jan-70 00:00:01 GMT". Time.mk refuses a day past the month's end and a time past 23:59:59.

Cav

U32

§5.5: 400 days, the longest a cookie lives.

@+now:0xe00bbf72c3ff9dc6d7b077524522b3a8/time.Instant -> @+secs:U32 -> 0xe00bbf72c3ff9dc6d7b077524522b3a8/time.Instant

@+now:0xe00bbf72c3ff9dc6d7b077524522b3a8/time.Instant -> @m:Maybe<&2, 0xe00bbf72c3ff9dc6d7b077524522b3a8/time.Instant> -> Maybe<&2, 0xe00bbf72c3ff9dc6d7b077524522b3a8/time.Instant>

@m:Maybe<&2, U32> -> Maybe<&2, U32>

@s:String -> String

@long:Bool -> @m:Maybe<&2, U32> -> Maybe<&2, U32>

More than 9 significant digits is past the limit (and would overflow parse_u32).

@+v:String -> @neg:Bool -> Maybe<&2, U32>

@+now:0xe00bbf72c3ff9dc6d7b077524522b3a8/time.Instant -> @m:Maybe<&2, U32> -> Maybe<&2, 0xe00bbf72c3ff9dc6d7b077524522b3a8/time.Instant>

Zero or less is the earliest time, so the cookie is already expired.

@+v:String -> Maybe<&2, U32>

§5.6.2: DIGIT*, or "-" and DIGIT*. Anything else is ignored.

@+v:String -> String

@+k:String -> Av

@k:Av -> @a:Cav -> @+v:String -> Cav

An Expires or Max-Age that does not parse leaves the earlier one. A leading dot of Domain is dropped.

@+a:Cav -> @kv:Pair(String, Pair(String, Bool)) -> Cav

§5.6: name and value trimmed; a value over 1024 octets drops the attribute.

@xs:List<&2, String> -> @a:Cav -> Cav

@r:Pair(String, Pair(String, Bool)) -> Pair(String, String)

§5.6: with no "=", the name is empty and the pair is the value.

@+s:String -> @+p:String -> Bool

@+host:String -> @+d:String -> Maybe<&1, Pair(String, Bool)>

§5.7 steps 8–10: (domain, host-only), or None to ignore the cookie. ponytail: the public-suffix check knows single-label suffixes only (com, org, localhost). Multi-label ones (co.uk, github.io) need the publicsuffix.org list; ship it as data when a caller needs it.

@p:Maybe<&2, String> -> @+req:String -> String

@dm:Maybe<&1, Pair(String, Bool)> -> @+name:String -> @+value:String -> @+path:String -> @has_path:Bool -> @+secure:Bool -> @http_only:Bool -> @+same_site:String -> @expiry:Maybe<&2, 0xe00bbf72c3ff9dc6d7b077524522b3a8/time.Instant> -> @https:Bool -> Maybe<&2, Cookie>

§5.7 steps 12–20: Secure needs https; SameSite=None needs Secure; the __Secure- and __Host- prefixes.

@+now:0xe00bbf72c3ff9dc6d7b077524522b3a8/time.Instant -> @m:Maybe<&2, U32> -> @e:Maybe<&2, 0xe00bbf72c3ff9dc6d7b077524522b3a8/time.Instant> -> Maybe<&2, 0xe00bbf72c3ff9dc6d7b077524522b3a8/time.Instant>

Max-Age wins over Expires, whatever their order (§5.7 step 6). Both count from now.

@+now:0xe00bbf72c3ff9dc6d7b077524522b3a8/time.Instant -> @a:0x1f2d80f53f971b16c6de6a65cb1918ae/url.Abs -> @+name:String -> @+value:String -> @c:Cav -> Maybe<&2, Cookie>

@+now:0xe00bbf72c3ff9dc6d7b077524522b3a8/time.Instant -> @a:0x1f2d80f53f971b16c6de6a65cb1918ae/url.Abs -> @nv:Pair(String, String) -> @avs:List<&2, String> -> Maybe<&2, Cookie>

An empty name and value, or more than 4096 octets of them, is ignored.

@+now:0xe00bbf72c3ff9dc6d7b077524522b3a8/time.Instant -> @a:0x1f2d80f53f971b16c6de6a65cb1918ae/url.Abs -> @xs:List<&2, String> -> Maybe<&2, Cookie>

@+now:0xe00bbf72c3ff9dc6d7b077524522b3a8/time.Instant -> @a:0x1f2d80f53f971b16c6de6a65cb1918ae/url.Abs -> @+line:String -> Maybe<&2, Cookie>

§5.6 and §5.7: one Set-Cookie value received from a at now, or None when it is ignored.

@a:0x1f2d80f53f971b16c6de6a65cb1918ae/url.Abs -> Bool

@c:Cookie -> Bool

@+a:Cookie -> @+b:Cookie -> Bool

Same name, domain, host-only flag and path: the new cookie replaces the old one.

@+old:Cookie -> @+c:Cookie -> Bool

§5.7 step 16: a secure cookie that a new cookie from plain http must not overlay.

@cs:List<&2, Cookie> -> @+c:Cookie -> Bool

@cs:List<&2, Cookie> -> @+c:Cookie -> @+live:Bool -> List<&2, Cookie>

cs with the cookie c replaces swapped for c (keeping its place, so its creation order), or c last. A c that is not live only removes the old one: that is how a server deletes a cookie.

def jar.put.c source · line 2366 · raw

@m:Maybe<&2, Cookie> -> @j:Jar -> @+https:Bool -> Jar

def jar.put.one source · line 2375 · raw

@j:Jar -> @+a:0x1f2d80f53f971b16c6de6a65cb1918ae/url.Abs -> @x:String -> Jar

def jar.put.all source · line 2379 · raw

@xs:List<&2, String> -> @j:Jar -> @+a:0x1f2d80f53f971b16c6de6a65cb1918ae/url.Abs -> Jar

def jar.store.abs source · line 2387 · raw

@j:Jar -> @+a:0x1f2d80f53f971b16c6de6a65cb1918ae/url.Abs -> @+h:Map<&2, List<&2, String>> -> Jar

Every set-cookie field of h, in order, as received from a.

def jar.store.url source · line 2390 · raw

@j:Jar -> @u:Maybe<&2, 0x1f2d80f53f971b16c6de6a65cb1918ae/url.Abs> -> @+h:Map<&2, List<&2, String>> -> Jar

def jar.store source · line 2399 · raw

@j:Jar -> @url:String -> @res:Res -> Pair(Jar, Res)

The jar after res came from url, and res as it was. Header names are lowercase, as parse gives them. An unparsable url stores nothing.

@+host:String -> @+path:String -> @+https:Bool -> @+c:Cookie -> Bool

§5.8.3: domain (exact when host-only), path, and Secure only over https.

@cs:List<&2, Cookie> -> @+host:String -> @+path:String -> @+https:Bool -> List<&2, Cookie>

@a:Cookie -> @b:Cookie -> Bool

The sort order of §5.8.3: longer paths first; the stable sort keeps creation order among equals.

@c:Cookie -> String

@cs:List<&2, Cookie> -> List<&2, String>

def jar.string source · line 2433 · raw

@j:Jar -> @a:0x1f2d80f53f971b16c6de6a65cb1918ae/url.Abs -> String

§5.8.3: the cookie-string for a request to a, or "" when no cookie matches.

def jar.header source · line 2439 · raw

@+h:Map<&2, List<&2, String>> -> @+s:String -> Map<&2, List<&2, String>>

One cookie field: the caller's own cookie values first, then the jar's.

def jar.apply.url source · line 2443 · raw

@j:Jar -> @u:Maybe<&2, 0x1f2d80f53f971b16c6de6a65cb1918ae/url.Abs> -> @+h:Map<&2, List<&2, String>> -> Map<&2, List<&2, String>>

def jar.apply source · line 2452 · raw

@j:Jar -> @url:String -> @+h:Map<&2, List<&2, String>> -> Map<&2, List<&2, String>>

The headers with the jar's cookies for a request to url in their cookie field (lowercase, as fetch sends names). An unparsable url adds nothing.

def jar.opt.apply source · line 2456 · raw

@m:Maybe<&2, Jar> -> @a:0x1f2d80f53f971b16c6de6a65cb1918ae/url.Abs -> @+h:Map<&2, List<&2, String>> -> Map<&2, List<&2, String>>

The jar, if any, that a fetch threads through its hops.

def jar.opt.res source · line 2463 · raw

@j:Jar -> @+a:0x1f2d80f53f971b16c6de6a65cb1918ae/url.Abs -> @r:Result<&1, &1, Err, Res> -> Pair(Maybe<&2, Jar>, Result<&1, &1, Err, Res>)

def jar.opt.store source · line 2471 · raw

@m:Maybe<&2, Jar> -> @+a:0x1f2d80f53f971b16c6de6a65cb1918ae/url.Abs -> @r:Result<&1, &1, Err, Res> -> Pair(Maybe<&2, Jar>, Result<&1, &1, Err, Res>)

def io.recv.words source · line 2478 · raw

@tls:Bool -> @s:Socket -> @max:U32 -> @ms:U32 -> IO(Pair(Socket, Result<&1, &1, Pair(U32, String), Pair(U32, Array<U32>)>))

def io.send.words source · line 2485 · raw

@tls:Bool -> @s:Socket -> @+len:U32 -> @buf:Array<U32> -> IO(Pair(Socket, Result<&1, &1, Pair(U32, String), Unit>))

def io.send.bytes source · line 2492 · raw

@tls:Bool -> @s:Socket -> @b:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> IO(Pair(Socket, Result<&1, &1, Pair(U32, String), Unit>))

def io.close source · line 2496 · raw

@tls:Bool -> @s:Socket -> IO(Unit)

def fetch.close source · line 2503 · raw

@tls:Bool -> @s:Socket -> @r:Result<&1, &1, Err, Res> -> IO(Result<&1, &1, Err, Res>)

def fetch.boxed source · line 2514 · raw

@r:Result<&1, &1, Err, Res> -> @none:Bool -> Out

def fetch.bad source · line 2521 · raw

@tls:Bool -> @s:Socket -> @e:Maybe<&2, Err> -> IO(Result<&1, &1, Err, Res>)

def fetch.shut source · line 2528 · raw

@tls:Bool -> @s:Socket -> @r:Result<&1, &1, Err, Res> -> @none:Bool -> IO(Out)

def fetch.hold.go source · line 2533 · raw

@tls:Bool -> @s:Socket -> @res:Res -> @left:Maybe<&1, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes> -> IO(Out)

def fetch.hold source · line 2540 · raw

@tls:Bool -> @close:Bool -> @s:Socket -> @res:Res -> @left:Maybe<&1, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes> -> IO(Out)

def fetch.failout source · line 2544 · raw

@tls:Bool -> @s:Socket -> @e:Maybe<&2, Err> -> @none:Bool -> IO(Out)

def fetch.rt source · line 2556 · raw

@+n:U32 -> @t:Rt -> Fl

def fetch.over source · line 2566 · raw

@+n:U32 -> Bool

64 KiB of head past the body cap, as serve allows.

def fetch.piece.cap source · line 2569 · raw

@over:Bool -> @+head:Bool -> @rv:Rv -> @+n2:U32 -> @+len:U32 -> @buf:Array<U32> -> Fl

def fetch.piece source · line 2576 · raw

@+head:Bool -> @rv:Rv -> @+n:U32 -> @p:Pair(U32, Array<U32>) -> Fl

def fetch.next source · line 2581 · raw

@+head:Bool -> @rv:Rv -> @+n:U32 -> @m:Pair(Socket, Result<&1, &1, Pair(U32, String), Pair(U32, Array<U32>)>) -> Pair(Socket, Fl)

def exchange.sent source · line 2603 · raw

@+tls:Bool -> @+ms:U32 -> @+close:Bool -> @+head:Bool -> @m:Pair(Socket, Result<&1, &1, Pair(U32, String), Unit>) -> IO(Out)

def exchange.go source · line 2611 · raw

@+tls:Bool -> @+ms:U32 -> @+close:Bool -> @+head:Bool -> @s:Socket -> @wire:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> IO(Out)

def exchange.tup source · line 2616 · raw

@o:Out -> Pair(Maybe<&1, Socket>, Pair(Result<&1, &1, Err, Res>, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes))

def exchange source · line 2624 · raw

@+tls:Bool -> @+ms:U32 -> @+close:Bool -> @+head:Bool -> @s:Socket -> @wire:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> IO(Pair(Maybe<&1, Socket>, Pair(Result<&1, &1, Err, Res>, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes)))

One request on an open socket. Some{socket}: it can take another request.

def pool.new.with source · line 2670 · raw

@+cap:U32 -> Pool

def pool.new source · line 2674 · raw

Pool

Up to 8 idle sockets per origin.

def pool.key source · line 2677 · raw

@+scheme:String -> @+host:String -> @+port:U32 -> String

def pool.key.cert source · line 2680 · raw

@+base:String -> @cert:Maybe<&2, Cert> -> String

def pool.key.ca source · line 2688 · raw

@+base:String -> @+ca:String -> @empty:Bool -> String

def pool.key.trust source · line 2695 · raw

@+base:String -> @cert:Maybe<&2, Cert> -> @+ca:String -> String

def pool.take.of source · line 2698 · raw

@+cap:U32 -> @+key:String -> @r:Pair(Map<&1, List<&1, Conn>>, Maybe<&1, List<&1, Conn>>) -> Pair(Pool, Maybe<&1, Conn>)

def pool.take source · line 2711 · raw

@p:Pool -> @+key:String -> Pair(Pool, Maybe<&1, Conn>)

The socket given back last.

def conn.close source · line 2715 · raw

@c:Conn -> IO(Unit)

def conns.cut source · line 2723 · raw

@xs:List<&1, Conn> -> @n:Nat -> IO(List<&1, Conn>)

The first n sockets; the rest are closed.

def pool.give.of source · line 2738 · raw

@+cap:U32 -> @+key:String -> @c:Conn -> @limit:Nat -> @r:Pair(Map<&1, List<&1, Conn>>, Maybe<&1, List<&1, Conn>>) -> IO(Pool)

def pool.give source · line 2746 · raw

@p:Pool -> @+key:String -> @c:Conn -> IO(Pool)

Past the limit (cap for HTTP/1.1, one session for HTTP/2), close the oldest idle connection.

def pool.close.go source · line 2755 · raw

@xs:List<&1, List<&1, Conn>> -> IO(Unit)

def pool.close source · line 2764 · raw

@p:Pool -> IO(Unit)

def pool.idempotent source · line 2769 · raw

@+method:String -> Bool

RFC 9110 §9.2.2

def conn.tls source · line 2772 · raw

@m:Pair(Socket, Result<&1, &1, Pair(U32, String), Unit>) -> IO(Result<&1, &1, Err, Conn>)

def conn.h2.sent source · line 2782 · raw

@client:0xc0a30c11b68a9aafb25795f94a58eba5/http2.Client -> @r:Pair(Socket, Result<&1, &1, Pair(U32, String), Unit>) -> IO(Result<&1, &1, Err, Conn>)

def conn.h2.start source · line 2792 · raw

@s:Socket -> @r:Pair(0xc0a30c11b68a9aafb25795f94a58eba5/http2.Client, 0xb7603dcfa1d7f60d01e06c928738cc73/bytes.Bytes) -> IO(Result<&1, &1, Err, Conn>)

def conn.tls.protocol source · line 2798 · raw

@proto:String -> @s:Socket -> IO(Result<&1, &1, Err, Conn>)

def conn.tls.alpn source · line 2811 · raw

@m:Pair(Socket, Result<&1, &1, Pair(U32, String), String>) -> IO(Result<&1, &1, Err, Conn>)

def conn.secure.store source · line 2821 · raw

@offer:Bool -> @s:Socket -> @host:String -> @+ms:U32 -> IO(Result<&1, &1, Err, Conn>)

def conn.secure.file source · line 2834 · raw

@offer:Bool -> @s:Socket -> @host:String -> @+ms:U32 -> @+ca:String -> IO(Result<&1, &1, Err, Conn>)

def conn.secure.no.cert source · line 2848 · raw

@empty:Bool -> @offer:Bool -> @s:Socket -> @host:String -> @+ms:U32 -> @+ca:String -> IO(Result<&1, &1, Err, Conn>)

def conn.secure.tls source · line 2856 · raw

@cert:Maybe<&2, Cert> -> @s:Socket -> @host:String -> @+ms:U32 -> @offer:Bool -> @+ca:String -> IO(Result<&1, &1, Err, Conn>)

def conn.secure source · line 2868 · raw

@+ms:U32 -> @sni:String -> @s:Socket -> @tls:Bool -> @cert:Maybe<&2, Cert> -> @offer:Bool -> @+ca:String -> IO(Result<&1, &1, Err, Conn>)

A failed handshake is an error, never plaintext.

def conn.made source · line 2876 · raw

@+ms:U32 -> @sni:String -> @tls:Bool -> @cert:Maybe<&2, Cert> -> @offer:Bool -> @+ca:String -> @r:Result<&1, &1, Pair(U32, String), Socket> -> IO(Result<&1, &1, Err, Conn>)

def conn.open source · line 2885 · raw

@+tls:Bool -> @+ms:U32 -> @sni:String -> @ip:String -> @port:U32 -> IO(Result<&1, &1, Err, Conn>)

def conn.dial.time source · line 2895 · raw

@+ip:String -> @+port:U32 -> @+deadline:Nat -> @now:Nat -> @expired:Bool -> IO(Result<&1, &1, Pair(U32, String), Socket>)

def conn.dial.with source · line 2903 · raw

@+ip:String -> @+port:U32 -> @+ms:U32 -> @+deadline:Nat -> @+now:Nat -> @unlimited:Bool -> IO(Result<&1, &1, Pair(U32, String), Socket>)

def conn.dial.try source · line 2911 · raw

@+ip:String -> @+port:U32 -> @+ms:U32 -> @+deadline:Nat -> IO(Result<&1, &1, Pair(U32, String), Socket>)

def conn.dial.after source · line 2917 · raw

@r:Result<&1, &1, Pair(U32, String), Socket> -> @ip:String -> @+port:U32 -> @+ms:U32 -> @+deadline:Nat -> IO(Result<&1, &1, Pair(U32, String), Socket>)

def conn.dial.more source · line 2925 · raw

@prev:IO(Result<&1, &1, Pair(U32, String), Socket>) -> @ip:String -> @+port:U32 -> @+ms:U32 -> @+deadline:Nat -> IO(Result<&1, &1, Pair(U32, String), Socket>)

def conn.dial.fold source · line 2931 · raw

@d:Dial -> @ip:String -> Dial

def conn.dial.run source · line 2935 · raw

@d:Dial -> IO(Result<&1, &1, Pair(U32, String), Socket>)

def conn.dial.all source · line 2939 · raw

@+port:U32 -> @+ms:U32 -> @+start:Nat -> @first:String -> @rest:List<&2, String> -> IO(Result<&1, &1, Pair(U32, String), Socket>)

def conn.open.all source · line 2949 · raw

@+tls:Bool -> @+ms:U32 -> @+host:String -> @+port:U32 -> @ips:List<&2, String> -> @cert:Maybe<&2, Cert> -> @offer:Bool -> @+ca:String -> IO(Result<&1, &1, Err, Conn>)

def proxy.auth.safe source · line 2961 · raw

@s:String -> Bool

def proxy.auth.checked source · line 2968 · raw

@+decoded:String -> @valid:Bool -> Maybe<&2, String>

def proxy.auth.value source · line 2975 · raw

@m:Maybe<&2, String> -> Maybe<&2, String>

def proxy.from.abs source · line 2982 · raw

@authorization:String -> @m:Maybe<&2, 0x1f2d80f53f971b16c6de6a65cb1918ae/url.Abs> -> Maybe<&2, Proxy>

def proxy.from.user source · line 2989 · raw

@user:String -> @host:String -> Maybe<&2, Proxy>

def proxy.from.authority source · line 2994 · raw

@has_user:Bool -> @authority:String -> @split:Pair(String, String) -> Maybe<&2, Proxy>

def proxy.from.parts source · line 3003 · raw

@parts:Pair(String, String) -> Maybe<&2, Proxy>

def proxy.from.url.if source · line 3011 · raw

@valid:Bool -> @raw:String -> Maybe<&2, Proxy>

def proxy.from.url source · line 3018 · raw

@+raw:String -> Maybe<&2, Proxy>

def proxy.no.domain source · line 3021 · raw

@+host:String -> @+suffix:String -> Bool

def proxy.no.suffix source · line 3024 · raw

@+host:String -> @+raw:String -> Bool

def proxy.no.port source · line 3031 · raw

@valid:Bool -> @+host:String -> @suffix:String -> Bool

def proxy.no.named source · line 3038 · raw

@+host:String -> @+port:U32 -> @parts:Pair(String, String) -> Bool

def proxy.no.literal source · line 3046 · raw

@+host:String -> @+port:U32 -> @+name:String -> Bool

def proxy.no.token source · line 3051 · raw

@+host:String -> @+port:U32 -> @token:String -> Bool

def proxy.no.list source · line 3058 · raw

@xs:List<&2, String> -> @+host:String -> @+port:U32 -> Bool

def proxy.no_match source · line 3065 · raw

@+host:String -> @+port:U32 -> @no_proxy:String -> Bool

def proxy.env.value source · line 3068 · raw

@r:Result<&1, &1, Pair(U32, String), String> -> String

def proxy.env.lower source · line 3075 · raw

@r:Result<&1, &1, Pair(U32, String), String> -> @upper:String -> IO(String)

def proxy.env source · line 3085 · raw

@lower:String -> @upper:String -> IO(String)

def proxy.from.env source · line 3090 · raw

@value:String -> Maybe<&2, Proxy>

def proxy.choose source · line 3097 · raw

@bypass:Bool -> @value:String -> Maybe<&2, Proxy>

def proxy.select source · line 3104 · raw

@+scheme:String -> @+host:String -> @+port:U32 -> IO(Maybe<&2, Proxy>)

@+name:String -> Bool

@+name:String -> U32

@+name:String -> @+mode:U32 -> @vs:List<&2, String> -> List<&2, 0xc0a30c11b68a9aafb25795f94a58eba5/hpack.Field>

@vs:List<&2, String> -> List<&2, String>

@enabled:Bool -> @vs:List<&2, String> -> @rest:List<&2, String> -> List<&2, String>

@xs:List<&2, Sigma<&2, &2, String, _ => List<&2, String>>> -> List<&2, String>

@xs:List<&2, String> -> @+key:String -> Bool

@skip:Bool -> @+name:String -> @vs:List<&2, String> -> @tail:List<&2, 0xc0a30c11b68a9aafb25795f94a58eba5/hpack.Field> -> List<&2, 0xc0a30c11b68a9aafb25795f94a58eba5/hpack.Field>

@xs:List<&2, Sigma<&2, &2, String, _ => List<&2, String>>> -> @+nominated:List<&2, String> -> List<&2, 0xc0a30c11b68a9aafb25795f94a58eba5/hpack.Field>

def h2.request.fields source · line 3185 · raw

@+method:String -> @target:String -> @authority:String -> @headers:Map<&2, List<&2, String>> -> List<&2, 0xc0a30c11b68a9aafb25795f94a58eba5/hpack.Field>

def h2.response.status.value source · line 3193 · raw

@+value:String -> @valid:Bool -> Maybe<&2, U32>

def h2.response.status source · line 3200 · raw

@xs:List<&2, 0xc0a30c11b68a9aafb25795f94a58eba5/hpack.Field> -> Maybe<&2, U32>

def h2.response.headers source · line 3211 · raw

@xs:List<&2, 0xc0a30c11b68a9aafb25795f94a58eba5/hpack.Field> -> @acc:Map<&2, List<&2, String>> -> Map<&2, List<&2, String>>

def h2.response.final source · line 3223 · raw

@interim:Bool -> @+status:U32 -> @headers:List<&2, 0xc0a30c11b68a9aafb25795f94a58eba5/hpack.Field> -> @body:0xb7603dcfa1d7f60d01e06c928738cc73/bytes.Bytes -> Result<&1, &1, Err, Maybe<&1, Res>>

def h2.response.valid source · line 3232 · raw

@valid:Bool -> @+status:U32 -> @headers:List<&2, 0xc0a30c11b68a9aafb25795f94a58eba5/hpack.Field> -> @body:0xb7603dcfa1d7f60d01e06c928738cc73/bytes.Bytes -> Result<&1, &1, Err, Maybe<&1, Res>>

def h2.response.parsed source · line 3240 · raw

@m:Maybe<&2, U32> -> @headers:List<&2, 0xc0a30c11b68a9aafb25795f94a58eba5/hpack.Field> -> @body:0xb7603dcfa1d7f60d01e06c928738cc73/bytes.Bytes -> Result<&1, &1, Err, Maybe<&1, Res>>

def h2.response source · line 3249 · raw

@+fields:List<&2, 0xc0a30c11b68a9aafb25795f94a58eba5/hpack.Field> -> @body:0xb7603dcfa1d7f60d01e06c928738cc73/bytes.Bytes -> Result<&1, &1, Err, Maybe<&1, Res>>

def h2.event.fold source · line 3253 · raw

@acc:Result<&1, &1, Err, Maybe<&1, Res>> -> @event:0xc0a30c11b68a9aafb25795f94a58eba5/http2.ClientEvent -> Result<&1, &1, Err, Maybe<&1, Res>>

def h2.send.report source · line 3271 · raw

@r:Pair(Socket, Result<&1, &1, Pair(U32, String), Unit>) -> IO(Result<&1, &1, Err, Socket>)

def h2.send.one source · line 3282 · raw

@prev:Result<&1, &1, Err, Socket> -> @b:0xb7603dcfa1d7f60d01e06c928738cc73/bytes.Bytes -> IO(Result<&1, &1, Err, Socket>)

def h2.send.fold source · line 3293 · raw

@prev:IO(Result<&1, &1, Err, Socket>) -> @b:0xb7603dcfa1d7f60d01e06c928738cc73/bytes.Bytes -> IO(Result<&1, &1, Err, Socket>)

def h2.send source · line 3299 · raw

@xs:List<&1, 0xb7603dcfa1d7f60d01e06c928738cc73/bytes.Bytes> -> @s:Socket -> IO(Result<&1, &1, Err, Socket>)

def h2.received.step source · line 3303 · raw

@over:Bool -> @s:Socket -> @client:0xc0a30c11b68a9aafb25795f94a58eba5/http2.Client -> @+len:U32 -> @buf:Array<U32> -> H2Step

def h2.fail source · line 3311 · raw

@s:Socket -> @e:Err -> IO(Result<&1, &1, Err, Pair(Conn, Res)>)

def h2.loop source · line 3316 · raw

@n:Nat -> @step:H2Step -> @+ms:U32 -> @+used:U32 -> IO(Result<&1, &1, Err, Pair(Conn, Res)>)

def h2.exchange source · line 3375 · raw

@s:Socket -> @client:0xc0a30c11b68a9aafb25795f94a58eba5/http2.Client -> @+ms:U32 -> @request:Send -> IO(Result<&1, &1, Err, Pair(Conn, Res)>)

def proxy.connect.fail source · line 3383 · raw

@s:Socket -> @e:Err -> IO(Result<&1, &1, Err, Conn>)

def proxy.connect.extra source · line 3388 · raw

@m:Maybe<&2, String> -> @s:Socket -> @+ms:U32 -> @sni:String -> @cert:Maybe<&2, Cert> -> @+ca:String -> IO(Result<&1, &1, Err, Conn>)

def proxy.connect.status source · line 3400 · raw

@ok:Bool -> @+status:U32 -> @raw:String -> @s:Socket -> @+ms:U32 -> @sni:String -> @cert:Maybe<&2, Cert> -> @+ca:String -> IO(Result<&1, &1, Err, Conn>)

def proxy.connect.finish source · line 3409 · raw

@res:Res -> @raw:String -> @s:Socket -> @+ms:U32 -> @sni:String -> @cert:Maybe<&2, Cert> -> @+ca:String -> IO(Result<&1, &1, Err, Conn>)

def proxy.connect.frame source · line 3415 · raw

@raw:String -> @over:Bool -> Frame

def proxy.connect.chunk source · line 3422 · raw

@empty:Bool -> @s:Socket -> @raw:String -> @+len:U32 -> @buf:Array<U32> -> TunnelStep

def proxy.connect.loop source · line 3430 · raw

@n:Nat -> @step:TunnelStep -> @+ms:U32 -> @+sni:String -> @+cert:Maybe<&2, Cert> -> @+ca:String -> IO(Result<&1, &1, Err, Conn>)

def proxy.connect.header source · line 3468 · raw

@+authority:String -> @authorization:String -> String

def proxy.connect.sent source · line 3476 · raw

@r:Pair(Socket, Result<&1, &1, Pair(U32, String), Unit>) -> @+ms:U32 -> @sni:String -> @cert:Maybe<&2, Cert> -> @+ca:String -> IO(Result<&1, &1, Err, Conn>)

def proxy.connect source · line 3486 · raw

@s:Socket -> @+ms:U32 -> @sni:String -> @authority:String -> @authorization:String -> @cert:Maybe<&2, Cert> -> @+ca:String -> IO(Result<&1, &1, Err, Conn>)

def proxy.route.tls source · line 3494 · raw

@tls:Bool -> @s:Socket -> @+ms:U32 -> @sni:String -> @authority:String -> @authorization:String -> @cert:Maybe<&2, Cert> -> @+ca:String -> IO(Result<&1, &1, Err, Conn>)

def proxy.route.connected source · line 3503 · raw

@tls:Bool -> @+ms:U32 -> @sni:String -> @authority:String -> @authorization:String -> @cert:Maybe<&2, Cert> -> @+ca:String -> @r:Result<&1, &1, Err, Conn> -> IO(Result<&1, &1, Err, Conn>)

def proxy.route.open source · line 3518 · raw

@+ms:U32 -> @+tls:Bool -> @+host:String -> @+port:U32 -> @+sni:String -> @+authority:String -> @+authorization:String -> @cert:Maybe<&2, Cert> -> @+ca:String -> IO(Result<&1, &1, Err, Conn>)

def route.open source · line 3527 · raw

@+ms:U32 -> @route:Route -> IO(Result<&1, &1, Err, Conn>)

def conn.ex.h1 source · line 3536 · raw

@+tls:Bool -> @s:Socket -> @+ms:U32 -> @request:Send -> IO(Out)

def pool.keep.s source · line 3542 · raw

@p:Pool -> @+key:String -> @+tls:Bool -> @res:Res -> @s:Socket -> @clean:Bool -> IO(Pair(Pool, Result<&1, &1, Err, Res>))

A socket with bytes past the response is out of step with the server, so it is closed.

def pool.keep.m source · line 3553 · raw

@p:Pool -> @+key:String -> @+tls:Bool -> @res:Res -> @+clean:Bool -> @sock:Maybe<&1, Socket> -> IO(Pair(Pool, Result<&1, &1, Err, Res>))

def pool.keep source · line 3560 · raw

@p:Pool -> @+key:String -> @+tls:Bool -> @res:Res -> @sock:Maybe<&1, Socket> -> @rest:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> IO(Pair(Pool, Result<&1, &1, Err, Res>))

def pool.after source · line 3564 · raw

@p:Pool -> @+key:String -> @+tls:Bool -> @o:Out -> IO(Pair(Pool, Result<&1, &1, Err, Res>))

def pool.h2.reusable source · line 3571 · raw

@c:Conn -> Pair(Bool, Conn)

def pool.h2.keep source · line 3581 · raw

@p:Pool -> @+key:String -> @res:Res -> @state:Pair(Bool, Conn) -> IO(Pair(Pool, Result<&1, &1, Err, Res>))

def pool.h2.result source · line 3594 · raw

@p:Pool -> @+key:String -> @r:Result<&1, &1, Err, Pair(Conn, Res)> -> IO(Pair(Pool, Result<&1, &1, Err, Res>))

def pool.h2.ex source · line 3602 · raw

@p:Pool -> @+key:String -> @+ms:U32 -> @request:Send -> @s:Socket -> @client:0xc0a30c11b68a9aafb25795f94a58eba5/http2.Client -> IO(Pair(Pool, Result<&1, &1, Err, Res>))

def pool.fresh.conn source · line 3608 · raw

@p:Pool -> @+key:String -> @+ms:U32 -> @request:Send -> @r:Result<&1, &1, Err, Conn> -> IO(Pair(Pool, Result<&1, &1, Err, Res>))

def pool.fresh source · line 3622 · raw

@p:Pool -> @+key:String -> @+ms:U32 -> @request:Send -> @route:Route -> IO(Pair(Pool, Result<&1, &1, Err, Res>))

def pool.retry source · line 3629 · raw

@+none:Bool -> @+idem:Bool -> Bool

A reused socket the server already closed fails before any response byte.

def pool.stale source · line 3632 · raw

@p:Pool -> @+key:String -> @+ms:U32 -> @request:Send -> @e:Err -> @again:Bool -> @route:Route -> IO(Pair(Pool, Result<&1, &1, Err, Res>))

def pool.reused source · line 3641 · raw

@p:Pool -> @+key:String -> @+tls:Bool -> @+ms:U32 -> @+idem:Bool -> @spare:Send -> @o:Out -> @route:Route -> IO(Pair(Pool, Result<&1, &1, Err, Res>))

def pool.idle.h1.bodies source · line 3651 · raw

@p:Pool -> @+key:String -> @+tls:Bool -> @+ms:U32 -> @+idem:Bool -> @s:Socket -> @+method:String -> @+target:String -> @+authority:String -> @+headers:Map<&2, List<&2, String>> -> @r:Pair(0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes) -> @route:Route -> IO(Pair(Pool, Result<&1, &1, Err, Res>))

Copy only the reused HTTP/1.1 request body, for a stale-socket retry.

def pool.idle.h1 source · line 3661 · raw

@p:Pool -> @+key:String -> @+tls:Bool -> @+ms:U32 -> @+idem:Bool -> @s:Socket -> @request:Send -> @route:Route -> IO(Pair(Pool, Result<&1, &1, Err, Res>))

def pool.idle.reuse source · line 3668 · raw

@p:Pool -> @+key:String -> @+ms:U32 -> @+idem:Bool -> @c:Conn -> @request:Send -> @route:Route -> IO(Pair(Pool, Result<&1, &1, Err, Res>))

def pool.idle source · line 3677 · raw

@taken:Pair(Pool, Maybe<&1, Conn>) -> @+key:String -> @+ms:U32 -> @+idem:Bool -> @request:Send -> @route:Route -> IO(Pair(Pool, Result<&1, &1, Err, Res>))

def proxy.http.headers source · line 3687 · raw

@headers:Map<&2, List<&2, String>> -> @authorization:String -> Map<&2, List<&2, String>>

def proxy.absolute source · line 3695 · raw

@scheme:String -> @host_field:String -> @target:String -> String

def proxy.request source · line 3698 · raw

@secure:Bool -> @+scheme:String -> @method:String -> @+target:String -> @+hf:String -> @headers:Map<&2, List<&2, String>> -> @body:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @authorization:String -> Send

def pool.origin.proxy source · line 3709 · raw

@p:Pool -> @+method:String -> @+ms:U32 -> @headers:Map<&2, List<&2, String>> -> @body:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @+hf:String -> @+scheme:String -> @+host:String -> @+port:U32 -> @+target:String -> @+cert:Maybe<&2, Cert> -> @+ca:String -> @proxy:Proxy -> IO(Pair(Pool, Result<&1, &1, Err, Res>))

def pool.origin.choice source · line 3731 · raw

@p:Pool -> @method:String -> @ms:U32 -> @headers:Map<&2, List<&2, String>> -> @body:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @hf:String -> @scheme:String -> @host:String -> @port:U32 -> @target:String -> @cert:Maybe<&2, Cert> -> @+ca:String -> @choice:Maybe<&2, Proxy> -> IO(Pair(Pool, Result<&1, &1, Err, Res>))

def pool.origin source · line 3743 · raw

@p:Pool -> @method:String -> @ms:U32 -> @headers:Map<&2, List<&2, String>> -> @body:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @hf:String -> @a:0x1f2d80f53f971b16c6de6a65cb1918ae/url.Abs -> @known:Bool -> @cert:Maybe<&2, Cert> -> @+ca:String -> @choice:Maybe<&2, Proxy> -> IO(Pair(Pool, Result<&1, &1, Err, Res>))

def pool.scheme.ok source · line 3756 · raw

@a:0x1f2d80f53f971b16c6de6a65cb1918ae/url.Abs -> Bool

def pool.one.back source · line 3760 · raw

@h:Hop -> @pr:Pair(Pool, Result<&1, &1, Err, Res>) -> Pair(Pool, Pair(Result<&1, &1, Err, Res>, Hop))

def pool.one.of source · line 3765 · raw

@p:Pool -> @+method:String -> @+url:0x1f2d80f53f971b16c6de6a65cb1918ae/url.Abs -> @headers:Map<&2, List<&2, String>> -> @sent:Map<&2, List<&2, String>> -> @+ms:U32 -> @r:Pair(0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes) -> @cert:Maybe<&2, Cert> -> @+ca:String -> IO(Pair(Pool, Pair(Result<&1, &1, Err, Res>, Hop)))

sent is headers plus any jar cookies; the hop keeps headers, so cookies never pile up across hops.

def pool.one source · line 3779 · raw

@p:Pool -> @h:Hop -> @+ms:U32 -> @cert:Maybe<&2, Cert> -> @+ca:String -> @jar:Maybe<&2, Jar> -> IO(Pair(Pool, Pair(Result<&1, &1, Err, Res>, Hop)))

One request, on an idle socket to its origin when the pool has one. The hop comes back for the redirect.

def fetch.hop source · line 3794 · raw

@left:Nat -> @h:Hop -> Next

left: redirects still allowed after the request we just finished.

def fetch.decide.r source · line 3801 · raw

@left:Nat -> @r:Res -> @next:Maybe<&1, Hop> -> Next

def fetch.decide.res source · line 3808 · raw

@left:Nat -> @h:Hop -> @r:Res -> Next

def fetch.decide source · line 3812 · raw

@left:Nat -> @h:Hop -> @m:Result<&1, &1, Err, Res> -> Next

def fetch.error.res source · line 3819 · raw

@r:Res -> @bad:Bool -> Next

def fetch.error source · line 3826 · raw

@h:Hop -> @m:Result<&1, &1, Err, Res> -> Next

def fetch.policy source · line 3834 · raw

@mode:Mode -> @left:Nat -> @h:Hop -> @m:Result<&1, &1, Err, Res> -> Next

def accept.enc source · line 3844 · raw

@+h:Map<&2, List<&2, String>> -> @+enc:String -> Map<&2, List<&2, String>>

A caller's own Accept-Encoding wins; enc is the codings fetch can undo.

def fetch.start source · line 3847 · raw

@method:String -> @headers:Map<&2, List<&2, String>> -> @body:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @u:Maybe<&2, 0x1f2d80f53f971b16c6de6a65cb1918ae/url.Abs> -> @+enc:String -> Next

def pool.next.ca source · line 3858 · raw

@same:Bool -> @+ca:String -> String

def pool.next.move source · line 3865 · raw

@p:Pool -> @+old:String -> @cert:Maybe<&2, Cert> -> @jar:Maybe<&2, Jar> -> @+ca:String -> @n:Next -> Hops

def pool.next.of source · line 3877 · raw

@+mode:Mode -> @left:Nat -> @cert:Maybe<&2, Cert> -> @+ca:String -> @p:Pool -> @+url:0x1f2d80f53f971b16c6de6a65cb1918ae/url.Abs -> @h:Hop -> @r:Pair(Maybe<&2, Jar>, Result<&1, &1, Err, Res>) -> Hops

def pool.next source · line 3882 · raw

@+mode:Mode -> @left:Nat -> @cert:Maybe<&2, Cert> -> @+ca:String -> @jar:Maybe<&2, Jar> -> @x:Pair(Pool, Pair(Result<&1, &1, Err, Res>, Hop)) -> Hops

The jar takes the response's Set-Cookie fields first, redirect or not.

def pool.hops.one source · line 3887 · raw

@+mode:Mode -> @+ms:U32 -> @+cert:Maybe<&2, Cert> -> @+ca:String -> @+jar:Maybe<&2, Jar> -> @p:Pool -> @h:Hop -> @left:Nat -> IO(Hops)

def ce.keep source · line 3908 · raw

@+w:String -> @+rest:List<&2, String> -> List<&2, String>

Content-Encoding (RFC 9110 §8.4): each value, trimmed and lowercased, in the order applied.

def ce.norm source · line 3911 · raw

@xs:List<&2, String> -> List<&2, String>

def ce.split source · line 3918 · raw

@xs:List<&2, String> -> List<&2, String>

def ce.of source · line 3931 · raw

@m:Maybe<&2, String> -> Dec

def ce.deflate source · line 3939 · raw

@+b:String -> @m:Maybe<&2, String> -> Dec

Servers send deflate both with and without the zlib wrapper.

def ce.apply source · line 3946 · raw

@+c:String -> @+b:String -> Dec

def ce.go source · line 3951 · raw

@cs:List<&2, String> -> @d:Dec -> Dec

def decoded.pick source · line 3964 · raw

@d:Dec -> @+status:U32 -> @headers:Map<&2, List<&2, String>> -> @body:String -> Result<&1, &1, Err, Res>

def decoded.cs source · line 3974 · raw

@+status:U32 -> @+headers:Map<&2, List<&2, String>> -> @body:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @cs:List<&2, String> -> Result<&1, &1, Err, Res>

ponytail: the codings run on a String copy of the body; give zlib a Bytes input if gzip bodies get big.

def decoded.go source · line 3982 · raw

@empty:Bool -> @+status:U32 -> @+headers:Map<&2, List<&2, String>> -> @body:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> Result<&1, &1, Err, Res>

def decoded source · line 3990 · raw

@res:Res -> Result<&1, &1, Err, Res>

The body decoded per Content-Encoding; the headers stay as sent. A corrupt body is ErrBad.

def decoded.m source · line 3995 · raw

@r:Result<&1, &1, Err, Res> -> Maybe<&1, Res>

def decoded.some source · line 4002 · raw

@res:Res -> Maybe<&1, Res>

def ce.words source · line 4005 · raw

@r:Result<&1, &1, Pair(U32, String), Pair(U32, Array<U32>)> -> Maybe<&1, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes>

def ce.dec source · line 4019 · raw

@d:Dec -> Maybe<&1, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes>

def ce.io.deflate source · line 4029 · raw

@on:Bool -> @b:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> IO(Maybe<&1, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes>)

ponytail: deflate runs on the pure decoder, which also takes raw DEFLATE; servers rarely send it.

def ce.io.zstd source · line 4037 · raw

@on:Bool -> @+c:String -> @b:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> IO(Maybe<&1, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes>)

def ce.io.br source · line 4044 · raw

@on:Bool -> @+c:String -> @b:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> IO(Maybe<&1, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes>)

def ce.io.gz source · line 4052 · raw

@on:Bool -> @+c:String -> @b:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> IO(Maybe<&1, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes>)

One known coding undone: gzip, x-gzip, br, zstd, deflate, or identity.

def ce.io.go source · line 4059 · raw

@cs:List<&2, String> -> @m:Maybe<&1, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes> -> IO(Maybe<&1, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes>)

def ce.has source · line 4076 · raw

@xs:List<&2, String> -> @+c:String -> Bool

def ce.known source · line 4083 · raw

@cs:List<&2, String> -> @+ok:List<&2, String> -> Bool

def decoded.io.pick source · line 4090 · raw

@m:Maybe<&1, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes> -> @+status:U32 -> @headers:Map<&2, List<&2, String>> -> Result<&1, &1, Err, Res>

def decoded.io.run source · line 4097 · raw

@known:Bool -> @+status:U32 -> @+headers:Map<&2, List<&2, String>> -> @body:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @cs:List<&2, String> -> IO(Result<&1, &1, Err, Res>)

def decoded.io.go source · line 4106 · raw

@empty:Bool -> @+enc:String -> @+status:U32 -> @+headers:Map<&2, List<&2, String>> -> @body:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> IO(Result<&1, &1, Err, Res>)

def decoded.io source · line 4115 · raw

@+enc:String -> @res:Res -> IO(Result<&1, &1, Err, Res>)

decoded through the C libraries, for the codings in enc. A body with any other coding stays as sent.

def codings.ok source · line 4121 · raw

@r:Result<&1, &1, Pair(U32, String), Pair(U32, Array<U32>)> -> Bool

An effect on empty input fails with ENOENT only when its library does not load.

def codings.add source · line 4134 · raw

@has:Bool -> @+enc:String -> @+c:String -> String

def codings source · line 4138 · raw

IO(String)

gzip and deflate, then br and zstd when their C library loads.

def fetch.final source · line 4145 · raw

@+enc:String -> @r:Result<&1, &1, Err, Res> -> IO(Result<&1, &1, Err, Res>)

The final response of a fetch, after redirects.

def pool.final source · line 4152 · raw

@+enc:String -> @pr:Pair(Pool, Pair(Result<&1, &1, Err, Res>, Maybe<&2, Jar>)) -> IO(Pair(Pool, Result<&1, &1, Err, Res>))

def pool.how.enc source · line 4158 · raw

@+enc:String -> @p:Pool -> @method:String -> @url:String -> @headers:Map<&2, List<&2, String>> -> @body:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @ms:U32 -> @mode:Mode -> @cert:Maybe<&2, Cert> -> @+ca:String -> IO(Pair(Pool, Result<&1, &1, Err, Res>))

def pool.how.cert source · line 4163 · raw

@p:Pool -> @method:String -> @url:String -> @headers:Map<&2, List<&2, String>> -> @body:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @ms:U32 -> @mode:Mode -> @cert:Maybe<&2, Cert> -> IO(Pair(Pool, Result<&1, &1, Err, Res>))

def pool.how source · line 4171 · raw

@p:Pool -> @method:String -> @url:String -> @headers:Map<&2, List<&2, String>> -> @body:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @ms:U32 -> @mode:Mode -> IO(Pair(Pool, Result<&1, &1, Err, Res>))

pool.how(p, "GET", "https://example.com/x?y=1", headers, body, ms, mode) follows redirects on p's idle sockets. Fail is a bad URL, a failed lookup, connect, handshake, send, read, a malformed response, more than 20 redirects, or a step past ms. Bodies are bytes.

def pool.fetch.with source · line 4174 · raw

@p:Pool -> @method:String -> @url:String -> @headers:Map<&2, List<&2, String>> -> @body:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @ms:U32 -> IO(Pair(Pool, Result<&1, &1, Err, Res>))

def pool.fetch source · line 4177 · raw

@p:Pool -> @method:String -> @url:String -> @headers:Map<&2, List<&2, String>> -> @body:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> IO(Pair(Pool, Result<&1, &1, Err, Res>))

def pool.fetch.cert.with source · line 4180 · raw

@p:Pool -> @method:String -> @url:String -> @headers:Map<&2, List<&2, String>> -> @body:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @chain:String -> @key:String -> @ms:U32 -> IO(Pair(Pool, Result<&1, &1, Err, Res>))

def pool.fetch.cert source · line 4183 · raw

@p:Pool -> @method:String -> @url:String -> @headers:Map<&2, List<&2, String>> -> @body:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @chain:String -> @key:String -> IO(Pair(Pool, Result<&1, &1, Err, Res>))

def pool.fetch.ca.with source · line 4186 · raw

@p:Pool -> @method:String -> @url:String -> @headers:Map<&2, List<&2, String>> -> @body:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @ca:String -> @ms:U32 -> IO(Pair(Pool, Result<&1, &1, Err, Res>))

def pool.fetch.ca source · line 4191 · raw

@p:Pool -> @method:String -> @url:String -> @headers:Map<&2, List<&2, String>> -> @body:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @ca:String -> IO(Pair(Pool, Result<&1, &1, Err, Res>))

def fetch.all.job source · line 4198 · raw

@p:Pool -> @f:Fetch -> IO(Pair(Pool, Result<&1, &1, Err, Res>))

def fetch.all.pools source · line 4202 · raw

@n:Nat -> List<&1, Pool>

def fetch.all.close source · line 4209 · raw

@ps:List<&1, Pool> -> IO(Unit)

def fetch.all.done source · line 4218 · raw

@r:Pair(List<&1, Pool>, List<&1, Result<&1, &1, Err, Res>>) -> IO(List<&1, Result<&1, &1, Err, Res>>)

def fetch.all.go source · line 4225 · raw

@xs:List<&1, Fetch> -> @+workers:Nat -> IO(List<&1, Result<&1, &1, Err, Res>>)

No requests start no workers, since Conc.pool needs at least one.

def fetch.all.of source · line 4235 · raw

@+n:U32 -> @nx:Pair(Nat, List<&1, Fetch>) -> IO(List<&1, Result<&1, &1, Err, Res>>)

def fetch.all source · line 4243 · raw

@reqs:List<&1, Fetch> -> @+n:U32 -> IO(List<&1, Result<&1, &1, Err, Res>>)

Each request as fetch would make it, on at most n workers (0 counts as 1, and never more workers than requests). Each worker owns its own Pool, so an idle socket is reused only by the worker that opened it; every pool is closed at the end. Results come back in the order of reqs.

def pool.jar.final source · line 4247 · raw

@+enc:String -> @j:Jar -> @pr:Pair(Pool, Pair(Result<&1, &1, Err, Res>, Maybe<&2, Jar>)) -> IO(Pair(Pool, Pair(Jar, Result<&1, &1, Err, Res>)))

The hops always hand the jar back; j is only the type's fallback.

def pool.jar.enc source · line 4253 · raw

@+enc:String -> @p:Pool -> @+j:Jar -> @method:String -> @url:String -> @headers:Map<&2, List<&2, String>> -> @body:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> IO(Pair(Pool, Pair(Jar, Result<&1, &1, Err, Res>)))

def pool.fetch.jar source · line 4261 · raw

@p:Pool -> @j:Jar -> @method:String -> @url:String -> @headers:Map<&2, List<&2, String>> -> @body:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> IO(Pair(Pool, Pair(Jar, Result<&1, &1, Err, Res>)))

pool.fetch with a cookie jar (RFC 6265bis). Before every hop, redirects included, the jar's cookies for that URL join the request's cookie field; after every response, redirects included, its Set-Cookie fields go into the jar. The jar's clock is the caller's: advance it with jar.at.

def fetch.end source · line 4265 · raw

@pr:Pair(Pool, Result<&1, &1, Err, Res>) -> IO(Result<&1, &1, Err, Res>)

def fetch.how source · line 4272 · raw

@method:String -> @url:String -> @headers:Map<&2, List<&2, String>> -> @body:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @ms:U32 -> @mode:Mode -> IO(Result<&1, &1, Err, Res>)

fetch is pool.how on a fresh pool that closes afterwards.

def fetch.with source · line 4277 · raw

@method:String -> @url:String -> @headers:Map<&2, List<&2, String>> -> @body:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @ms:U32 -> IO(Result<&1, &1, Err, Res>)

def fetch.cert.with source · line 4280 · raw

@method:String -> @url:String -> @headers:Map<&2, List<&2, String>> -> @body:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @chain:String -> @key:String -> @ms:U32 -> IO(Result<&1, &1, Err, Res>)

def fetch.cert source · line 4285 · raw

@method:String -> @url:String -> @headers:Map<&2, List<&2, String>> -> @body:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @chain:String -> @key:String -> IO(Result<&1, &1, Err, Res>)

def fetch.ca.with source · line 4288 · raw

@method:String -> @url:String -> @headers:Map<&2, List<&2, String>> -> @body:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @ca:String -> @ms:U32 -> IO(Result<&1, &1, Err, Res>)

def fetch.ca source · line 4293 · raw

@method:String -> @url:String -> @headers:Map<&2, List<&2, String>> -> @body:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @ca:String -> IO(Result<&1, &1, Err, Res>)

def fetch source · line 4297 · raw

@method:String -> @url:String -> @headers:Map<&2, List<&2, String>> -> @body:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> IO(Result<&1, &1, Err, Res>)

fetch.with and a 30 s step timeout.

def get source · line 4300 · raw

@url:String -> IO(Result<&1, &1, Err, Res>)

def post.json source · line 4304 · raw

@url:String -> @v:0x584fc27920487ceab242392391418d7f/json.Val -> IO(Result<&1, &1, Err, Res>)

POST v as compact JSON, with content-type: application/json.

def resolve.show source · line 4309 · raw

@a:0x1f2d80f53f971b16c6de6a65cb1918ae/url.Abs -> String

Base URLs: resolve(base, ref) is ref against the absolute http(s) URL base (RFC 3986 §5.2), written back as a URL for fetch. None when base is not absolute or ref has another scheme.

def resolve.to source · line 4313 · raw

@m:Maybe<&2, 0x1f2d80f53f971b16c6de6a65cb1918ae/url.Abs> -> Maybe<&2, String>

def resolve.base source · line 4320 · raw

@m:Maybe<&2, 0x1f2d80f53f971b16c6de6a65cb1918ae/url.Abs> -> @+ref:String -> Maybe<&2, String>

def resolve source · line 4327 · raw

@base:String -> @+ref:String -> Maybe<&2, String>

def retry.cap source · line 4332 · raw

U32

Retry. The wait before retry n (0 first) is 500 ms doubled n times, at most 30 s; its upper half is jitter r: backoff(n, r) = half + r mod (half + 1).

def retry.base source · line 4335 · raw

@n:Nat -> U32

def retry.backoff.half source · line 4342 · raw

@+half:U32 -> @+r:U32 -> U32

def retry.backoff source · line 4345 · raw

@n:Nat -> @+r:U32 -> U32

def retry.after.ms source · line 4349 · raw

@+ms:0x4eed9d7ac6ece61523d747a9d804e4f0/int.I64 -> U32

ms clamped to 0 .. retry.cap().

def retry.after.date source · line 4353 · raw

@m:Maybe<&2, 0xe00bbf72c3ff9dc6d7b077524522b3a8/time.Instant> -> @now:0xe00bbf72c3ff9dc6d7b077524522b3a8/time.Instant -> Maybe<&2, U32>

def retry.after.secs source · line 4361 · raw

@+v:String -> @now:0xe00bbf72c3ff9dc6d7b077524522b3a8/time.Instant -> @n:Maybe<&2, U32> -> Maybe<&2, U32>

More than 5 digits is past the cap, and would overflow parse_u32.

def retry.after source · line 4370 · raw

@+v:String -> @now:0xe00bbf72c3ff9dc6d7b077524522b3a8/time.Instant -> Maybe<&2, U32>

Retry-After (RFC 9110 §10.2.3) as ms from now, at most retry.cap(): delay-seconds, or an HTTP-date (a past date is 0). None when v is empty or neither form.

def retry.wait source · line 4373 · raw

@m:Maybe<&2, U32> -> @n:Nat -> @+r:U32 -> U32

def retry.delay source · line 4381 · raw

@+v:String -> @now:0xe00bbf72c3ff9dc6d7b077524522b3a8/time.Instant -> @n:Nat -> @+r:U32 -> U32

The wait before retry n: Retry-After v when it reads as a delay, else backoff with jitter r.

def retry.status source · line 4385 · raw

@+s:U32 -> Bool

Statuses a later try may clear.

def retry.fail source · line 4390 · raw

@e:Err -> Pair(Result<&1, &1, Err, Res>, Maybe<&2, String>)

A refused connect or a timeout may clear; any other error would repeat.

def retry.res source · line 4399 · raw

@res:Res -> Pair(Result<&1, &1, Err, Res>, Maybe<&2, String>)

def retry.judge.try source · line 4403 · raw

@r:Result<&1, &1, Err, Res> -> Pair(Result<&1, &1, Err, Res>, Maybe<&2, String>)

def retry.judge source · line 4412 · raw

@idem:Bool -> @r:Result<&1, &1, Err, Res> -> Pair(Result<&1, &1, Err, Res>, Maybe<&2, String>)

One try, judged: the result as it came, and Some{Retry-After value} ("" when absent) when an idempotent request may try again.

def retry.jitter source · line 4420 · raw

@r:Result<&1, &1, Pair(U32, String), U32> -> U32

ponytail: a failed random source gives jitter 0, so the wait is the lower half.

def retry.sleep source · line 4427 · raw

@+v:String -> @n:Nat -> IO(Unit)

def retry.kept source · line 4433 · raw

@body:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @j:Pair(Result<&1, &1, Err, Res>, Maybe<&2, String>) -> Pair(0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes, Pair(Result<&1, &1, Err, Res>, Maybe<&2, String>))

def retry.one source · line 4438 · raw

@+idem:Bool -> @+method:String -> @+url:String -> @+headers:Map<&2, List<&2, String>> -> @r:Pair(0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes) -> IO(Pair(0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes, Pair(Result<&1, &1, Err, Res>, Maybe<&2, String>)))

One fetch of the copy; the body comes back for the next try.

def retry.go source · line 4446 · raw

@left:Nat -> @+n:Nat -> @+idem:Bool -> @+method:String -> @+url:String -> @+headers:Map<&2, List<&2, String>> -> @t:Pair(0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes, Pair(Result<&1, &1, Err, Res>, Maybe<&2, String>)) -> IO(Result<&1, &1, Err, Res>)

left: retries still allowed. n: the retry to wait for next, 0 first.

def retry.start source · line 4470 · raw

@enabled:Bool -> @n:U32 -> @+method:String -> @+url:String -> @+headers:Map<&2, List<&2, String>> -> @body:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> IO(Result<&1, &1, Err, Res>)

fetch.retry(n, method, url, headers, body) is fetch, tried again up to n times while an idempotent method (GET, HEAD, OPTIONS, TRACE, PUT, DELETE) gets a connect error, a timeout, or 408, 429, 500, 502, 503, or 504. POST, PATCH and other methods get one try. It waits Retry-After (seconds or HTTP-date, at most 30 s) when given, else the backoff. When retries run out, the last response or error comes back as it was.

def fetch.retry source · line 4482 · raw

@+n:U32 -> @+method:String -> @+url:String -> @+headers:Map<&2, List<&2, String>> -> @body:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> IO(Result<&1, &1, Err, Res>)

def pc.po source · line 4504 · raw

@more:Bool -> @empty:Bool -> @b:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> Po

A body piece, or none when empty: more reads the next piece, and not more is the end.

def pc.piece source · line 4511 · raw

@more:Bool -> @+rb:Rb -> @b:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> Pc

def pc.fed.of source · line 4515 · raw

@b:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @st:Rb -> Pc

def pc.fed source · line 4528 · raw

@bf:Bf -> Pc

def pc.of source · line 4533 · raw

@rb:Rb -> @piece:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> Pc

The body bytes that just arrived: what they add to the body, and how it ends.

def pc.end source · line 4537 · raw

@ok:Bool -> Pc

The server closed. Only a close-delimited body may end this way (RFC 9112 §8).

def pc.eof source · line 4544 · raw

@st:Rb -> Pc

def stream.mk source · line 4547 · raw

@+tls:Bool -> @s:Socket -> @+ms:U32 -> @res:Res -> @decs:List<&1, 0xcc180113489c489d3f5cdc852e6806f9/zlib.Decoder> -> @pc:Pc -> Stream

def stream.got.piece source · line 4551 · raw

@+tls:Bool -> @s:Socket -> @+ms:U32 -> @res:Res -> @decs:List<&1, 0xcc180113489c489d3f5cdc852e6806f9/zlib.Decoder> -> @+rb:Rb -> @p:Pair(U32, Array<U32>) -> Stream

def stream.got source · line 4555 · raw

@+tls:Bool -> @+ms:U32 -> @res:Res -> @decs:List<&1, 0xcc180113489c489d3f5cdc852e6806f9/zlib.Decoder> -> @+rb:Rb -> @m:Pair(Socket, Result<&1, &1, Pair(U32, String), Pair(U32, Array<U32>)>) -> Stream

def stream.after source · line 4563 · raw

@+rb:Rb -> Po

def stream.feed.received source · line 4579 · raw

@done:List<&1, 0xcc180113489c489d3f5cdc852e6806f9/zlib.Decoder> -> @m:Pair(0xcc180113489c489d3f5cdc852e6806f9/zlib.Decoder, Result<&1, &1, Pair(U32, String), Pair(U32, Array<U32>)>) -> Fed

def stream.feed.step source · line 4587 · raw

@st:Fed -> @d:0xcc180113489c489d3f5cdc852e6806f9/zlib.Decoder -> IO(Fed)

def stream.feed.one source · line 4599 · raw

@prev:IO(Fed) -> @d:0xcc180113489c489d3f5cdc852e6806f9/zlib.Decoder -> IO(Fed)

def stream.feed.reverse source · line 4604 · raw

@st:Fed -> Fed

def stream.feed.all source · line 4608 · raw

@decs:List<&1, 0xcc180113489c489d3f5cdc852e6806f9/zlib.Decoder> -> @b:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> IO(Fed)

def stream.ready source · line 4614 · raw

@empty:Bool -> @+rb:Rb -> @b:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> Po

def stream.feed.got source · line 4621 · raw

@+tls:Bool -> @s:Socket -> @+ms:U32 -> @res:Res -> @+rb:Rb -> @st:Fed -> Stream

def stream.feed.st source · line 4630 · raw

@st:Stream -> @b:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> IO(Stream)

def stream.finish.ok source · line 4640 · raw

@r:Result<&1, &1, Pair(U32, String), Unit> -> Bool

def stream.finish source · line 4647 · raw

@decs:List<&1, 0xcc180113489c489d3f5cdc852e6806f9/zlib.Decoder> -> IO(Bool)

def stream.ended source · line 4657 · raw

@good:Bool -> @+tls:Bool -> @s:Socket -> @+ms:U32 -> @res:Res -> @+rb:Rb -> Pair(Stream, Result<&1, &1, Err, Maybe<&1, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes>>)

def stream.res source · line 4690 · raw

@st:Stream -> Pair(Stream, Res)

Status and headers. Its body is empty: read the body with stream.read.

def stream.close source · line 4695 · raw

@st:Stream -> IO(Unit)

def sh.of source · line 4707 · raw

@hs:Hs -> Sh

def sh.piece source · line 4718 · raw

@+head:Bool -> @buf:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @+k:U32 -> @p:Pair(U32, Array<U32>) -> Sh

def sh.next source · line 4722 · raw

@+head:Bool -> @buf:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @+k:U32 -> @m:Pair(Socket, Result<&1, &1, Pair(U32, String), Pair(U32, Array<U32>)>) -> Pair(Socket, Sh)

def fetch.fail.of source · line 4730 · raw

@r:Result<&1, &1, Err, Res> -> Result<&1, &1, Err, Stream>

def stream.sent source · line 4753 · raw

@+tls:Bool -> @+ms:U32 -> @+head:Bool -> @m:Pair(Socket, Result<&1, &1, Pair(U32, String), Unit>) -> IO(Result<&1, &1, Err, Stream>)

def stream.conn source · line 4763 · raw

@r:Result<&1, &1, Err, Conn> -> @+ms:U32 -> @+head:Bool -> @wire:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> IO(Result<&1, &1, Err, Stream>)

def stream.origin source · line 4779 · raw

@+ms:U32 -> @+head:Bool -> @wire:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @a:0x1f2d80f53f971b16c6de6a65cb1918ae/url.Abs -> @known:Bool -> IO(Result<&1, &1, Err, Stream>)

One connection per stream; the request says close.

def stream.one.of source · line 4790 · raw

@+method:String -> @+url:0x1f2d80f53f971b16c6de6a65cb1918ae/url.Abs -> @+headers:Map<&2, List<&2, String>> -> @+ms:U32 -> @r:Pair(0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes) -> IO(Pair(Hop, Result<&1, &1, Err, Stream>))

def stream.one source · line 4798 · raw

@h:Hop -> @+ms:U32 -> IO(Pair(Hop, Result<&1, &1, Err, Stream>))

One request on its own connection. The hop comes back for the redirect.

def sn.of source · line 4808 · raw

@n:Next -> Sn

def stream.decide.n source · line 4821 · raw

@st:Stream -> @n:Next -> Sn

def stream.decide.of source · line 4830 · raw

@+left:Nat -> @hop:Hop -> @sr:Pair(Stream, Res) -> Sn

def stream.decide source · line 4834 · raw

@+left:Nat -> @x:Pair(Hop, Result<&1, &1, Err, Stream>) -> Sn

def stream.open.got source · line 4859 · raw

@st:Opened -> @r:Result<&1, &1, Pair(U32, String), 0xcc180113489c489d3f5cdc852e6806f9/zlib.Decoder> -> Opened

def stream.open.add source · line 4867 · raw

@st:Opened -> @m:IO(Result<&1, &1, Pair(U32, String), 0xcc180113489c489d3f5cdc852e6806f9/zlib.Decoder>) -> IO(Opened)

def stream.open.zstd source · line 4872 · raw

@zstd:Bool -> @st:Opened -> IO(Opened)

def stream.open.br source · line 4879 · raw

@br:Bool -> @+c:String -> @st:Opened -> IO(Opened)

def stream.open.gz source · line 4886 · raw

@gz:Bool -> @+c:String -> @st:Opened -> IO(Opened)

def stream.open.step source · line 4893 · raw

@+c:String -> @st:Opened -> IO(Opened)

def stream.open.one source · line 4902 · raw

@prev:IO(Opened) -> @c:String -> IO(Opened)

def stream.open.all source · line 4907 · raw

@cs:List<&2, String> -> IO(Opened)

def stream.put.decs source · line 4910 · raw

@st:Stream -> @decs:List<&1, 0xcc180113489c489d3f5cdc852e6806f9/zlib.Decoder> -> Stream

def stream.init.opened source · line 4914 · raw

@st:Stream -> @opened:Opened -> IO(Result<&1, &1, Err, Stream>)

def stream.init.known source · line 4924 · raw

@known:Bool -> @st:Stream -> @cs:List<&2, String> -> IO(Result<&1, &1, Err, Stream>)

def stream.init.st source · line 4933 · raw

@+enc:String -> @st:Stream -> IO(Result<&1, &1, Err, Stream>)

def stream.init source · line 4940 · raw

@+enc:String -> @r:Result<&1, &1, Err, Stream> -> IO(Result<&1, &1, Err, Stream>)

def stream.start source · line 4947 · raw

@method:String -> @headers:Map<&2, List<&2, String>> -> @body:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @u:Maybe<&2, 0x1f2d80f53f971b16c6de6a65cb1918ae/url.Abs> -> Sn

def open.raw.with source · line 4955 · raw

@method:String -> @url:String -> @headers:Map<&2, List<&2, String>> -> @body:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @+ms:U32 -> IO(Result<&1, &1, Err, Stream>)

Open a raw stream. Its body bytes and headers remain as sent.

def open.raw source · line 4958 · raw

@method:String -> @url:String -> @headers:Map<&2, List<&2, String>> -> @body:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> IO(Result<&1, &1, Err, Stream>)

def open.with.enc source · line 4961 · raw

@+enc:String -> @method:String -> @url:String -> @headers:Map<&2, List<&2, String>> -> @body:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @+ms:U32 -> IO(Result<&1, &1, Err, Stream>)

def open.with source · line 4968 · raw

@method:String -> @url:String -> @headers:Map<&2, List<&2, String>> -> @body:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @+ms:U32 -> IO(Result<&1, &1, Err, Stream>)

Follow redirects, then decode each body piece by Content-Encoding. Unknown codings stay raw.

def open source · line 4973 · raw

@method:String -> @url:String -> @headers:Map<&2, List<&2, String>> -> @body:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> IO(Result<&1, &1, Err, Stream>)

def hex.digit source · line 4980 · raw

@+n:U32 -> Char

def hex.go source · line 4983 · raw

@k:Nat -> @+n:U32 -> @acc:String -> String

def hex.trim source · line 4990 · raw

@+s:String -> String

def hex source · line 4997 · raw

@+n:U32 -> String

def up.sent source · line 5000 · raw

@+tls:Bool -> @+ms:U32 -> @+head:Bool -> @m:Pair(Socket, Result<&1, &1, Pair(U32, String), Unit>) -> Up

def up.conn source · line 5008 · raw

@r:Result<&1, &1, Err, Conn> -> @+ms:U32 -> @+head:Bool -> @wire:String -> IO(Result<&1, &1, Err, Up>)

def up.head source · line 5023 · raw

@+method:String -> @+target:String -> @+hf:String -> @+headers:Map<&2, List<&2, String>> -> String

def up.origin source · line 5026 · raw

@+method:String -> @+ms:U32 -> @headers:Map<&2, List<&2, String>> -> @a:0x1f2d80f53f971b16c6de6a65cb1918ae/url.Abs -> @known:Bool -> IO(Result<&1, &1, Err, Up>)

def up.url source · line 5037 · raw

@+method:String -> @+ms:U32 -> @headers:Map<&2, List<&2, String>> -> @u:Maybe<&2, 0x1f2d80f53f971b16c6de6a65cb1918ae/url.Abs> -> IO(Result<&1, &1, Err, Up>)

def upload.with source · line 5045 · raw

@+method:String -> @url:String -> @headers:Map<&2, List<&2, String>> -> @+ms:U32 -> IO(Result<&1, &1, Err, Up>)

Http.upload(method, url, headers) sends the head. A streamed body cannot be replayed, so redirects are not followed.

def upload source · line 5048 · raw

@+method:String -> @url:String -> @headers:Map<&2, List<&2, String>> -> IO(Result<&1, &1, Err, Up>)

def up.wrote source · line 5051 · raw

@+tls:Bool -> @+ms:U32 -> @+head:Bool -> @m:Pair(Socket, Result<&1, &1, Pair(U32, String), Unit>) -> Pair(Up, Result<&2, &2, Err, Unit>)

def up.put source · line 5061 · raw

@+tls:Bool -> @s:Socket -> @+ms:U32 -> @+head:Bool -> @+len:U32 -> @piece:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @skip:Bool -> IO(Pair(Up, Result<&2, &2, Err, Unit>))

One write per chunk, so the size line and the data do not wait on each other (Nagle).

def up.chunk source · line 5070 · raw

@+tls:Bool -> @s:Socket -> @+ms:U32 -> @+head:Bool -> @piece:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> IO(Pair(Up, Result<&2, &2, Err, Unit>))

def upload.write source · line 5075 · raw

@up:Up -> @piece:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> IO(Pair(Up, Result<&2, &2, Err, Unit>))

One chunk. An empty piece sends nothing, since an empty chunk would end the body.

def upload.finish source · line 5084 · raw

@up:Up -> IO(Result<&1, &1, Err, Stream>)

Ends the body and returns the response as a stream.

def limits.representable source · line 5107 · raw

U32

Bytes.words rounds with len+3 in U32. A retained cap plus the fixed 65536 receive overshoot must still fit before that addition, including temporary copies.

def limits.validate.ok source · line 5110 · raw

@valid:Bool -> IO(Unit)

def limits.validate source · line 5117 · raw

@+max:Nat -> IO(Unit)

def limits source · line 5120 · raw

@max:Nat -> Limits

def limits.config source · line 5123 · raw

@config:ServerConfig -> Limits

def phase.new source · line 5131 · raw

@+kind:U32 -> @ms:U32 -> @now:0xe00bbf72c3ff9dc6d7b077524522b3a8/time.Duration -> Phase

def phase.remaining source · line 5134 · raw

@+until:0xe00bbf72c3ff9dc6d7b077524522b3a8/time.Duration -> @+now:0xe00bbf72c3ff9dc6d7b077524522b3a8/time.Duration -> U32

def bounded.sent source · line 5138 · raw

@m:Pair(Socket, Pair(U32, Result<&1, &1, Pair(U32, String), Unit>)) -> Pair(Socket, Result<&1, &1, Pair(U32, String), Unit>)

def bounded.send.ready source · line 5142 · raw

@expired:Bool -> @s:Socket -> @b:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @ms:U32 -> IO(Pair(Socket, Result<&1, &1, Pair(U32, String), Unit>))

def bounded.send source · line 5152 · raw

@s:Socket -> @b:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @until:0xe00bbf72c3ff9dc6d7b077524522b3a8/time.Duration -> IO(Pair(Socket, Result<&1, &1, Pair(U32, String), Unit>))

def reply.bytes source · line 5158 · raw

@res:Res -> @head:Bool -> @close:Bool -> 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes

def reply.fail.bytes source · line 5162 · raw

@+status:U32 -> Res

def reply.drain.of source · line 5165 · raw

@m:Pair(Socket, Result<&1, &1, Pair(U32, String), Pair(U32, Array<U32>)>) -> Pair(Socket, Bool)

def reply.drain source · line 5175 · raw

@n:Nat -> @alive:Bool -> @+until:0xe00bbf72c3ff9dc6d7b077524522b3a8/time.Duration -> @st:Pair(Socket, Bool) -> IO(Unit)

ponytail: cap drain at 32 MiB and 2.55 s; use socket half-close if larger peers need guaranteed delivery.

def reply.sent.close source · line 5196 · raw

@m:Pair(Socket, Result<&1, &1, Pair(U32, String), Unit>) -> IO(Unit)

def reply.sent.observe source · line 5206 · raw

@observer:0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Receipt -> @status:U32 -> @sent:Pair(Socket, Result<&1, &1, Pair(U32, String), Unit>) -> IO(Unit)

def reply_fail source · line 5220 · raw

@observer:0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Receipt -> @s:Socket -> @+status:U32 -> @ms:U32 -> IO(Unit)

def serve.max source · line 5246 · raw

Nat

def sv.none source · line 5249 · raw

Sv

def sv.body source · line 5252 · raw

@req:Req -> @+v11:Bool -> @parts:List<&1, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes> -> @rest:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> Turn

def sv.len.cut source · line 5256 · raw

@req:Req -> @+v11:Bool -> @parts:List<&1, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes> -> @+len:U32 -> @+left:U32 -> @r:Pair(0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes) -> Turn

def sv.len.have source · line 5260 · raw

@short:Bool -> @req:Req -> @+v11:Bool -> @+left:U32 -> @parts:List<&1, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes> -> @+len:U32 -> @piece:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> Turn

def sv.len source · line 5267 · raw

@req:Req -> @+v11:Bool -> @+left:U32 -> @parts:List<&1, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes> -> @piece:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> Turn

def sv.chunk.of source · line 5271 · raw

@req:Req -> @+v11:Bool -> @+n:U32 -> @c:Ck -> Turn

def sv.chunk.parts.cons source · line 5293 · raw

@+len:U32 -> @buf:Array<U32> -> @counted:Pair(List<&1, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes>, Nat) -> Pair(List<&1, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes>, Nat)

def sv.chunk.parts source · line 5297 · raw

@xs:List<&1, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes> -> @old:List<&1, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes> -> Pair(List<&1, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes>, Nat)

def sv.chunk.cap source · line 5305 · raw

@big:Bool -> @req:Req -> @+v11:Bool -> @n:U32 -> @st:Dc -> @parts:List<&1, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes> -> @rest:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> Turn

def sv.chunk.counted source · line 5312 · raw

@+max:Nat -> @req:Req -> @v11:Bool -> @n:U32 -> @st:Dc -> @rest:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @counted:Pair(List<&1, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes>, Nat) -> Turn

def sv.chunk.decoded source · line 5318 · raw

@max:Nat -> @req:Req -> @v11:Bool -> @n:U32 -> @old:List<&1, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes> -> @c:Ck -> Turn

def sv.chunk source · line 5322 · raw

@+max:Nat -> @req:Req -> @+v11:Bool -> @+n:U32 -> @st:Dc -> @parts:List<&1, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes> -> @piece:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> Turn

def sv.cont source · line 5326 · raw

@want:Bool -> @t:Turn -> Turn

RFC 9110 §10.1.1: answer 100 Continue only when the body is still to come.

def sv.cl.k source · line 5339 · raw

@big:Bool -> @req:Req -> @+v11:Bool -> @+k:U32 -> @rest:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> Turn

def sv.cl source · line 5346 · raw

@+max:Nat -> @req:Req -> @+v11:Bool -> @rest:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @n:Maybe<&2, U32> -> Turn

def sv.frame source · line 5353 · raw

@+max:Nat -> @req:Req -> @+v11:Bool -> @rest:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @te:Bool -> Turn

def sv.expects source · line 5361 · raw

@+v11:Bool -> @+headers:Map<&2, List<&2, String>> -> Bool

def sv.got.head source · line 5364 · raw

@+max:Nat -> @+v11:Bool -> @rest:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @req:Req -> Turn

def sv.parsed source · line 5368 · raw

@+max:Nat -> @+v11:Bool -> @rest:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @g:Got -> Turn

def sv.split source · line 5379 · raw

@+max:Nat -> @+hlen:U32 -> @+len:U32 -> @r:Pair(0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes) -> Turn

def sv.hit.none source · line 5384 · raw

@big:Bool -> @buf:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> Turn

def sv.hit.some source · line 5391 · raw

@big:Bool -> @+max:Nat -> @+hlen:U32 -> @+len:U32 -> @buf:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> Turn

def sv.hit source · line 5399 · raw

@+max:Nat -> @+headers:U32 -> @+len:U32 -> @buf:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @at:Maybe<&2, U32> -> Turn

RFC 6585 §5: refuse a head over the configured byte limit.

def sv.seek.of source · line 5407 · raw

@+max:Nat -> @+headers:U32 -> @+len:U32 -> @+from:U32 -> @buf:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @r:Pair(0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes, Maybe<&2, U32>) -> Turn

def sv.seek source · line 5411 · raw

@+max:Nat -> @+headers:U32 -> @+len:U32 -> @+from:U32 -> @r:Pair(0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes) -> Turn

def sv.head.at source · line 5416 · raw

@+max:Nat -> @+headers:U32 -> @+from:U32 -> @buf:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> Turn

Only the new bytes, and the 3 before them, can finish the blank line.

def sv.head source · line 5420 · raw

@+max:Nat -> @+headers:U32 -> @buf:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @piece:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> Turn

def sv.closed.pick source · line 5424 · raw

@empty:Bool -> Turn

def sv.closed.head source · line 5431 · raw

@buf:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> Turn

def sv.step source · line 5436 · raw

@closed:Bool -> @+max:Nat -> @+headers:U32 -> @sv:Sv -> @piece:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> Turn

A close mid-request is a request cut short (RFC 9112 §8).

def sv.frame.req source · line 5455 · raw

@t:Turn -> Maybe<&1, Pair(String, String)>

def sv.frame.go source · line 5469 · raw

@xs:List<&2, String> -> @t:Turn -> Maybe<&1, Pair(String, String)>

def serve.frame source · line 5487 · raw

@xs:List<&2, String> -> Maybe<&1, Pair(String, String)>

The body and the bytes after it, once the pieces make a whole request; None otherwise.

def talk.piece source · line 5490 · raw

@settings:Limits -> @sv:Sv -> @p:Pair(U32, Array<U32>) -> Turn

def talk.next source · line 5495 · raw

@settings:Limits -> @sv:Sv -> @m:Pair(Socket, Result<&1, &1, Pair(U32, String), Pair(U32, Array<U32>)>) -> Pair(Socket, Turn)

def talk.after.pick source · line 5503 · raw

@empty:Bool -> @settings:Limits -> @rest:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> Turn

def talk.after.rest source · line 5511 · raw

@settings:Limits -> @rest:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @s:Socket -> Pair(Socket, Turn)

def talk.after.keep source · line 5515 · raw

@keep:Bool -> @settings:Limits -> @rest:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @s:Socket -> Pair(Socket, Turn)

def talk.after source · line 5522 · raw

@settings:Limits -> @keep:Bool -> @rest:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @m:Pair(Socket, Result<&1, &1, Pair(U32, String), Unit>) -> Pair(Pair(Socket, Turn), 0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Outcome)

def talk.send source · line 5530 · raw

@+settings:Limits -> @s:Socket -> @rest:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @+headers:Map<&2, List<&2, String>> -> @v11:Bool -> @+head:Bool -> @res:Res -> IO(Pair(Pair(Socket, Turn), 0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Outcome))

def talk.completed.connection source · line 5540 · raw

@outcome:0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Outcome -> @next:Pair(Socket, Turn) -> IO(Maybe<&1, Pair(Socket, Turn)>)

def talk.completed source · line 5556 · raw

@observer:0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Receipt -> @receipt:0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Receipt -> @+status:U32 -> @sent:Pair(Pair(Socket, Turn), 0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Outcome) -> IO(Maybe<&1, Pair(Socket, Turn)>)

def talk.respond source · line 5566 · raw

@observer:0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Receipt -> @+settings:Limits -> @s:Socket -> @rest:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @headers:Map<&2, List<&2, String>> -> @v11:Bool -> @head:Bool -> @reply:Reply -> IO(Maybe<&1, Pair(Socket, Turn)>)

def talk.cont source · line 5573 · raw

@cont:Bool -> @s:Socket -> @ms:U32 -> IO(Pair(Socket, Result<&1, &1, Pair(U32, String), Unit>))

def phase.head source · line 5582 · raw

@empty:Bool -> @settings:Limits -> @now:0xe00bbf72c3ff9dc6d7b077524522b3a8/time.Duration -> Phase

def phase.start source · line 5591 · raw

@settings:Limits -> @sv:Sv -> @now:0xe00bbf72c3ff9dc6d7b077524522b3a8/time.Duration -> Pair(Phase, Sv)

def phase.select source · line 5602 · raw

@settings:Limits -> @sv:Sv -> @now:0xe00bbf72c3ff9dc6d7b077524522b3a8/time.Duration -> @previous:Maybe<&2, Phase> -> Pair(Phase, Sv)

def phase.body source · line 5610 · raw

@previous:Maybe<&2, Phase> -> @settings:Limits -> @now:0xe00bbf72c3ff9dc6d7b077524522b3a8/time.Duration -> Phase

Buffered pipelined headers have already ended before upload callbacks run.

def phase.after source · line 5618 · raw

@+settings:Limits -> @+now:0xe00bbf72c3ff9dc6d7b077524522b3a8/time.Duration -> @+phase:Phase -> @t:Turn -> Pair(Turn, Phase)

def phase.expired source · line 5639 · raw

@phase:Phase -> Turn

def talk.received.state source · line 5643 · raw

@s:Socket -> @next:Pair(Turn, Phase) -> Pair(Pair(Socket, Turn), Phase)

def talk.received.phase source · line 5647 · raw

@settings:Limits -> @phase:Phase -> @now:0xe00bbf72c3ff9dc6d7b077524522b3a8/time.Duration -> @next:Pair(Socket, Turn) -> Pair(Pair(Socket, Turn), Phase)

def talk.received.late source · line 5651 · raw

@expired:Bool -> @+settings:Limits -> @+phase:Phase -> @now:0xe00bbf72c3ff9dc6d7b077524522b3a8/time.Duration -> @sv:Sv -> @m:Pair(Socket, Result<&1, &1, Pair(U32, String), Pair(U32, Array<U32>)>) -> Pair(Pair(Socket, Turn), Phase)

def talk.read.running source · line 5662 · raw

@held:Bool -> @inbox:Chan(0x6a946b742ab6f76f0ba5b90b14da52ad/admission.Command) -> IO(Bool)

A real host read slice returns its socket; no raced operation is abandoned. The original absolute phase survives slice timeouts and stop observations. Admitted streamed uploads retain their state and finish; unadmitted input closes.

def talk.read source · line 5724 · raw

@+inbox:Chan(0x6a946b742ab6f76f0ba5b90b14da52ad/admission.Command) -> @held:Bool -> @+settings:Limits -> @sv:Sv -> @phase:Phase -> @m:Pair(Socket, Result<&1, &1, Pair(U32, String), Unit>) -> IO(Pair(Pair(Socket, Turn), Phase))

def talk.recv.selected source · line 5732 · raw

@+inbox:Chan(0x6a946b742ab6f76f0ba5b90b14da52ad/admission.Command) -> @held:Bool -> @+settings:Limits -> @s:Socket -> @cont:Bool -> @selected:Pair(Phase, Sv) -> IO(Pair(Pair(Socket, Turn), Phase))

def talk.recv source · line 5739 · raw

@+inbox:Chan(0x6a946b742ab6f76f0ba5b90b14da52ad/admission.Command) -> @held:Bool -> @+settings:Limits -> @s:Socket -> @sv:Sv -> @cont:Bool -> @previous:Maybe<&2, Phase> -> IO(Pair(Pair(Socket, Turn), Phase))

def talk.state source · line 5747 · raw

@received:Pair(Pair(Socket, Turn), Phase) -> Serving

def serve.write.state source · line 5751 · raw

@after:Maybe<&1, Pair(Socket, Turn)> -> Maybe<&1, Serving>

def admission.done source · line 5761 · raw

@+inbox:Chan(0x6a946b742ab6f76f0ba5b90b14da52ad/admission.Command) -> @operation:IO(Unit) -> IO(Unit)

A buffered-work unit owns one connection's incomplete request, decoded body, and pipelined remainder from before its first recv until the task really returns. ponytail: idle sockets also reserve buffer units; split idle/read leases if idle utilization matters.

def admission.head source · line 5766 · raw

@req:Req -> Bool

def admission.turn.head source · line 5770 · raw

@turn:Turn -> Bool

def admission.reject source · line 5790 · raw

@observer:0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Receipt -> @s:Socket -> @head:Bool -> @ms:U32 -> IO(Unit)

This rejection has parsed metadata, so normal HEAD body suppression still applies.

def server.config source · line 5868 · raw

@host:String -> @port:U32 -> ServerConfig

def server.config.with source · line 5871 · raw

@host:String -> @port:U32 -> @max:Nat -> ServerConfig

def server.deadline.valid source · line 5875 · raw

@+ms:U32 -> Bool

Host deadline effects use signed 32-bit milliseconds.

def server.config.valid source · line 5878 · raw

@config:ServerConfig -> Bool

def server.counts source · line 5931 · raw

@counts:Maybe<&2, 0x6a946b742ab6f76f0ba5b90b14da52ad/admission.Counts> -> Maybe<&2, ServerCounts>

def server.stats source · line 5940 · raw

@observer:ServerStats -> IO(Maybe<&2, ServerCounts>)

None means accounting has closed after the listener and its retained operations. This is not a drain result or a per-response write outcome.

def server.stop source · line 5954 · raw

@control:ServerControl -> IO(Bool)

def server.final.counts source · line 5958 · raw

@counts:0x6a946b742ab6f76f0ba5b90b14da52ad/admission.Counts -> ServerCounts

def server.finished source · line 5977 · raw

@stopped:Bool -> @error:Pair(U32, String) -> @counts:ServerCounts -> ServerExit

def error.stopped source · line 6059 · raw

@error:Pair(U32, String) -> Bool

def error.capacity source · line 6068 · raw

@error:Pair(U32, String) -> Bool

def server.exited source · line 6103 · raw

@result:ServerExit -> IO(Unit)

Convenience wrappers use the same owner and observe its actual exit/drain.

def server.start.failed source · line 6108 · raw

@error:StartupError -> IO(Unit)

def serve.config.result source · line 6113 · raw

@result:Result<&2, &2, StartupError, Unit> -> IO(Unit)

def admission.ready source · line 6159 · raw

@t:Turn -> Pair(Bool, Turn)

def admission.give.held source · line 6178 · raw

@held:Bool -> @inbox:Chan(0x6a946b742ab6f76f0ba5b90b14da52ad/admission.Command) -> IO(Unit)

def admission.stream.take source · line 6203 · raw

@needed:Bool -> @inbox:Chan(0x6a946b742ab6f76f0ba5b90b14da52ad/admission.Command) -> IO(Bool)

def writer.sent source · line 6352 · raw

@+mode:WriterMode -> @+until:0xe00bbf72c3ff9dc6d7b077524522b3a8/time.Duration -> @m:Pair(Socket, Result<&1, &1, Pair(U32, String), Unit>) -> IO(Writer)

def writer.raw source · line 6362 · raw

@w:Writer -> @b:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> IO(Writer)

def writer.chunk source · line 6372 · raw

@s:Socket -> @b:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @+len:U32 -> @until:0xe00bbf72c3ff9dc6d7b077524522b3a8/time.Duration -> IO(Writer)

def writer.known source · line 6378 · raw

@ok:Bool -> @s:Socket -> @+left:U32 -> @len:U32 -> @b:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @+until:0xe00bbf72c3ff9dc6d7b077524522b3a8/time.Duration -> IO(Writer)

def writer.chunk.go source · line 6387 · raw

@empty:Bool -> @s:Socket -> @b:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @len:U32 -> @until:0xe00bbf72c3ff9dc6d7b077524522b3a8/time.Duration -> IO(Writer)

def writer.write.mode source · line 6394 · raw

@s:Socket -> @mode:WriterMode -> @b:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @until:0xe00bbf72c3ff9dc6d7b077524522b3a8/time.Duration -> IO(Writer)

def writer.write source · line 6405 · raw

@w:Writer -> @b:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> IO(Writer)

def writer.result source · line 6413 · raw

@w:Writer -> Pair(Maybe<&1, Socket>, 0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Outcome)

def writer.finish.known source · line 6417 · raw

@complete:Bool -> @s:Socket -> IO(Pair(Maybe<&1, Socket>, 0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Outcome))

def writer.finish.mode source · line 6426 · raw

@s:Socket -> @mode:WriterMode -> @until:0xe00bbf72c3ff9dc6d7b077524522b3a8/time.Duration -> IO(Pair(Maybe<&1, Socket>, 0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Outcome))

def writer.finish source · line 6437 · raw

@w:Writer -> IO(Pair(Maybe<&1, Socket>, 0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Outcome))

@m:Map<&2, List<&2, String>> -> @+key:String -> @vs:List<&2, String> -> @framing:Bool -> Map<&2, List<&2, String>>

def writer.headers source · line 6452 · raw

@xs:List<&2, Sigma<&2, &2, String, _ => List<&2, String>>> -> @m:Map<&2, List<&2, String>> -> Map<&2, List<&2, String>>

def writer.plan.body source · line 6461 · raw

@headers:Map<&2, List<&2, String>> -> @length:Maybe<&2, U32> -> Pair(WriterMode, Map<&2, List<&2, String>>)

def writer.plan source · line 6468 · raw

@nobody:Bool -> @headers:Map<&2, List<&2, String>> -> @length:Maybe<&2, U32> -> Pair(WriterMode, Map<&2, List<&2, String>>)

def serve.write.after source · line 6475 · raw

@settings:Limits -> @keep:Bool -> @rest:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @socket:Maybe<&1, Socket> -> Maybe<&1, Pair(Socket, Turn)>

def serve.write.completed source · line 6482 · raw

@observer:0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Receipt -> @receipt:0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Receipt -> @+status:U32 -> @settings:Limits -> @keep:Bool -> @rest:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @result:Pair(Maybe<&1, Socket>, 0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Outcome) -> IO(Maybe<&1, Pair(Socket, Turn)>)

def serve.write.returned source · line 6491 · raw

@observer:0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Receipt -> @status:U32 -> @settings:Limits -> @keep:Bool -> @rest:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @result:Pair(Writer, 0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Receipt) -> IO(Maybe<&1, Pair(Socket, Turn)>)

def serve.write.finish source · line 6498 · raw

@observer:0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Receipt -> @receipt:0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Receipt -> @status:U32 -> @settings:Limits -> @keep:Bool -> @rest:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @w:Writer -> IO(Maybe<&1, Pair(Socket, Turn)>)

def writer.connection source · line 6532 · raw

@keep:Bool -> @headers:Map<&2, List<&2, String>> -> Map<&2, List<&2, String>>

Templates

template reply.complete source · line 37 · raw

@-D:Data -> @-done:(@_:0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Completion<D> -> IO(Unit)) -> @payload:D -> @response:Res -> Reply

template ce.eff source · line 4013 · raw

@-eff:(@_:U32 -> @_:U32 -> @_:Array<U32> -> IO(Result<&1, &1, Pair(U32, String), Pair(U32, Array<U32>)>)) -> @b:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> IO(Maybe<&1, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes>)

A decoded body stops at 16 MiB, like a received one.

template codings.has source · line 4128 · raw

@-eff:(@_:U32 -> @_:U32 -> @_:Array<U32> -> IO(Result<&1, &1, Pair(U32, String), Pair(U32, Array<U32>)>)) -> @b:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> IO(Bool)

template admission.request source · line 5797 · raw

@-C:Data -> @-h:(@_:C -> @_:Req -> IO(Reply)) -> @-observe:(@_:C -> @_:U32 -> @_:0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Outcome -> IO(Unit)) -> @admitted:Bool -> @+inbox:Chan(0x6a946b742ab6f76f0ba5b90b14da52ad/admission.Command) -> @+context:C -> @+settings:Limits -> @s:Socket -> @req:Req -> @rest:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @v11:Bool -> IO(Maybe<&1, Pair(Socket, Turn)>)

template conn.admitted source · line 5840 · raw

@-h:(@_:Req -> IO(Reply)) -> @-observe:(@_:U32 -> @_:0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Outcome -> IO(Unit)) -> @admitted:Bool -> @+settings:Limits -> @+inbox:Chan(0x6a946b742ab6f76f0ba5b90b14da52ad/admission.Command) -> @l:Listener -> @s:Socket -> IO(Listener)

template conn source · line 5852 · raw

@-h:(@_:Req -> IO(Reply)) -> @-observe:(@_:U32 -> @_:0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Outcome -> IO(Unit)) -> @+settings:Limits -> @+inbox:Chan(0x6a946b742ab6f76f0ba5b90b14da52ad/admission.Command) -> @m:Pair(Listener, Result<&1, &1, Pair(U32, String), Socket>) -> IO(Listener)

template server.opened source · line 5886 · raw

@-C:Data -> @-O:Type -> @owner:O -> @listener:Listener -> @context:C -> @config:ServerConfig -> @opened:Pair(Chan(0x6a946b742ab6f76f0ba5b90b14da52ad/admission.Command), Chan(0x6a946b742ab6f76f0ba5b90b14da52ad/admission.Counts)) -> IO(Pair(O, Result<&2, &1, StartupError, Server<C>>))

template server.started source · line 5891 · raw

@-C:Data -> @-O:Type -> @context:C -> @owner:O -> @+config:ServerConfig -> @result:Result<&1, &1, Pair(U32, String), Listener> -> IO(Pair(O, Result<&2, &1, StartupError, Server<C>>))

template server.start.valid source · line 5902 · raw

@-C:Data -> @-O:Type -> @valid:Bool -> @context:C -> @owner:O -> @+config:ServerConfig -> IO(Pair(O, Result<&2, &1, StartupError, Server<C>>))

template server.start source · line 5914 · raw

@-C:Data -> @-O:Type -> @context:C -> @owner:O -> @+config:ServerConfig -> IO(Pair(O, Result<&2, &1, StartupError, Server<C>>))

Done is the readiness signal: TCP.listen has installed an accepting socket. Both branches return the preopened application owner unchanged.

template server.observer source · line 5927 · raw

@-C:Data -> @server:Server<C> -> Pair(Server<C>, ServerStats)

template server.control source · line 5950 · raw

@-C:Data -> @server:Server<C> -> Pair(Server<C>, ServerControl)

Stop linearizes in Admission. It requests quiescence, never attests drain.

template server.close source · line 5964 · raw

@-C:Data -> @server:Server<C> -> IO(ServerCounts)

Only the listener owner closes it, after the current accept really returns. Joining the controller waits for every real operation, including callbacks.

template server.finish source · line 5985 · raw

@-C:Data -> @stopped:Bool -> @error:Pair(U32, String) -> @server:Server<C> -> IO(ServerExit)

template server.admitted source · line 5990 · raw

@-C:Data -> @-operation:(@_:C -> @_:Limits -> @_:Chan(0x6a946b742ab6f76f0ba5b90b14da52ad/admission.Command) -> @_:Socket -> IO(Unit)) -> @admitted:Bool -> @+context:C -> @+config:ServerConfig -> @+inbox:Chan(0x6a946b742ab6f76f0ba5b90b14da52ad/admission.Command) -> @drained:Chan(0x6a946b742ab6f76f0ba5b90b14da52ad/admission.Counts) -> @listener:Listener -> @socket:Socket -> IO(Pair(Server<C>, Result<&1, &1, Pair(U32, String), Chan(Unit)>))

template server.accepted source · line 6001 · raw

@-C:Data -> @-operation:(@_:C -> @_:Limits -> @_:Chan(0x6a946b742ab6f76f0ba5b90b14da52ad/admission.Command) -> @_:Socket -> IO(Unit)) -> @+context:C -> @+config:ServerConfig -> @+inbox:Chan(0x6a946b742ab6f76f0ba5b90b14da52ad/admission.Command) -> @drained:Chan(0x6a946b742ab6f76f0ba5b90b14da52ad/admission.Counts) -> @result:Pair(Listener, Result<&1, &1, Pair(U32, String), Socket>) -> IO(Pair(Server<C>, Result<&1, &1, Pair(U32, String), Chan(Unit)>))

template server.accept.operation source · line 6050 · raw

@-C:Data -> @-operation:(@_:C -> @_:Limits -> @_:Chan(0x6a946b742ab6f76f0ba5b90b14da52ad/admission.Command) -> @_:Socket -> IO(Unit)) -> @server:Server<C> -> IO(Pair(Server<C>, Result<&1, &1, Pair(U32, String), Chan(Unit)>))

template server.accept source · line 6054 · raw

@-C:Data -> @-h:(@_:C -> @_:Req -> IO(Reply)) -> @-observe:(@_:C -> @_:U32 -> @_:0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Outcome -> IO(Unit)) -> @server:Server<C> -> IO(Pair(Server<C>, Result<&1, &1, Pair(U32, String), Chan(Unit)>))

template server.run source · line 6097 · raw

@-C:Data -> @-h:(@_:C -> @_:Req -> IO(Reply)) -> @-observe:(@_:C -> @_:U32 -> @_:0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Outcome -> IO(Unit)) -> @server:Server<C> -> IO(ServerExit)

template serve.stream.nonempty source · line 6118 · raw

@-S:Type -> @-piece:(@_:S -> @_:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> IO(Pair(S, Bool))) -> @empty:Bool -> @state:S -> @b:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> IO(Pair(S, Bool))

template serve.stream.one source · line 6126 · raw

@-S:Type -> @-piece:(@_:S -> @_:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> IO(Pair(S, Bool))) -> @drop:Bool -> @state:S -> @b:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> IO(Pair(S, Bool))

The piece callback returns True to discard the rest of this request body.

template serve.stream.parts source · line 6134 · raw

@-S:Type -> @-piece:(@_:S -> @_:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> IO(Pair(S, Bool))) -> @xs:List<&1, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes> -> @st:Pair(S, Bool) -> IO(Pair(S, Bool))

template serve.stream.feed source · line 6144 · raw

@-S:Type -> @-start:(@_:Req -> IO(S)) -> @-piece:(@_:S -> @_:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> IO(Pair(S, Bool))) -> @req:Req -> @m:Maybe<&1, Pair(S, Bool)> -> @parts:List<&1, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes> -> IO(Pair(S, Bool))

template serve.stream.respond source · line 6153 · raw

@-S:Type -> @-finish:(@_:S -> IO(Reply)) -> @-observe:(@_:U32 -> @_:0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Outcome -> IO(Unit)) -> @+settings:Limits -> @s:Socket -> @rest:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @+headers:Map<&2, List<&2, String>> -> @v11:Bool -> @+method:String -> @st:Pair(S, Bool) -> IO(Maybe<&1, Pair(Socket, Turn)>)

template serve.stream.after source · line 6191 · raw

@-S:Type -> @next:Maybe<&1, Pair(Socket, Turn)> -> StreamServing<S>

template serve.stream.ready source · line 6198 · raw

@-S:Type -> @held:Bool -> @socket:Socket -> @phase:Maybe<&2, Phase> -> @state:Maybe<&1, Pair(S, Bool)> -> @result:Pair(Bool, Turn) -> StreamServing<S>

template serve.stream.abort source · line 6217 · raw

@-S:Type -> @-abort:(@_:S -> @_:StreamAbort -> IO(Unit)) -> @reason:StreamAbort -> @state:Maybe<&1, Pair(S, Bool)> -> IO(Unit)

The application consumes its real affine state on unsuccessful upload paths. An abort that does not return remains admitted work, not a fabricated drain.

template server.stream.run source · line 6309 · raw

@-S:Type -> @-start:(@_:Req -> IO(S)) -> @-piece:(@_:S -> @_:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> IO(Pair(S, Bool))) -> @-finish:(@_:S -> IO(Reply)) -> @-abort:(@_:S -> @_:StreamAbort -> IO(Unit)) -> @-observe:(@_:U32 -> @_:0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Outcome -> IO(Unit)) -> @server:Server<Unit> -> IO(ServerExit)

template serve.stream.started source · line 6319 · raw

@-S:Type -> @-start:(@_:Req -> IO(S)) -> @-piece:(@_:S -> @_:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> IO(Pair(S, Bool))) -> @-finish:(@_:S -> IO(Reply)) -> @-abort:(@_:S -> @_:StreamAbort -> IO(Unit)) -> @-observe:(@_:U32 -> @_:0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Outcome -> IO(Unit)) -> @result:Pair(Unit, Result<&2, &1, StartupError, Server<Unit>>) -> IO(Result<&2, &2, StartupError, Unit>)

template serve.stream.config source · line 6333 · raw

@-S:Type -> @-start:(@_:Req -> IO(S)) -> @-piece:(@_:S -> @_:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> IO(Pair(S, Bool))) -> @-finish:(@_:S -> IO(Reply)) -> @-abort:(@_:S -> @_:StreamAbort -> IO(Unit)) -> @-observe:(@_:U32 -> @_:0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Outcome -> IO(Unit)) -> @config:ServerConfig -> IO(Result<&2, &2, StartupError, Unit>)

template serve.write.body source · line 6502 · raw

@-S:Type -> @-write:(@_:S -> @_:Writer -> @_:0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Receipt -> IO(Pair(Writer, 0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Receipt))) -> @-dispose:(@_:S -> IO(Unit)) -> @observer:0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Receipt -> @receipt:0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Receipt -> @status:U32 -> @settings:Limits -> @keep:Bool -> @rest:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @state:S -> @s:Socket -> @mode:WriterMode -> @suppress:Bool -> @until:0xe00bbf72c3ff9dc6d7b077524522b3a8/time.Duration -> IO(Maybe<&1, Pair(Socket, Turn)>)

template serve.write.open source · line 6515 · raw

@-S:Type -> @-write:(@_:S -> @_:Writer -> @_:0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Receipt -> IO(Pair(Writer, 0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Receipt))) -> @-dispose:(@_:S -> IO(Unit)) -> @observer:0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Receipt -> @receipt:0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Receipt -> @+status:U32 -> @settings:Limits -> @keep:Bool -> @rest:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @state:S -> @mode:WriterMode -> @suppress:Bool -> @until:0xe00bbf72c3ff9dc6d7b077524522b3a8/time.Duration -> @m:Pair(Socket, Result<&1, &1, Pair(U32, String), Unit>) -> IO(Maybe<&1, Pair(Socket, Turn)>)

template serve.write.send.plan source · line 6539 · raw

@-S:Type -> @-write:(@_:S -> @_:Writer -> @_:0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Receipt -> IO(Pair(Writer, 0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Receipt))) -> @-dispose:(@_:S -> IO(Unit)) -> @observer:0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Receipt -> @receipt:0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Receipt -> @+settings:Limits -> @s:Socket -> @rest:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @+keep:Bool -> @+head:Bool -> @+status:U32 -> @state:S -> @plan:Pair(WriterMode, Map<&2, List<&2, String>>) -> IO(Maybe<&1, Pair(Socket, Turn)>)

template serve.write.send source · line 6555 · raw

@-S:Type -> @-write:(@_:S -> @_:Writer -> @_:0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Receipt -> IO(Pair(Writer, 0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Receipt))) -> @-dispose:(@_:S -> IO(Unit)) -> @observer:0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Receipt -> @settings:Limits -> @s:Socket -> @rest:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @+headers:Map<&2, List<&2, String>> -> @v11:Bool -> @+head:Bool -> @out:WriteHead<S> -> IO(Maybe<&1, Pair(Socket, Turn)>)

template admission.write source · line 6565 · raw

@-S:Type -> @-start:(@_:Req -> IO(WriteHead<S>)) -> @-write:(@_:S -> @_:Writer -> @_:0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Receipt -> IO(Pair(Writer, 0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Receipt))) -> @-dispose:(@_:S -> IO(Unit)) -> @-observe:(@_:U32 -> @_:0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Outcome -> IO(Unit)) -> @admitted:Bool -> @+inbox:Chan(0x6a946b742ab6f76f0ba5b90b14da52ad/admission.Command) -> @+settings:Limits -> @s:Socket -> @req:Req -> @rest:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> @v11:Bool -> IO(Maybe<&1, Pair(Socket, Turn)>)

template server.write.run source · line 6611 · raw

@-S:Type -> @-start:(@_:Req -> IO(WriteHead<S>)) -> @-write:(@_:S -> @_:Writer -> @_:0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Receipt -> IO(Pair(Writer, 0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Receipt))) -> @-dispose:(@_:S -> IO(Unit)) -> @-observe:(@_:U32 -> @_:0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Outcome -> IO(Unit)) -> @server:Server<Unit> -> IO(ServerExit)

template serve.write.started source · line 6623 · raw

@-S:Type -> @-start:(@_:Req -> IO(WriteHead<S>)) -> @-write:(@_:S -> @_:Writer -> @_:0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Receipt -> IO(Pair(Writer, 0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Receipt))) -> @-dispose:(@_:S -> IO(Unit)) -> @-observe:(@_:U32 -> @_:0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Outcome -> IO(Unit)) -> @result:Pair(Unit, Result<&2, &1, StartupError, Server<Unit>>) -> IO(Result<&2, &2, StartupError, Unit>)

template serve.write.config source · line 6637 · raw

@-S:Type -> @-start:(@_:Req -> IO(WriteHead<S>)) -> @-write:(@_:S -> @_:Writer -> @_:0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Receipt -> IO(Pair(Writer, 0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Receipt))) -> @-dispose:(@_:S -> IO(Unit)) -> @-observe:(@_:U32 -> @_:0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Outcome -> IO(Unit)) -> @config:ServerConfig -> IO(Result<&2, &2, StartupError, Unit>)

template serve.started source · line 6644 · raw

@-h:(@_:Req -> IO(Reply)) -> @-observe:(@_:U32 -> @_:0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Outcome -> IO(Unit)) -> @started:Pair(Unit, Result<&2, &1, StartupError, Server<Unit>>) -> IO(Unit)

template serve.on.with source · line 6655 · raw

@-h:(@_:Req -> IO(Reply)) -> @-observe:(@_:U32 -> @_:0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Outcome -> IO(Unit)) -> @host:String -> @+port:U32 -> @+max:Nat -> IO(Unit)

template serve.on source · line 6662 · raw

@-h:(@_:Req -> IO(Reply)) -> @-observe:(@_:U32 -> @_:0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Outcome -> IO(Unit)) -> @host:String -> @+port:U32 -> IO(Unit)

template serve.with source · line 6665 · raw

@-h:(@_:Req -> IO(Reply)) -> @-observe:(@_:U32 -> @_:0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Outcome -> IO(Unit)) -> @+port:U32 -> @+max:Nat -> IO(Unit)

template serve source · line 6668 · raw

@-h:(@_:Req -> IO(Reply)) -> @-observe:(@_:U32 -> @_:0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Outcome -> IO(Unit)) -> @+port:U32 -> IO(Unit)

template serve.stream.on.with source · line 6671 · raw

@-S:Type -> @-start:(@_:Req -> IO(S)) -> @-piece:(@_:S -> @_:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> IO(Pair(S, Bool))) -> @-finish:(@_:S -> IO(Reply)) -> @-abort:(@_:S -> @_:StreamAbort -> IO(Unit)) -> @-observe:(@_:U32 -> @_:0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Outcome -> IO(Unit)) -> @host:String -> @+port:U32 -> @+max:Nat -> IO(Unit)

template serve.stream.with source · line 6681 · raw

@-S:Type -> @-start:(@_:Req -> IO(S)) -> @-piece:(@_:S -> @_:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> IO(Pair(S, Bool))) -> @-finish:(@_:S -> IO(Reply)) -> @-abort:(@_:S -> @_:StreamAbort -> IO(Unit)) -> @-observe:(@_:U32 -> @_:0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Outcome -> IO(Unit)) -> @+port:U32 -> @+max:Nat -> IO(Unit)

template serve.write.on.with source · line 6687 · raw

@-S:Type -> @-start:(@_:Req -> IO(WriteHead<S>)) -> @-write:(@_:S -> @_:Writer -> @_:0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Receipt -> IO(Pair(Writer, 0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Receipt))) -> @-dispose:(@_:S -> IO(Unit)) -> @-observe:(@_:U32 -> @_:0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Outcome -> IO(Unit)) -> @host:String -> @+port:U32 -> @+max:Nat -> IO(Unit)

template serve.write.with source · line 6697 · raw

@-S:Type -> @-start:(@_:Req -> IO(WriteHead<S>)) -> @-write:(@_:S -> @_:Writer -> @_:0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Receipt -> IO(Pair(Writer, 0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Receipt))) -> @-dispose:(@_:S -> IO(Unit)) -> @-observe:(@_:U32 -> @_:0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Outcome -> IO(Unit)) -> @+port:U32 -> @+max:Nat -> IO(Unit)

Unsafe

unsafe fetch.loop source · line 2591 · raw

@+close:Bool -> @+head:Bool -> @+tls:Bool -> @+ms:U32 -> @st:Pair(Socket, Fl) -> IO(Out)

Reads until the response is whole or cannot be; an empty read means the server closed.

unsafe pool.hops source · line 3895 · raw

@+mode:Mode -> @+ms:U32 -> @st:Hops -> IO(Pair(Pool, Pair(Result<&1, &1, Err, Res>, Maybe<&2, Jar>)))

NGo.left is how many redirects may follow this request. 20 is WHATWG's limit. The jar, when there is one, gives cookies to every hop and takes them from every response.

unsafe stream.read source · line 4667 · raw

@st:Stream -> IO(Pair(Stream, Result<&1, &1, Err, Maybe<&1, 0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes>>))

The next piece of the body; None at the end. A piece is never empty.

unsafe stream.head source · line 4739 · raw

@+tls:Bool -> @+ms:U32 -> @+head:Bool -> @st:Pair(Socket, Sh) -> IO(Result<&1, &1, Err, Stream>)

Reads until the final head is in; the body bytes that came with it are the first piece.

unsafe stream.hops source · line 4843 · raw

@+ms:U32 -> @sn:Sn -> IO(Result<&1, &1, Err, Stream>)

unsafe talk.read.loop source · line 5678 · raw

@+inbox:Chan(0x6a946b742ab6f76f0ba5b90b14da52ad/admission.Command) -> @+held:Bool -> @+settings:Limits -> @step:ReadStep -> IO(Pair(Pair(Socket, Turn), Phase))

One state machine owns the socket through each actual host return.

unsafe talk source · line 5817 · raw

@-C:Data -> @-h:(@_:C -> @_:Req -> IO(Reply)) -> @-observe:(@_:C -> @_:U32 -> @_:0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Outcome -> IO(Unit)) -> @+context:C -> @+settings:Limits -> @+inbox:Chan(0x6a946b742ab6f76f0ba5b90b14da52ad/admission.Command) -> @st:Maybe<&1, Serving> -> IO(Unit)

unsafe server.accept.loop source · line 6019 · raw

@-C:Data -> @-operation:(@_:C -> @_:Limits -> @_:Chan(0x6a946b742ab6f76f0ba5b90b14da52ad/admission.Command) -> @_:Socket -> IO(Unit)) -> @step:AcceptStep<C> -> IO(Pair(Server<C>, Result<&1, &1, Pair(U32, String), Chan(Unit)>))

unsafe server.run.loop source · line 6075 · raw

@-C:Data -> @-operation:(@_:C -> @_:Limits -> @_:Chan(0x6a946b742ab6f76f0ba5b90b14da52ad/admission.Command) -> @_:Socket -> IO(Unit)) -> @step:ServerLoop<C> -> IO(ServerExit)

A single recursive state machine avoids recursion hidden inside a template.

unsafe serve.stream.talk source · line 6227 · raw

@-S:Type -> @-start:(@_:Req -> IO(S)) -> @-piece:(@_:S -> @_:0x49814d83de8f70993a43e1002be29ecd/bytes.Bytes -> IO(Pair(S, Bool))) -> @-finish:(@_:S -> IO(Reply)) -> @-abort:(@_:S -> @_:StreamAbort -> IO(Unit)) -> @-observe:(@_:U32 -> @_:0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Outcome -> IO(Unit)) -> @+settings:Limits -> @+inbox:Chan(0x6a946b742ab6f76f0ba5b90b14da52ad/admission.Command) -> @step:StreamServing<S> -> IO(Unit)

One recursive state machine keeps template callbacks out of mutual recursion.

unsafe serve.write.talk source · line 6585 · raw

@-S:Type -> @-start:(@_:Req -> IO(WriteHead<S>)) -> @-write:(@_:S -> @_:Writer -> @_:0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Receipt -> IO(Pair(Writer, 0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Receipt))) -> @-dispose:(@_:S -> IO(Unit)) -> @-observe:(@_:U32 -> @_:0x6a946b742ab6f76f0ba5b90b14da52ad/completion.Outcome -> IO(Unit)) -> @+settings:Limits -> @+inbox:Chan(0x6a946b742ab6f76f0ba5b90b14da52ad/admission.Command) -> @st:Maybe<&1, Serving> -> IO(Unit)