@amritk/nish-x86_64-linux 0.23.1 → 0.24.0

package/std/compress/zlib.ts

@@ -0,0 +1,168 @@
+/**
+ * `nish/compress/zlib` — the zlib format (RFC 1950) around
+ * `nish/compress/deflate`: a two-byte header, the DEFLATE stream and the
+ * Adler-32 of the data, big-endian. What HTTP's `Content-Encoding: deflate`
+ * means (RFC 9110 §8.4.1.2), and what PNG and many protocols carry.
+ *
+ *     import { DEFLATE_DEFAULT } from "nish/compress/deflate";
+ *     import { ZlibCompressor, ZlibDecompressor } from "nish/compress/zlib";
+ *
+ *     const z = new ZlibCompressor(DEFLATE_DEFAULT);
+ *     const end: i32 = z.compress(src, 0, n, out, 0); // -1: no room
+ *     const got: i32 = new ZlibDecompressor().decompress(out, 0, end, back, 0, n); // < 0: an error
+ *
+ * The objects allocate their tables once and nothing per call; the free
+ * functions build one for a single call. The header written is `0x78` and
+ * the `FLEVEL` of the level, with no preset dictionary. Reading refuses a
+ * method other than 8, a window over 32 KB, a header whose check fails
+ * (`ZLIB_ERR_HEADER`) and a preset dictionary (`ZLIB_ERR_DICTIONARY`, since
+ * none can be supplied); a wrong Adler-32 is `ZLIB_ERR_ADLER`, and bytes
+ * after the trailer are `DEFLATE_ERR_TRAILING`.
+ *
+ * Written from RFC 1950.
+ */
+import { adler32 } from "nish/compress/checksum"
+import {
+  DEFLATE_ERR_OUTPUT_LIMIT,
+  DEFLATE_ERR_TRAILING,
+  DEFLATE_ERR_TRUNCATED,
+  DEFLATE_NO_ROOM,
+  Deflater,
+  INFLATE_DONE,
+  INFLATE_NEED_OUTPUT,
+  Inflater,
+} from "nish/compress/deflate"
+
+/** A zlib header that is not one: the wrong method, a window over 32 KB, or a failed check. */
+export const ZLIB_ERR_HEADER: i32 = -12
+
+/** The trailer's Adler-32 is not the Adler-32 of the data. */
+export const ZLIB_ERR_ADLER: i32 = -13
+
+/** The stream needs a preset dictionary (`FDICT`), which this reader has no way to be given. */
+export const ZLIB_ERR_DICTIONARY: i32 = -14
+
+/** Panics unless `buf[off .. off + len)` lies inside `buf`. */
+const zlibWindow = (what: string, buf: u8[], off: i32, len: i32): void => {
+  if (off < 0 || len < 0 || off > toI32(buf.length) - len) {
+    panic(`${what}: the window [${off}, ${off} + ${len}) is outside a buffer of ${toI32(buf.length)} bytes`)
+  }
+}
+
+/** A zlib compressor at one level, allocated once. Not shared between threads. */
+export class ZlibCompressor {
+  readonly deflater: Deflater
+
+  /** A compressor at `level`, 0 to 9; another level panics. */
+  constructor(level: i32) {
+    this.deflater = new Deflater(level)
+  }
+
+  /**
+   * Compresses `src[off .. off + len)` into `out` from `at` as one zlib
+   * stream and answers where it ends, or `DEFLATE_NO_ROOM` (-1) when `out`
+   * cannot hold it; `compressBound(len)` bytes always can. A window outside
+   * its array panics. Allocates nothing.
+   */
+  compress(src: u8[], off: i32, len: i32, out: u8[], at: i32): i32 {
+    zlibWindow("ZlibCompressor.compress", src, off, len)
+    zlibWindow("ZlibCompressor.compress", out, at, 0)
+    if (toI32(out.length) - at < 6) {
+      return DEFLATE_NO_ROOM
+    }
+    const level: i32 = this.deflater.level
+    // FLEVEL (§2.2): fastest, fast, default, slowest.
+    let flevel: i32 = 3
+    if (level < 2) {
+      flevel = 0
+    } else if (level < 6) {
+      flevel = 1
+    } else if (level === 6) {
+      flevel = 2
+    }
+    const cmf: i32 = 0x78
+    let flg: i32 = flevel << 6
+    flg += (toI32(31) - ((cmf * 256 + flg) % 31)) % 31
+    out[at] = toU8(cmf)
+    out[at + 1] = toU8(flg)
+    const end: i32 = this.deflater.compress(src, off, len, out, at + 2)
+    if (end < 0 || toI32(out.length) - end < 4) {
+      return DEFLATE_NO_ROOM
+    }
+    const a: u32 = adler32(src, off, len)
+    out[end] = toU8(a >>> 24)
+    out[end + 1] = toU8((a >>> 16) & 255)
+    out[end + 2] = toU8((a >>> 8) & 255)
+    out[end + 3] = toU8(a & 255)
+    return end + 4
+  }
+}
+
+/** A zlib decompressor, allocated once. Not shared between threads. */
+export class ZlibDecompressor {
+  readonly inflater: Inflater
+
+  /** Builds the tables. */
+  constructor() {
+    this.inflater = new Inflater()
+  }
+
+  /**
+   * Decompresses the zlib stream `src[off .. off + len)` into `out` from
+   * `at`, writing at most `limit` bytes and never past `out`'s end, and
+   * answers where the output ends, or a negative `ZLIB_ERR_*` or
+   * `DEFLATE_ERR_*`. A window outside its array, or a negative `limit`,
+   * panics. Allocates nothing.
+   */
+  decompress(src: u8[], off: i32, len: i32, out: u8[], at: i32, limit: i32): i32 {
+    zlibWindow("ZlibDecompressor.decompress", src, off, len)
+    zlibWindow("ZlibDecompressor.decompress", out, at, 0)
+    if (limit < 0) {
+      panic("ZlibDecompressor.decompress: a negative limit")
+    }
+    if (len < 2) {
+      return DEFLATE_ERR_TRUNCATED
+    }
+    const cmf: i32 = toI32(src[off])
+    const flg: i32 = toI32(src[off + 1])
+    if ((cmf & 15) !== 8 || cmf >> 4 > 7 || (cmf * 256 + flg) % 31 !== 0) {
+      return ZLIB_ERR_HEADER
+    }
+    if ((flg & 0x20) !== 0) {
+      return ZLIB_ERR_DICTIONARY
+    }
+    const room: i32 = toI32(out.length) - at
+    const outEnd: i32 = at + (limit < room ? limit : room)
+    const inf: Inflater = this.inflater
+    inf.reset()
+    const end: i32 = off + len
+    const r: i32 = inf.inflate(src, off + 2, end, false, out, at, outEnd, at)
+    if (r === INFLATE_NEED_OUTPUT) {
+      return DEFLATE_ERR_OUTPUT_LIMIT
+    }
+    if (r !== INFLATE_DONE) {
+      return r
+    }
+    const q: i32 = inf.inPos
+    if (end - q < 4) {
+      return DEFLATE_ERR_TRUNCATED
+    }
+    const want: u32 =
+      (toU32(src[q]) << 24) | (toU32(src[q + 1]) << 16) | (toU32(src[q + 2]) << 8) | toU32(src[q + 3])
+    if (adler32(out, at, inf.outPos - at) !== want) {
+      return ZLIB_ERR_ADLER
+    }
+    if (q + 4 !== end) {
+      return DEFLATE_ERR_TRAILING
+    }
+    return inf.outPos
+  }
+}
+
+/** `ZlibCompressor.compress` at `level`, building the compressor for this call alone. */
+export const zlibCompress = (src: u8[], off: i32, len: i32, out: u8[], at: i32, level: i32): i32 =>
+  new ZlibCompressor(level).compress(src, off, len, out, at)
+
+/** `ZlibDecompressor.decompress`, building the decompressor for this call alone. */
+export const zlibDecompress = (src: u8[], off: i32, len: i32, out: u8[], at: i32, limit: i32): i32 =>
+  new ZlibDecompressor().decompress(src, off, len, out, at, limit)

package/std/crypto/sha256.ts

@@ -215,9 +215,8 @@ const sha256Compress = (h: u32[], w: u32[], src: u8[], at: i32): void => {
   // early exit, because that is the shape that proves the plain `w[t]` and
   // `h[i]` indices in range and drops their bounds checks. The computed ones —
   // the byte reads in `sha256LoadWord` and `w[t - 2]` and its kin — keep a
-  // check each; measured, removing every check (with `--unchecked-indexing`,
-  // which no longer reaches a `nish/` module at all) moved the 1 MiB time by
-  // less than the run-to-run noise.
+  // check each; measured, removing every check moved the 1 MiB time by less
+  // than the run-to-run noise.
   if (toI32(h.length) >= 8 && toI32(w.length) >= 64 && at >= 0 && at <= toI32(src.length) - SHA256_BLOCK) {
     // Step 1: the message schedule.
     for (let t: i32 = 0; t < 16; t += 1) {

package/std/crypto/x25519.ts

@@ -21,10 +21,9 @@
  *   subtraction needs no bias and a carry is a floor division that works the
  *   same on a negative limb.
  *
- * Signed `i64` overflow is undefined behaviour in this language, and
- * `--wrapping` does not reach a `nish/` module (only `wrappingAdd`,
- * `wrappingSub` and `wrappingMul` from `nish:unsafe` define a wrap, at the
- * site that calls one), so the limb bounds below are not a nicety: each function states what it accepts and what it answers, and
+ * Signed `i64` overflow is undefined behaviour in this language (only
+ * `wrappingAdd`, `wrappingSub` and `wrappingMul` from `nish:unsafe` define a
+ * wrap, at the site that calls one), so the limb bounds below are not a nicety: each function states what it accepts and what it answers, and
  * `f25519Mul` says why its sums fit.
  *
  * **Constant time, by construction, and in part by disassembly.** Nothing

package/std/net/http-compress.ts

@@ -0,0 +1,393 @@
+/**
+ * `nish/net/http-compress` — content coding for HTTP responses (RFC 9110
+ * §8.4 and §12.5.3): reading a request's `Accept-Encoding` and compressing a
+ * body with `Content-Encoding: gzip`, for any of the three servers.
+ *
+ *     import { DEFLATE_FAST } from "nish/compress/deflate";
+ *     import { HTTP_CODING_GZIP, HttpCompressor } from "nish/net/http-compress";
+ *
+ *     const enc = new HttpCompressor(DEFLATE_FAST, 1024, 65536); // once per thread
+ *     // HTTP/1.1, in one call:
+ *     conn.respondEncoded(200, names, values, body, 0, n, enc, conn.acceptEncoding());
+ *     // HTTP/2 or HTTP/3, by hand:
+ *     const coding: i32 = httpAcceptEncoding(value, 0, toI32(value.length), HTTP_OFFER_GZIP);
+ *     const m: i32 = enc.compress(coding, body, 0, n);
+ *     if (m >= 0) {
+ *       enc.addFields(names, values);
+ *       h2.respond(id, 200, enc.names, enc.values, false);
+ *       h2.write(id, enc.output, 0, m);
+ *     }
+ *
+ * **Opt-in.** Nothing here runs unless the program asks: it decides which
+ * responses to compress, and `HttpCompressor` declines any body shorter than
+ * its `minLength`, longer than its `maxLength`, or that gzip would not make
+ * smaller, answering -1 so the program sends the bytes as they are.
+ *
+ * **Negotiation** (`httpAcceptEncoding`) follows §12.5.3: each listed coding
+ * with its q-value, `x-gzip` as `gzip`, `*` for every coding not listed, and
+ * `identity` acceptable unless it is given q=0, directly or through `*`. Of
+ * the codings the program offers, the most preferred with q above 0 wins, the
+ * program's order (gzip, then deflate) breaking ties; it beats `identity` at
+ * an equal q, and beats an `identity` the field does not mention at any q. With no field at all the answer is
+ * `HTTP_CODING_IDENTITY` (the RFC allows any coding then, but a client that
+ * says nothing is safest sent nothing it may not read); an empty field asks
+ * for identity too. `HTTP_CODING_NONE` means nothing offered is acceptable
+ * and identity is refused: a server may answer 406 or send identity anyway.
+ * A malformed element is skipped. The parser allocates nothing.
+ *
+ * **Compressing allocates nothing**: `HttpCompressor` holds a
+ * `GzipCompressor`, an output buffer of `compressBound(maxLength)` bytes and
+ * the field arrays `addFields` fills, all built once.
+ * `HTTP_CODING_DEFLATE` (zlib framing) is negotiated but not produced: a
+ * client that accepts only `deflate` is sent identity, which every client
+ * reads.
+ */
+import { DEFLATE_FAST, compressBound } from "nish/compress/deflate"
+import { GzipCompressor } from "nish/compress/gzip"
+
+/** No content coding: the body as it is. */
+export const HTTP_CODING_IDENTITY: i32 = 0
+
+/** `gzip` (RFC 9110 §8.4.1.3), or its alias `x-gzip`. */
+export const HTTP_CODING_GZIP: i32 = 1
+
+/** `deflate`: the zlib format (RFC 9110 §8.4.1.2). */
+export const HTTP_CODING_DEFLATE: i32 = 2
+
+/** Nothing offered is acceptable, identity included (§12.5.3: 406, or identity anyway). */
+export const HTTP_CODING_NONE: i32 = -1
+
+/** `httpAcceptEncoding`'s `offered` bits: the program can send gzip, deflate. */
+export const HTTP_OFFER_GZIP: i32 = 1
+export const HTTP_OFFER_DEFLATE: i32 = 2
+
+/** A q-value of 1, in thousandths. */
+const HTTP_Q_ONE: i32 = 1000
+
+/** Whether `c` is an ASCII letter, digit or one of the token characters a coding uses. */
+const httpCodingChar = (c: i32): boolean =>
+  (c >= 97 && c <= 122) ||
+  (c >= 65 && c <= 90) ||
+  (c >= 48 && c <= 57) ||
+  c === 45 ||
+  c === 46 ||
+  c === 95 ||
+  c === 42 ||
+  c === 33 ||
+  c === 35 ||
+  c === 36 ||
+  c === 37 ||
+  c === 38 ||
+  c === 39 ||
+  c === 43 ||
+  c === 94 ||
+  c === 96 ||
+  c === 124 ||
+  c === 126
+
+/** Whether `buf[start .. end)` is `word`, ignoring ASCII case; `word` is lower case. */
+const httpCodingIs = (buf: u8[], start: i32, end: i32, word: string): boolean => {
+  if (end - start !== toI32(word.length)) {
+    return false
+  }
+  for (let i: i32 = 0; i < end - start && i < toI32(word.length); i += 1) {
+    let c: i32 = toI32(buf[start + i])
+    if (c >= 65 && c <= 90) {
+      c += 32
+    }
+    if (c !== toI32(word.charCodeAt(i))) {
+      return false
+    }
+  }
+  return true
+}
+
+/**
+ * The q-value of `buf[start .. end)`, in thousandths (RFC 9110 §12.4.2:
+ * `0`, `0.` and up to three digits, `1`, `1.` and up to three zeros), or -1
+ * when it is not one.
+ */
+const httpQValue = (buf: u8[], start: i32, end: i32): i32 => {
+  if (start >= end) {
+    return -1
+  }
+  const lead: i32 = toI32(buf[start])
+  if (lead !== 48 && lead !== 49) {
+    return -1
+  }
+  let q: i32 = lead === 49 ? HTTP_Q_ONE : 0
+  if (start + 1 === end) {
+    return q
+  }
+  if (buf[start + 1] !== 46 || end - start > 5) {
+    return -1
+  }
+  let scale: i32 = 100
+  for (let i: i32 = start + 2; i < end && i >= 0 && i < toI32(buf.length); i += 1) {
+    const d: i32 = toI32(buf[i]) - 48
+    if (d < 0 || d > 9 || (lead === 49 && d !== 0)) {
+      return -1
+    }
+    q += d * scale
+    scale = scale / 10
+  }
+  return q
+}
+
+/** A coding's q: its own when listed, else `*`'s when that is, else 0. */
+const httpQOrStar = (own: i32, star: i32): i32 => {
+  if (own >= 0) {
+    return own
+  }
+  return star >= 0 ? star : 0
+}
+
+/** Whether `c` is optional whitespace (SP or HTAB). */
+const httpOws = (c: i32): boolean => c === 32 || c === 9
+
+/**
+ * The content coding to send for the `Accept-Encoding` field value
+ * `buf[start .. end)` among the codings `offered` (`HTTP_OFFER_GZIP |
+ * HTTP_OFFER_DEFLATE`): `HTTP_CODING_GZIP`, `HTTP_CODING_DEFLATE`,
+ * `HTTP_CODING_IDENTITY` or `HTTP_CODING_NONE`, by the rules in the module
+ * comment. A window outside `buf` panics.
+ */
+export const httpAcceptEncoding = (buf: u8[], start: i32, end: i32, offered: i32): i32 => {
+  if (start < 0 || start > end || end > toI32(buf.length)) {
+    panic("httpAcceptEncoding: the window lies outside its buffer")
+  }
+  let qGzip: i32 = -1
+  let qDeflate: i32 = -1
+  let qIdentity: i32 = -1
+  let qStar: i32 = -1
+  let p: i32 = start
+  while (p < end) {
+    // One element: OWS coding OWS *( ";" OWS name "=" value ) OWS ","
+    while (p < end && (httpOws(toI32(buf[p])) || buf[p] === 44)) {
+      p += 1
+    }
+    const codingStart: i32 = p
+    while (p < end && httpCodingChar(toI32(buf[p]))) {
+      p += 1
+    }
+    const codingEnd: i32 = p
+    let q: i32 = HTTP_Q_ONE
+    let valid: boolean = codingEnd > codingStart
+    while (p < end && buf[p] !== 44) {
+      while (p < end && httpOws(toI32(buf[p]))) {
+        p += 1
+      }
+      if (p >= end || buf[p] === 44) {
+        break
+      }
+      if (buf[p] !== 59) {
+        valid = false
+        while (p < end && buf[p] !== 44) {
+          p += 1
+        }
+        break
+      }
+      p += 1
+      while (p < end && httpOws(toI32(buf[p]))) {
+        p += 1
+      }
+      const nameStart: i32 = p
+      while (p < end && httpCodingChar(toI32(buf[p]))) {
+        p += 1
+      }
+      const nameEnd: i32 = p
+      if (p >= end || buf[p] !== 61) {
+        valid = false
+        continue
+      }
+      p += 1
+      const valueStart: i32 = p
+      while (p < end && httpCodingChar(toI32(buf[p]))) {
+        p += 1
+      }
+      if (httpCodingIs(buf, nameStart, nameEnd, "q")) {
+        q = httpQValue(buf, valueStart, p)
+        if (q < 0) {
+          valid = false
+        }
+      }
+    }
+    if (valid) {
+      if (
+        httpCodingIs(buf, codingStart, codingEnd, "gzip") ||
+        httpCodingIs(buf, codingStart, codingEnd, "x-gzip")
+      ) {
+        qGzip = q
+      } else if (httpCodingIs(buf, codingStart, codingEnd, "deflate")) {
+        qDeflate = q
+      } else if (httpCodingIs(buf, codingStart, codingEnd, "identity")) {
+        qIdentity = q
+      } else if (httpCodingIs(buf, codingStart, codingEnd, "*")) {
+        qStar = q
+      }
+    }
+  }
+  const gzip: i32 = (offered & HTTP_OFFER_GZIP) === 0 ? 0 : httpQOrStar(qGzip, qStar)
+  const deflate: i32 = (offered & HTTP_OFFER_DEFLATE) === 0 ? 0 : httpQOrStar(qDeflate, qStar)
+  // `identity` unlisted (and not reached by `*`) is acceptable but stated no
+  // preference, so any offered coding with q above 0 is sent before it.
+  let identity: i32 = -1
+  if (qIdentity >= 0) {
+    identity = qIdentity
+  } else if (qStar >= 0) {
+    identity = qStar
+  }
+  let coding: i32 = HTTP_CODING_NONE
+  let codingQ: i32 = 0
+  if (deflate > gzip) {
+    coding = HTTP_CODING_DEFLATE
+    codingQ = deflate
+  } else if (gzip > 0) {
+    coding = HTTP_CODING_GZIP
+    codingQ = gzip
+  }
+  if (coding !== HTTP_CODING_NONE && codingQ >= identity) {
+    return coding
+  }
+  if (identity !== 0) {
+    return HTTP_CODING_IDENTITY
+  }
+  return HTTP_CODING_NONE
+}
+
+/** The bytes of an ASCII string. */
+const httpCompressBytes = (text: string): u8[] => {
+  const out: u8[] = new Array<u8>(toI32(text.length))
+  for (let i: i32 = 0; i < toI32(text.length) && i < toI32(out.length); i += 1) {
+    out[i] = toU8(text.charCodeAt(i))
+  }
+  return out
+}
+
+/**
+ * Compresses response bodies with gzip into a buffer of its own, and builds
+ * the response fields that say so. One per thread; allocated once.
+ */
+export class HttpCompressor {
+  readonly gzip: GzipCompressor
+  /** Where `compress` writes; valid until the next call. */
+  readonly output: u8[]
+  /** The fields `addFields` built: the program's, then `Content-Encoding` and `Vary`. */
+  readonly names: u8[][]
+  readonly values: u8[][]
+  readonly contentEncodingName: u8[]
+  readonly gzipValue: u8[]
+  readonly varyName: u8[]
+  readonly acceptEncodingValue: u8[]
+  /** The shortest body worth compressing, and the longest the output can hold. */
+  readonly minLength: i32
+  readonly maxLength: i32
+  /**
+   * Whether `addFields` adds `Vary: Accept-Encoding` (RFC 9110 §12.5.5), which
+   * a cache needs whenever the same resource may be sent either way. On by
+   * default; turn it off when the program sets its own `Vary`.
+   */
+  vary: boolean
+
+  /**
+   * A compressor at `level` (`DEFLATE_FAST` suits a server) for bodies of
+   * `minLength` to `maxLength` bytes. A level outside 0 to 9, a negative
+   * `minLength` or a `maxLength` below it panics.
+   */
+  constructor(level: i32, minLength: i32, maxLength: i32) {
+    if (minLength < 0 || maxLength < minLength) {
+      panic("HttpCompressor: the lengths are out of order")
+    }
+    this.gzip = new GzipCompressor(level)
+    this.output = new Array<u8>(compressBound(maxLength))
+    this.names = []
+    this.values = []
+    this.contentEncodingName = httpCompressBytes("content-encoding")
+    this.gzipValue = httpCompressBytes("gzip")
+    this.varyName = httpCompressBytes("vary")
+    this.acceptEncodingValue = httpCompressBytes("accept-encoding")
+    this.minLength = minLength
+    this.maxLength = maxLength
+    this.vary = true
+  }
+
+  /**
+   * Compresses `body[off .. off + len)` into `output` when `coding` is
+   * `HTTP_CODING_GZIP`, the length is in `[minLength, maxLength]` and gzip
+   * makes it smaller; answers the compressed length, or -1 to send the body
+   * as it is. A window outside `body` panics.
+   */
+  compress(coding: i32, body: u8[], off: i32, len: i32): i32 {
+    if (off < 0 || len < 0 || off > toI32(body.length) - len) {
+      panic("HttpCompressor.compress: the window lies outside its body")
+    }
+    if (coding !== HTTP_CODING_GZIP || len < this.minLength || len > this.maxLength) {
+      return -1
+    }
+    const n: i32 = this.gzip.compress(body, off, len, this.output, toI32(0))
+    if (n < 0 || n >= len) {
+      return -1
+    }
+    return n
+  }
+
+  /**
+   * Sets `names` / `values` to the program's fields followed by
+   * `Content-Encoding: gzip` and, when `vary`, `Vary: Accept-Encoding`. The
+   * arrays are reused, so after the first few calls this allocates nothing;
+   * they hold until the next call.
+   */
+  addFields(names: u8[][], values: u8[][]): void {
+    while (this.names.length > 0) {
+      this.names.pop()
+    }
+    while (this.values.length > 0) {
+      this.values.pop()
+    }
+    for (let i: i32 = 0; i < toI32(values.length); i += 1) {
+      if (i < toI32(names.length)) {
+        const name: u8[] = names[i]
+        const value: u8[] = values[i]
+        this.names.push(name)
+        this.values.push(value)
+      }
+    }
+    this.names.push(this.contentEncodingName)
+    this.values.push(this.gzipValue)
+    this.addVary()
+  }
+
+  /** Appends `Vary: Accept-Encoding` to the arrays `addFields` built when `vary` is set. */
+  addVary(): void {
+    if (this.vary) {
+      this.names.push(this.varyName)
+      this.values.push(this.acceptEncodingValue)
+    }
+  }
+
+  /**
+   * Sets `names` / `values` to the program's fields and, when `vary`,
+   * `Vary: Accept-Encoding`: the fields of a body sent as it is from a
+   * resource that is sometimes compressed.
+   */
+  identityFields(names: u8[][], values: u8[][]): void {
+    while (this.names.length > 0) {
+      this.names.pop()
+    }
+    while (this.values.length > 0) {
+      this.values.pop()
+    }
+    for (let i: i32 = 0; i < toI32(values.length); i += 1) {
+      if (i < toI32(names.length)) {
+        const name: u8[] = names[i]
+        const value: u8[] = values[i]
+        this.names.push(name)
+        this.values.push(value)
+      }
+    }
+    this.addVary()
+  }
+}
+
+/** A compressor for the usual server: `DEFLATE_FAST`, bodies of 1 KB to 1 MB. */
+export const httpCompressorDefault = (): HttpCompressor => new HttpCompressor(DEFLATE_FAST, 1024, 1048576)

package/std/net/http1-server.ts

@@ -114,6 +114,12 @@
  */
 import { Secret } from "nish:secret"
 import { copyBytes } from "nish/bytes"
+import {
+  HTTP_CODING_IDENTITY,
+  HTTP_OFFER_GZIP,
+  HttpCompressor,
+  httpAcceptEncoding,
+} from "nish/net/http-compress"
 import { netClose, netRead, netWrite, tcpAccept } from "nish:net"
 import {
   HTTP1_BODY,
@@ -1205,6 +1211,95 @@ export class Http1Connection {
     return 0
   }
 
+  // ---- Content coding -----------------------------------------------------------
+
+  /**
+   * The content coding to answer the current request with, read from its
+   * `Accept-Encoding` with gzip offered (`httpAcceptEncoding`):
+   * `HTTP_CODING_GZIP`, `HTTP_CODING_IDENTITY` (also with no such field), or
+   * `HTTP_CODING_NONE` when the client refuses identity and does not take
+   * gzip. Allocates nothing.
+   */
+  acceptEncoding(): i32 {
+    const parser: Http1Parser = this.parser
+    const i: i32 = parser.headerIndex("accept-encoding")
+    const spans: i32[] = parser.spans
+    if (i < 0 || 4 * i + 3 >= toI32(spans.length)) {
+      return HTTP_CODING_IDENTITY
+    }
+    const start: i32 = spans[4 * i + 2]
+    const end: i32 = spans[4 * i + 3]
+    if (start < 0 || start > end || end > toI32(parser.head.length)) {
+      return HTTP_CODING_IDENTITY
+    }
+    return httpAcceptEncoding(parser.head, start, end, HTTP_OFFER_GZIP)
+  }
+
+  /**
+   * Answers the current request with all of `body[off .. off + len)` in one
+   * call: `respond`, `write` and `end`, the body compressed by `enc` when
+   * `coding` (from `acceptEncoding`) is gzip and `enc.compress` takes it,
+   * with `Content-Encoding: gzip` and the compressed `Content-Length`, and
+   * otherwise sent as it is; `Vary: Accept-Encoding` either way while
+   * `enc.vary` is set. The program's fields may not name `Content-Encoding`
+   * or, with `enc.vary`, `Vary`. The whole response is written or none of
+   * it: `H1_AGAIN` when the output has no room for it yet (`H1_WRITE` says
+   * when to try again, compressing again), `H1_INVALID` for a response
+   * larger than the output could ever hold or one `respond` refuses,
+   * `H1_CLOSED` with no request to answer; 0 once it is queued. A window
+   * outside `body` panics.
+   */
+  respondEncoded(
+    status: i32,
+    names: u8[][],
+    values: u8[][],
+    body: u8[],
+    off: i32,
+    len: i32,
+    enc: HttpCompressor,
+    coding: i32
+  ): i32 {
+    http1ServerCheckWindow("Http1Connection.respondEncoded", body, off, len)
+    if (!this.answerable()) {
+      return H1_CLOSED
+    }
+    const packed: i32 = enc.compress(coding, body, off, len)
+    let n: i32 = len
+    if (packed >= 0) {
+      enc.addFields(names, values)
+      n = packed
+    } else {
+      enc.identityFields(names, values)
+    }
+    // `respond` and the body together, or neither: what `respond` sets is
+    // put back when the body does not fit behind the head.
+    const outputEnd: i32 = this.outputEnd
+    const closeAfter: boolean = this.closeAfter
+    const r: i32 = this.respond(status, enc.names, enc.values, n)
+    if (r !== 0) {
+      return r
+    }
+    if (!this.responseEmpty && n > this.bodyRoom()) {
+      const fits: boolean = this.outputEnd - outputEnd + n <= this.config.outputSize - H1_CONTROL_RESERVE
+      this.outputEnd = outputEnd
+      this.closeAfter = closeAfter
+      this.response = H1_R_NONE
+      this.responseFraming = 0
+      this.responseLeft = 0
+      this.responseEmpty = false
+      if (!fits) {
+        return H1_INVALID
+      }
+      this.writeHeld = true
+      return H1_AGAIN
+    }
+    const w: i32 = packed >= 0 ? this.write(enc.output, toI32(0), n) : this.write(body, off, n)
+    if (w !== n) {
+      panic("Http1Connection.respondEncoded: a body the room was checked for did not fit")
+    }
+    return this.end()
+  }
+
   // ---- WebSocket ----------------------------------------------------------------
 
   /**