@amritk/nish-x86_64-linux 0.29.0 → 0.31.0

package/std/net/{http1.ts → http1-codec.ts}

@@ -1,12 +1,12 @@
 /**
- * `nish/net/http1` — an incremental HTTP/1.1 request parser and a response
+ * `nish/net/http1-codec` — an incremental HTTP/1.1 request parser and a response
  * writer, sans-IO: bytes in, events and bytes out, and no socket anywhere.
  *
  * **The parser** is a push-pull machine. A caller `feed`s whatever slice the
  * socket gave it, of any length and cut anywhere, and then calls `next()`
  * until it answers `HTTP1_NEED_MORE`:
  *
- *     import { Http1Parser, HTTP1_HEAD, HTTP1_BODY, HTTP1_END, HTTP1_ERROR } from "nish/net/http1";
+ *     import { Http1Parser, HTTP1_HEAD, HTTP1_BODY, HTTP1_END, HTTP1_ERROR } from "nish/net/http1-codec";
  *
  *     const p = new Http1Parser(maxTarget, maxHeaderBytes, maxHeaders, maxBody);
  *     p.feed(received, 0, n);
@@ -81,6 +81,7 @@
  * Written from RFC 9112 and RFC 9110, not ported from another implementation.
  */
 import { copyBytes } from "nish/bytes"
+import { extract, loadU8x16, u8x16 } from "nish:simd"
 
 /** `next()`: the input so far holds no further event; feed more. */
 export const HTTP1_NEED_MORE: i32 = 0
@@ -218,7 +219,13 @@ export class Http1Parser {
   /** The line `http1TakeLine` found is `buf[lineStart .. lineEnd)`, its CRLF dropped. */
   lineStart: i32 = 0
   lineEnd: i32 = 0
-
+  /**
+   * Whether the line being scanned holds a byte a field value may not: a
+   * control byte other than HTAB, or DEL (RFC 9110 §5.5). `http1TakeLine`
+   * sets it as it looks for the line's end, so a field line's bytes are read
+   * once, not once for the LF and again for the check.
+   */
+  lineControl: boolean = false
   chunked: boolean = false
   keepAlive: boolean = false
   /** Whether the request asked to switch protocols (`upgrade` is its value when `keepText`). */
@@ -498,6 +505,60 @@ const http1StartRequest = (p: Http1Parser): void => {
   p.headHeld = false
 }
 
+/**
+ * Whether any of the eight bytes of `x` is below 32 or is 127: a control
+ * byte or DEL, which `http1TakeLine` stops at. Two of the bit tricks of
+ * "Bit Twiddling Hacks" (S. E. Anderson, public domain): a byte below `n`
+ * leaves its high bit set in `(x - n * ones) & ~x`, for `n` up to 128, and
+ * `127` is the byte that is zero in `x ^ 127 * ones`. A byte from 128 up
+ * has its high bit set in `x`, so `~x` clears it: obs-text never matches.
+ * The answer is exact for the word, though not for which byte. Each
+ * subtraction is masked to 64 bits because a `u64` is a BigInt under Node,
+ * which does not wrap; natively the mask is a no-op.
+ */
+const http1WordHasControl = (x: u64): boolean => {
+  const ones32: u64 = toU64(16843009)
+  const ones: u64 = (ones32 << toU64(32)) | ones32
+  const low32: u64 = 0xffffffff
+  const all: u64 = (low32 << toU64(32)) | low32
+  const high: u64 = ones * toU64(128)
+  const below: u64 = (x - ones * toU64(32)) & all & ~x & high
+  const y: u64 = x ^ (ones * toU64(127))
+  const del: u64 = (y - ones) & all & ~y & high
+  return (below | del) !== toU64(0)
+}
+
+/**
+ * Lanes `at` to `at + 7` of `v`, the first the lowest byte: eight bytes of a
+ * sixteen-byte load as one word, which `opt` folds to a bitcast of the
+ * vector's half. One load is one bounds check for sixteen bytes, where eight
+ * reads of `buf[i + k]` would be eight.
+ */
+const http1Lanes = (v: u8x16, at: i32): u64 => {
+  if (at === 0) {
+    return (
+      toU64(extract(v, 0)) |
+      (toU64(extract(v, 1)) << toU64(8)) |
+      (toU64(extract(v, 2)) << toU64(16)) |
+      (toU64(extract(v, 3)) << toU64(24)) |
+      (toU64(extract(v, 4)) << toU64(32)) |
+      (toU64(extract(v, 5)) << toU64(40)) |
+      (toU64(extract(v, 6)) << toU64(48)) |
+      (toU64(extract(v, 7)) << toU64(56))
+    )
+  }
+  return (
+    toU64(extract(v, 8)) |
+    (toU64(extract(v, 9)) << toU64(8)) |
+    (toU64(extract(v, 10)) << toU64(16)) |
+    (toU64(extract(v, 11)) << toU64(24)) |
+    (toU64(extract(v, 12)) << toU64(32)) |
+    (toU64(extract(v, 13)) << toU64(40)) |
+    (toU64(extract(v, 14)) << toU64(48)) |
+    (toU64(extract(v, 15)) << toU64(56))
+  )
+}
+
 /** `http1TakeLine`'s answer when a whole line is ready; never an event. */
 const HTTP1_LINE: i32 = -1
 
@@ -505,14 +566,42 @@ const HTTP1_LINE: i32 = -1
  * Finds the next line: answers `HTTP1_LINE` with it in `lineStart ..
  * lineEnd`, `HTTP1_NEED_MORE` when no LF has arrived yet, or the refusal. A line ends in CRLF and in
  * nothing else; a LF without its CR is a 400. A line that has not ended by
- * `limit` bytes is refused with `overStatus`.
+ * `limit` bytes is refused with `overStatus`. On the way it sets
+ * `lineControl` when the line holds a byte no field value may, which
+ * `http1FieldLine` reads instead of scanning the value again.
  */
 const http1TakeLine = (p: Http1Parser, limit: i32, overStatus: i32): i32 => {
   const buf: u8[] = p.buf
   const end: i32 = p.end
-  let i: i32 = p.scan > p.start ? p.scan : p.start
-  while (i >= 0 && i < end && i < toI32(buf.length)) {
-    if (buf[i] === 10) {
+  let i: i32 = p.start
+  if (p.scan > p.start) {
+    i = p.scan
+  } else {
+    p.lineControl = false
+  }
+  const stop: i32 = end < toI32(buf.length) ? end : toI32(buf.length)
+  if (i < 0) {
+    i = 0
+  }
+  while (i < stop) {
+    // Most bytes are printable: sixteen at a time while a whole vector is,
+    // then one at a time, with no test in either loop but the bytes' and the
+    // bound's.
+    while (i >= 0 && i <= stop - 16 && i <= toI32(buf.length) - 16) {
+      const v: u8x16 = loadU8x16(buf, i)
+      if (http1WordHasControl(http1Lanes(v, 0)) || http1WordHasControl(http1Lanes(v, 8))) {
+        break
+      }
+      i += 16
+    }
+    while (i >= 0 && i < stop && i < toI32(buf.length) && buf[i] >= 32 && buf[i] !== 127) {
+      i += 1
+    }
+    if (i < 0 || i >= stop || i >= toI32(buf.length)) {
+      break
+    }
+    const c: i32 = toI32(buf[i])
+    if (c === 10) {
       if (i === p.start || buf[i - 1] !== 13) {
         return http1Fail(p, 400, "a line ended in a bare LF")
       }
@@ -525,31 +614,49 @@ const http1TakeLine = (p: Http1Parser, limit: i32, overStatus: i32): i32 => {
       p.scan = i + 1
       return HTTP1_LINE
     }
+    if (c === 13 && i + 1 >= stop) {
+      // A CR at the end of the bytes so far: whether it ends the line is
+      // the next byte's to say, so the next call looks at it again.
+      break
+    }
+    if (c !== 9 && !(c === 13 && i + 1 < toI32(buf.length) && buf[i + 1] === 10)) {
+      p.lineControl = true
+    }
     i += 1
   }
-  p.scan = end
+  p.scan = i
   if (end - p.start > limit + 1) {
     return http1Fail(p, overStatus, "a line over its limit")
   }
   return HTTP1_NEED_MORE
 }
 
+/**
+ * The tchars of RFC 9110 §5.6.2 as three 32-bit masks, bit `c - 32`,
+ * `c - 64` and `c - 96` of each: `!` `#`-`'` `*` `+` `-` `.` and the digits
+ * in the first (0x03ff6cfa); the upper-case letters, `^` and `_` in the
+ * second (0xc7fffffe); `` ` ``, the lower-case letters, `|` and `~` in the
+ * third (0x57ffffff). No byte below 33 or above 126 is a tchar. One shift
+ * and mask replaces a chain of fourteen comparisons on the parser's hottest
+ * path (`bench/techempower`).
+ */
+const HTTP1_TCHAR_32: i32 = 67071226
+const HTTP1_TCHAR_64: i32 = -939524098
+const HTTP1_TCHAR_96: i32 = 1476395007
+
 /** Whether `c` is a tchar of RFC 9110 §5.6.2, the bytes a token is made of. */
-export const http1IsTokenByte = (c: i32): boolean =>
-  (c >= 97 && c <= 122) ||
-  (c >= 65 && c <= 90) ||
-  (c >= 48 && c <= 57) ||
-  c === 33 ||
-  (c >= 35 && c <= 39) ||
-  c === 42 ||
-  c === 43 ||
-  c === 45 ||
-  c === 46 ||
-  c === 94 ||
-  c === 95 ||
-  c === 96 ||
-  c === 124 ||
-  c === 126
+export const http1IsTokenByte = (c: i32): boolean => {
+  if (c < 32 || c > 127) {
+    return false
+  }
+  let mask: i32 = HTTP1_TCHAR_96
+  if (c < 64) {
+    mask = HTTP1_TCHAR_32
+  } else if (c < 96) {
+    mask = HTTP1_TCHAR_64
+  }
+  return ((mask >> (c & 31)) & 1) !== 0
+}
 
 /** Whether `c` may appear in a field value (RFC 9110 §5.5): HTAB, SP, VCHAR or obs-text. */
 export const http1IsValueByte = (c: i32): boolean => c === 9 || (c >= 32 && c !== 127)
@@ -720,6 +827,57 @@ const http1Tally = (p: Http1Parser, name: string, word: string): Http1ListTally
   return tally
 }
 
+/** `http1ConnectionOptions`: the Connection list names `close`. */
+const HTTP1_CONNECTION_CLOSE: i32 = 1
+/** `http1ConnectionOptions`: the Connection list names `keep-alive`. */
+const HTTP1_CONNECTION_KEEP_ALIVE: i32 = 2
+/** `http1ConnectionOptions`: the Connection list names `upgrade`. */
+const HTTP1_CONNECTION_UPGRADE: i32 = 4
+
+/**
+ * Which of `close`, `keep-alive` and `upgrade` the Connection fields name,
+ * in any case, as `HTTP1_CONNECTION_` bits: one walk of every Connection
+ * field's list, where three `http1Tally` walks would each read it all. An
+ * element is trimmed of OWS and compared whole, as `http1TallyRun` compares.
+ */
+const http1ConnectionOptions = (p: Http1Parser): i32 => {
+  const spans: i32[] = p.spans
+  const head: u8[] = p.head
+  let found: i32 = 0
+  for (let i: i32 = 0; i < p.headerCount && 4 * i + 3 < toI32(spans.length); i += 1) {
+    if (!http1HeadIs(head, spans[4 * i], spans[4 * i + 1], "connection", false)) {
+      continue
+    }
+    const to: i32 = spans[4 * i + 3]
+    let start: i32 = spans[4 * i + 2]
+    for (let k: i32 = start; k <= to; k += 1) {
+      const c: i32 = k < to && k >= 0 && k < toI32(head.length) ? toI32(head[k]) : 44
+      if (c !== 44) {
+        continue
+      }
+      let a: i32 = start
+      let b: i32 = k
+      while (a >= 0 && a < b && a < toI32(head.length) && http1IsOws(toI32(head[a]))) {
+        a += 1
+      }
+      while (b > a && b - 1 >= 0 && b - 1 < toI32(head.length) && http1IsOws(toI32(head[b - 1]))) {
+        b -= 1
+      }
+      // The length picks the one word an element could be.
+      const n: i32 = b - a
+      if (n === 5 && http1HeadIs(head, a, b, "close", true)) {
+        found = found | HTTP1_CONNECTION_CLOSE
+      } else if (n === 10 && http1HeadIs(head, a, b, "keep-alive", true)) {
+        found = found | HTTP1_CONNECTION_KEEP_ALIVE
+      } else if (n === 7 && http1HeadIs(head, a, b, "upgrade", true)) {
+        found = found | HTTP1_CONNECTION_UPGRADE
+      }
+      start = k + 1
+    }
+  }
+  return found
+}
+
 /**
  * Whether the buffered start of a request line holds more than
  * `HTTP1_MAX_METHOD` bytes before its first space (or line end).
@@ -828,10 +986,10 @@ const http1FieldLine = (p: Http1Parser, keep: boolean): i32 => {
     return http1Fail(p, 400, "a malformed field name")
   }
   const nameEnd: i32 = i
-  for (let k: i32 = nameEnd + 1; k >= 0 && k < b && k < toI32(buf.length); k += 1) {
-    if (!http1IsValueByte(toI32(buf[k]))) {
-      return http1Fail(p, 400, "a control character in a field value")
-    }
+  // The name is tchars and the colon is field text, so a byte no value may
+  // hold anywhere on the line is one in the value.
+  if (p.lineControl) {
+    return http1Fail(p, 400, "a control character in a field value")
   }
   p.fieldCount += 1
   if (p.fieldCount > p.maxHeaders) {
@@ -856,9 +1014,13 @@ const http1FieldLine = (p: Http1Parser, keep: boolean): i32 => {
     }
     const base: i32 = 4 * p.headerCount
     http1SpanSet(p, base + 3, at + (valueEnd - a))
-    http1SpanSet(p, base, at)
-    http1SpanSet(p, base + 1, at + (nameEnd - a))
-    http1SpanSet(p, base + 2, at + (valueStart - a))
+    // The last of the four is set first, so the array has room for them all.
+    const spans: i32[] = p.spans
+    if (base >= 0 && base + 2 < toI32(spans.length)) {
+      spans[base] = at
+      spans[base + 1] = at + (nameEnd - a)
+      spans[base + 2] = at + (valueStart - a)
+    }
     p.headerCount += 1
     if (p.keepText) {
       p.names.push(http1Text(buf, a, nameEnd, true))
@@ -938,12 +1100,12 @@ const http1EndOfHead = (p: Http1Parser): i32 => {
     }
     p.contentLength = size
   }
-  // Each tally is read before the next one reuses it, and none is walked
-  // for a request without a Connection field, which is most of them.
-  const listed: boolean = connectionFields > 0
-  const close: boolean = listed && http1Tally(p, "connection", "close").matches > 0
-  const keep: boolean = listed && http1Tally(p, "connection", "keep-alive").matches > 0
-  const upgradeAsked: boolean = listed && http1Tally(p, "connection", "upgrade").matches > 0
+  // One walk of the Connection list finds all three options, and none is
+  // made for a request without a Connection field.
+  const options: i32 = connectionFields > 0 ? http1ConnectionOptions(p) : 0
+  const close: boolean = (options & HTTP1_CONNECTION_CLOSE) !== 0
+  const keep: boolean = (options & HTTP1_CONNECTION_KEEP_ALIVE) !== 0
+  const upgradeAsked: boolean = (options & HTTP1_CONNECTION_UPGRADE) !== 0
   p.keepAlive = p.minor === 1 ? !close : keep && !close
   // The fields of one name joined with ", " are empty only when there is one
   // field and it is empty: the same test, without the join.
@@ -1405,9 +1567,18 @@ export const http1BytesAre = (bytes: u8[], word: string): boolean =>
 
 /** How many decimal digits `n`, which is not negative, takes. */
 const http1DecimalDigits = (n: i32): i32 => {
-  let digits: i32 = 1
-  let v: i32 = n
-  while (v >= 10) {
+  if (n < 10) {
+    return 1
+  }
+  if (n < 100) {
+    return 2
+  }
+  if (n < 1000) {
+    return 3
+  }
+  let digits: i32 = 4
+  let v: i32 = n / 10000
+  while (v > 0) {
     v = v / 10
     digits += 1
   }
@@ -1425,9 +1596,31 @@ export const http1PutText = (out: u8[], at: i32, text: string): i32 => {
   return at + n
 }
 
-/** Writes `bytes` at `out[at ..)`, likewise. */
+/** Writes CR LF at `out[at ..)`, likewise: two stores, where `http1PutText` walks a string. */
+const http1PutCrlf = (out: u8[], at: i32): i32 => {
+  if (at >= 0 && at < toI32(out.length) - 1) {
+    out[at] = 13
+    out[at + 1] = 10
+  }
+  return at + 2
+}
+
+/** Writes `: ` at `out[at ..)`, likewise. */
+const http1PutColonSpace = (out: u8[], at: i32): i32 => {
+  if (at >= 0 && at < toI32(out.length) - 1) {
+    out[at] = 58
+    out[at + 1] = 32
+  }
+  return at + 2
+}
+
+/** Writes `bytes` at `out[at ..)`, likewise, as one copy when it fits. */
 const http1PutBytes = (out: u8[], at: i32, bytes: u8[]): i32 => {
   const n: i32 = toI32(bytes.length)
+  if (at >= 0 && at <= toI32(out.length) - n) {
+    copyBytes(out, at, bytes, 0, n)
+    return at + n
+  }
   for (let k: i32 = 0; k < n && at + k < toI32(out.length); k += 1) {
     if (at + k >= 0) {
       out[at + k] = bytes[k]
@@ -1525,32 +1718,42 @@ export const http1WriteResponseHead = (
     return HTTP1_NO_ROOM
   }
   let end: i32 = http1PutText(out, at, "HTTP/1.1 ")
-  end = http1PutDecimal(out, end, status)
-  end = http1PutText(out, end, " ")
+  // A status is three digits, checked above: no division loop for them.
+  if (end >= 0 && end < toI32(out.length) - 3) {
+    const hundreds: i32 = status / 100
+    const tens: i32 = status / 10
+    const tensDigit: i32 = tens % 10
+    const ones: i32 = status % 10
+    out[end] = toU8(48 + hundreds)
+    out[end + 1] = toU8(48 + tensDigit)
+    out[end + 2] = toU8(48 + ones)
+    out[end + 3] = 32
+  }
+  end = end + 4
   end = http1PutText(out, end, reason)
-  end = http1PutText(out, end, "\r\n")
+  end = http1PutCrlf(out, end)
   for (let i: i32 = 0; i < count && i < toI32(values.length); i += 1) {
     end = http1PutBytes(out, end, names[i])
-    end = http1PutText(out, end, ": ")
+    end = http1PutColonSpace(out, end)
     end = http1PutBytes(out, end, values[i])
-    end = http1PutText(out, end, "\r\n")
+    end = http1PutCrlf(out, end)
   }
   if (sendDate) {
     end = http1PutText(out, end, "Date: ")
     end = http1PutBytes(out, end, date)
-    end = http1PutText(out, end, "\r\n")
+    end = http1PutCrlf(out, end)
   }
   if (bodyLength >= 0) {
     end = http1PutText(out, end, "Content-Length: ")
     end = http1PutDecimal(out, end, bodyLength)
-    end = http1PutText(out, end, "\r\n")
+    end = http1PutCrlf(out, end)
   } else if (bodyLength === HTTP1_CHUNKED) {
     end = http1PutText(out, end, "Transfer-Encoding: chunked\r\n")
   }
   if (toI32(connection.length) > 0) {
     end = http1PutText(out, end, "Connection: ")
     end = http1PutText(out, end, connection)
-    end = http1PutText(out, end, "\r\n")
+    end = http1PutCrlf(out, end)
   }
-  return http1PutText(out, end, "\r\n")
+  return http1PutCrlf(out, end)
 }

package/std/net/http1-server.ts

@@ -1,6 +1,6 @@
 /**
  * `nish/net/http1-server` — the server side of HTTP/1.1 (RFC 9112): a
- * sans-IO connection that drives `nish/net/http1`'s parser, and two pools of
+ * sans-IO connection that drives `nish/net/http1-codec`'s parser, and two pools of
  * them for a program that owns its readiness loop, one on `nish:net`'s plain
  * TCP and one on `nish/net/tls-tcp` with ALPN `http/1.1`.
  *
@@ -70,14 +70,18 @@
  * most once a second; a 1xx carries none. The pool's slots share one, so a
  * busy server formats a second once, not once a slot. A program that sets its
  * own `date` field sends that one instead, so a response has one `Date`.
- * `date.pin(unixMs)` fixes it, for a test that compares bytes.
+ * `Http1Server` reads the clock once per serve call — from `readable` or
+ * `writable` to the `flush` that ends it — and every response written in
+ * between carries that reading; one written outside a serve call, an answer
+ * given later, reads the clock then. `date.pin(unixMs)` fixes it, for a test
+ * that compares bytes.
  *
- * **Refusals.** Every refusal of `nish/net/http1`'s parser — the smuggling
+ * **Refusals.** Every refusal of `nish/net/http1-codec`'s parser — the smuggling
  * shapes, a `Content-Length` with a `Transfer-Encoding`, two that disagree,
  * a malformed chunk size — is answered with its status (400, 413, 414, 431,
  * 501, 505), `Content-Length: 0` and `Connection: close`, and ends the
  * connection; so does a malformed WebSocket frame, with its close code.
- * `docs/security/http1.md` is the record.
+ * `docs/security/http1-codec.md` is the record.
  *
  * **WebSocket.** A request that asked to upgrade reaches the program like any
  * other; `acceptWebSocket(protocol)` answers it with the 101 of
@@ -141,7 +145,7 @@ import {
   http1WriteChunk,
   http1WriteLastChunk,
   http1WriteResponseHead,
-} from "nish/net/http1"
+} from "nish/net/http1-codec"
 import {
   WS_CLOSE,
   WS_ERROR,
@@ -275,7 +279,8 @@ const http1ServerCopy = (out: u8[], at: i32, src: u8[], off: i32, n: i32): i32 =
  * it calls, `httpDateWrite`, stays in `nish/net/http-fields`, which compiles
  * for wasm32 (the split `nish/crypto/x509` and `x509-random` make). `pin`
  * replaces the clock with one instant, which is how a test asserts a response
- * byte for byte.
+ * byte for byte. `hold` reads the clock once for a run of responses, a serve
+ * call's, until `unhold`; `pin` wins over it.
  */
 export class HttpDate {
   /** The IMF-fixdate of `second`: what `current` answers, made once. */
@@ -284,9 +289,14 @@ export class HttpDate {
   second: i64 = -1
   /** The instant `pin` fixed, in milliseconds since 1970, while `pinned`. */
   pinnedMs: i64 = 0
+  /** The clock reading `hold` took, in milliseconds since 1970, while `held`. */
+  heldMs: i64 = 0
   /** How many times `bytes` has been rewritten. */
   rewrites: i64 = 0
+  /** How many times the wall clock has been read. */
+  reads: i64 = 0
   pinned: boolean = false
+  held: boolean = false
 
   /** A date on the wall clock, with nothing formatted yet. */
   constructor() {
@@ -301,7 +311,10 @@ export class HttpDate {
    * or past 9999 answers the nearer of the two ends.
    */
   current(): u8[] {
-    const ms: i64 = this.pinned ? this.pinnedMs : toI64(Date.now())
+    let ms: i64 = this.pinnedMs
+    if (!this.pinned) {
+      ms = this.held ? this.heldMs : this.now()
+    }
     let second: i64 = ms / 1000
     if (ms < 0) {
       second = 0
@@ -335,6 +348,34 @@ export class HttpDate {
     this.pinned = false
   }
 
+  /**
+   * Reads the wall clock once and makes `current` answer that reading until
+   * `unhold`, so the responses of one serve call cost one read. A pinned date
+   * reads nothing. A second `hold` takes a fresh reading.
+   */
+  hold(): void {
+    if (!this.pinned) {
+      this.heldMs = this.now()
+    }
+    this.held = true
+  }
+
+  /** Puts `current` back on a clock read per call, for a response written outside a serve call. */
+  unhold(): void {
+    this.held = false
+  }
+
+  /** The wall clock, in milliseconds since 1970. */
+  now(): i64 {
+    this.reads += 1
+    return toI64(Date.now())
+  }
+
+  /** How many times the wall clock has been read: once per `hold`, and once per `current` outside one. */
+  clockReads(): i64 {
+    return this.reads
+  }
+
   /** How many times the bytes have been rewritten: one per second that `current` was asked for, at most. */
   formats(): i64 {
     return this.rewrites
@@ -1573,7 +1614,11 @@ export class Http1Server {
    * accepted into, and slot 0's once `connection` has asked for it.
    */
   connections: Http1Connection[]
-  /** The `Date` every slot's responses carry, formatted once a second for all of them. `date.pin` fixes its clock. */
+  /**
+   * The `Date` every slot's responses carry, formatted once a second for all
+   * of them and read from the clock once per serve call: `readable` and
+   * `writable` hold a reading and `flush` lets it go. `date.pin` fixes its clock.
+   */
   date: HttpDate
   /**
    * Each slot's descriptor, or -1 while it is free, for the slots accepted
@@ -1729,12 +1774,15 @@ export class Http1Server {
 
   /**
    * The socket of `slot` is readable: reads it while the connection has room
-   * and the socket has more, then sends. Answers the interest.
+   * and the socket has more, then sends. Answers the interest. It begins a
+   * serve call, which the program's `flush` of the slot ends: the responses
+   * written in between carry one clock reading as their `Date`.
    */
   readable(slot: i32): i32 {
     if (!this.holds(slot)) {
       return H1_DONE
     }
+    this.date.hold()
     const conn: Http1Connection = this.connections[slot]
     const fd: i32 = this.fds[slot]
     let moved: boolean = false
@@ -1768,12 +1816,16 @@ export class Http1Server {
       conn.lastActive = now
       conn.headArrived(now)
     }
-    return this.flush(slot)
+    return this.settle(slot)
   }
 
-  /** The socket of `slot` is writable. Answers the interest. */
+  /** The socket of `slot` is writable: sends, and begins a serve call as `readable` does. Answers the interest. */
   writable(slot: i32): i32 {
-    return this.flush(slot)
+    if (!this.holds(slot)) {
+      return H1_DONE
+    }
+    this.date.hold()
+    return this.settle(slot)
   }
 
   /**
@@ -1797,9 +1849,16 @@ export class Http1Server {
   /**
    * Sends what `slot`'s connection holds until the socket would block, and
    * answers the interest: `H1_DONE` once the connection is over and sent,
-   * otherwise read while it has room and write while it holds bytes.
+   * otherwise read while it has room and write while it holds bytes. It ends
+   * the serve call, so a response written after it reads the clock anew.
    */
   flush(slot: i32): i32 {
+    this.date.unhold()
+    return this.settle(slot)
+  }
+
+  /** `flush` within a serve call: sends, answers the interest, and keeps the clock reading. */
+  settle(slot: i32): i32 {
     if (!this.holds(slot)) {
       return H1_DONE
     }

package/std/net/outbound.ts

@@ -7,13 +7,13 @@
  * reaches services that trust the program's address.
  *
  *     import { OutboundPolicy } from "nish/net/outbound";
- *     import { HttpOptions } from "nish/net/http-client";
+ *     import { HttpOptions } from "nish/net/fetch";
  *
  *     const options = new HttpOptions();
  *     options.outbound = new OutboundPolicy();
  *
  * **The check is on the address, after the lookup.** A name is never judged
- * by its text: `nish/net/http-client` resolves it, drops every address
+ * by its text: `nish/net/fetch` resolves it, drops every address
  * `outboundAddressAllowed` refuses, and connects only to the bytes it kept,
  * with no second lookup, so a name whose answer changes between a check and
  * a connect (DNS rebinding) cannot move the connection. Every redirect hop is