@amritk/nish-aarch64-darwin 0.34.0 → 0.34.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amritk/nish-aarch64-darwin",
-  "version": "0.34.0",
+  "version": "0.34.1",
   "description": "The nish native compiler for macOS on ARM64",
   "license": "MIT",
   "os": [

package/std/bytes.ts

@@ -26,7 +26,10 @@
  * inside a call, and after `getU32LE` inlines, LLVM keeps the checks on
  * `off + 1` to `off + 3`, because the guard compares the length truncated to
  * `i32` and the checks compare it unsigned at 64 bits. A loop that needs them
- * gone indexes the bytes itself.
+ * gone indexes the bytes itself. `getU64BE`, and with it `getI64BE` and
+ * `getF64BE`, is the exception: it checks the whole range once and reads the
+ * eight bytes unchecked, which lowers to one load and a byte swap. An offset
+ * outside the range still goes byte by byte, so it panics as the others do.
  *
  * The in-range answers are byte for byte those of the copies `std/` keeps for
  * itself: `sha256LoadWord` (`std/crypto/sha256.ts`) for `getU32BE`,
@@ -91,8 +94,8 @@ export const getU64LE = (b: u8[], off: i32): u64 => {
   return v
 }
 
-/** The `u64` whose bytes, most significant first, are `b[off]` to `b[off + 7]`. */
-export const getU64BE = (b: u8[], off: i32): u64 => {
+/** `getU64BE` a byte at a time, each index checked: the path for an offset whose eight bytes are not all in the array. */
+const getU64BEByByte = (b: u8[], off: i32): u64 => {
   let v = toU64(0)
   for (let i: i32 = 0; i < 8; i++) {
     v = (v << toU64(8)) | toU64(b[off + i])
@@ -100,6 +103,26 @@ export const getU64BE = (b: u8[], off: i32): u64 => {
   return v
 }
 
+/**
+ * The `u64` whose bytes, most significant first, are `b[off]` to `b[off + 7]`.
+ * The fast path's ors are grouped in pairs, which LLVM folds into one load and
+ * a `bswap`; a flat chain of eight `or`s stayed byte by byte. The byte loop is
+ * its own function so its last load is not merged with the fast path's.
+ */
+export const getU64BE = (b: u8[], off: i32): u64 => {
+  if (off >= 0 && off < 2147483640 && off + 8 <= toI32(b.length)) {
+    return (
+      (toU64(b[off]) << toU64(56)) |
+      (toU64(b[off + 1]) << toU64(48)) |
+      ((toU64(b[off + 2]) << toU64(40)) | (toU64(b[off + 3]) << toU64(32))) |
+      ((toU64(b[off + 4]) << toU64(24)) |
+        (toU64(b[off + 5]) << toU64(16)) |
+        ((toU64(b[off + 6]) << toU64(8)) | toU64(b[off + 7])))
+    )
+  }
+  return getU64BEByByte(b, off)
+}
+
 /** `getU32LE`'s bits as a two's-complement `i32`. */
 export const getI32LE = (b: u8[], off: i32): i32 => toI32(getU32LE(b, off))
 

package/std/crypto/base64url.ts

@@ -127,8 +127,9 @@ export const base64urlEncode = (data: u8[]): string => {
  * one canonical spelling of any byte string — see the module comment for the
  * five refusals.
  *
- * The same accumulator as `base64urlEncode`, run the other way: six bits in per
- * character, eight out per byte.
+ * Each group of four characters becomes one 24-bit word, six bits a
+ * character, which splits into three bytes; a short final group of two or
+ * three characters fills the top of the word and gives one or two.
  */
 export const base64urlDecode = (text: string): u8[] | null => {
   // A text past 2^31 - 1 bytes is refused before `toI32`, which would
@@ -148,31 +149,51 @@ export const base64urlDecode = (text: string): u8[] | null => {
   // short final group; `n * 3 / 4` would overflow for a text over 700 MB.
   const out: u8[] = new Array<u8>((n >> 2) * 3 + (tail === 0 ? 0 : tail - 1))
   const outLen: i32 = toI32(out.length)
-  // All ones once any character is outside the alphabet (its sextet of `-1`
+  // All ones once any character is outside the alphabet (a sextet of `-1`
   // shifted right by 31), and non-zero once the text ends on a bit that
   // encodes no byte.
   let bad: i32 = 0
-  let acc: i32 = 0
-  let bits: i32 = 0
+  // Four characters make one 24-bit word and three bytes, so a full group has
+  // no count of waiting bits to test, and its four sextets are independent.
   let j: i32 = 0
-  for (let k: i32 = 0; k < n; k++) {
-    const v: i32 = base64urlSextetOf(toI32(text.charCodeAt(k)))
-    bad = bad | (v >> 31)
-    acc = ((acc << 6) | (v & 63)) & 0xfff
-    bits += 6
-    if (bits >= 8) {
-      bits -= 8
-      // Always true — `out` was sized from the same length — but written out
-      // so that the store keeps no bounds check.
-      if (j >= 0 && j < outLen) {
-        out[j] = toU8((acc >> bits) & 255)
-      }
-      j++
+  for (let k: i32 = 0; k + 3 < n; k += 4) {
+    const s0: i32 = base64urlSextetOf(toI32(text.charCodeAt(k)))
+    const s1: i32 = base64urlSextetOf(toI32(text.charCodeAt(k + 1)))
+    const s2: i32 = base64urlSextetOf(toI32(text.charCodeAt(k + 2)))
+    const s3: i32 = base64urlSextetOf(toI32(text.charCodeAt(k + 3)))
+    bad = bad | ((s0 | s1 | s2 | s3) >> 31)
+    const word: i32 = ((s0 & 63) << 18) | ((s1 & 63) << 12) | ((s2 & 63) << 6) | (s3 & 63)
+    // Always true — `out` was sized from the same length — but written out so
+    // that the three stores keep no bounds check.
+    if (j >= 0 && j + 2 < outLen) {
+      out[j] = toU8(word >> 16)
+      out[j + 1] = toU8((word >> 8) & 255)
+      out[j + 2] = toU8(word & 255)
     }
+    j += 3
+  }
+  // A short final group of two or three characters: one or two bytes, and the
+  // four or two bits left over belong to no byte, so they must be zero for `AA`
+  // to be the only spelling of a zero byte and `AB` refused (RFC 4648 §3.5).
+  if (tail !== 0) {
+    const k: i32 = n - tail
+    const s0: i32 = base64urlSextetOf(toI32(text.charCodeAt(k)))
+    const s1: i32 = base64urlSextetOf(toI32(text.charCodeAt(k + 1)))
+    // A third character only when the tail has one; a two-character tail reads
+    // its place as `A`, the zero sextet, which adds no bits.
+    const s2: i32 = tail === 3 ? base64urlSextetOf(toI32(text.charCodeAt(k + 2))) : 0
+    bad = bad | ((s0 | s1 | s2) >> 31)
+    const word: i32 = ((s0 & 63) << 18) | ((s1 & 63) << 12) | ((s2 & 63) << 6)
+    if (j >= 0 && j < outLen) {
+      out[j] = toU8(word >> 16)
+    }
+    if (tail === 3 && j + 1 >= 0 && j + 1 < outLen) {
+      out[j + 1] = toU8((word >> 8) & 255)
+    }
+    // The bits under the last byte written: sixteen of the word when one byte
+    // was, eight when two were.
+    bad = bad | (word & (tail === 2 ? 0xffff : 0xff))
   }
-  // The two or four bits left over belong to no byte, and must be zero so that
-  // `AA` is the only spelling of a zero byte and `AB` is refused (RFC 4648 §3.5).
-  bad = bad | (acc & ((1 << bits) - 1))
   if (bad !== 0) {
     return null
   }

package/std/crypto/bcrypt.ts

@@ -1021,12 +1021,14 @@ const bcryptLoadSlot = (state: Secret<u32[]>, password: Secret<u8[]>, slot: i32)
 }
 
 // The cost-round kernels, one per width. Each is `bcryptBody4`'s text with
-// the lane count changed (bench/crypto/bcrypt/gen-body.mjs writes them), not
+// the lane count changed, except that six lanes' sixth lane takes its bytes
+// the previous way (see `bcryptBody4`); bench/crypto/bcrypt/gen-body.mjs
+// writes them all, so an edit is made there. They are not
 // one loop over a lane count: the lanes' l and r must live in registers and
 // their loads be scheduled together, which a loop over an array of lanes
 // does not give. Two lanes take each byte by its own shift and write every
 // lane's bytes before any lane's update, the form all widths had before the
-// rotated copy, which measured slower there.
+// copies behind the barrier, which measured slower there.
 
 /** `bcryptBody4`'s interleave on two lanes. */
 const bcryptBody2 = (st: u32[]): void => {
@@ -1091,41 +1093,47 @@ const bcryptBody3 = (st: u32[]): void => {
     l1 ^= st[1042]
     l2 ^= st[2084]
     for (let n: i32 = 1; n < 17; n += 2) {
-      const l0e: u32 = ctSelect((l0 >>> 8) | (l0 << 24), 0xffffffff, 0)
-      const l0a: i32 = toI32(l0 >>> 24) & 0xff
-      const l0b: i32 = toI32(l0e >>> 8) & 0xff
-      const l0c: i32 = toI32(l0e) & 0xff
-      const l0d: i32 = toI32(l0) & 0xff
+      const l0e: u32 = ctSelect(l0, 0xffffffff, 0)
+      const l0d: i32 = toI32(l0e) & 0xff
+      const l0c: i32 = toI32(l0e >>> 8) & 0xff
+      const l0f: u32 = ctSelect(l0e >>> 16, 0xffffffff, 0)
+      const l0b: i32 = toI32(l0f) & 0xff
+      const l0a: i32 = toI32(l0f >>> 8) & 0xff
       r0 ^= st[n] ^ (((st[18 + l0a] + st[274 + l0b]) ^ st[530 + l0c]) + st[786 + l0d])
-      const l1e: u32 = ctSelect((l1 >>> 8) | (l1 << 24), 0xffffffff, 0)
-      const l1a: i32 = toI32(l1 >>> 24) & 0xff
-      const l1b: i32 = toI32(l1e >>> 8) & 0xff
-      const l1c: i32 = toI32(l1e) & 0xff
-      const l1d: i32 = toI32(l1) & 0xff
+      const l1e: u32 = ctSelect(l1, 0xffffffff, 0)
+      const l1d: i32 = toI32(l1e) & 0xff
+      const l1c: i32 = toI32(l1e >>> 8) & 0xff
+      const l1f: u32 = ctSelect(l1e >>> 16, 0xffffffff, 0)
+      const l1b: i32 = toI32(l1f) & 0xff
+      const l1a: i32 = toI32(l1f >>> 8) & 0xff
       r1 ^= st[1042 + n] ^ (((st[1060 + l1a] + st[1316 + l1b]) ^ st[1572 + l1c]) + st[1828 + l1d])
-      const l2e: u32 = ctSelect((l2 >>> 8) | (l2 << 24), 0xffffffff, 0)
-      const l2a: i32 = toI32(l2 >>> 24) & 0xff
-      const l2b: i32 = toI32(l2e >>> 8) & 0xff
-      const l2c: i32 = toI32(l2e) & 0xff
-      const l2d: i32 = toI32(l2) & 0xff
+      const l2e: u32 = ctSelect(l2, 0xffffffff, 0)
+      const l2d: i32 = toI32(l2e) & 0xff
+      const l2c: i32 = toI32(l2e >>> 8) & 0xff
+      const l2f: u32 = ctSelect(l2e >>> 16, 0xffffffff, 0)
+      const l2b: i32 = toI32(l2f) & 0xff
+      const l2a: i32 = toI32(l2f >>> 8) & 0xff
       r2 ^= st[2084 + n] ^ (((st[2102 + l2a] + st[2358 + l2b]) ^ st[2614 + l2c]) + st[2870 + l2d])
-      const r0e: u32 = ctSelect((r0 >>> 8) | (r0 << 24), 0xffffffff, 0)
-      const r0a: i32 = toI32(r0 >>> 24) & 0xff
-      const r0b: i32 = toI32(r0e >>> 8) & 0xff
-      const r0c: i32 = toI32(r0e) & 0xff
-      const r0d: i32 = toI32(r0) & 0xff
+      const r0e: u32 = ctSelect(r0, 0xffffffff, 0)
+      const r0d: i32 = toI32(r0e) & 0xff
+      const r0c: i32 = toI32(r0e >>> 8) & 0xff
+      const r0f: u32 = ctSelect(r0e >>> 16, 0xffffffff, 0)
+      const r0b: i32 = toI32(r0f) & 0xff
+      const r0a: i32 = toI32(r0f >>> 8) & 0xff
       l0 ^= st[n + 1] ^ (((st[18 + r0a] + st[274 + r0b]) ^ st[530 + r0c]) + st[786 + r0d])
-      const r1e: u32 = ctSelect((r1 >>> 8) | (r1 << 24), 0xffffffff, 0)
-      const r1a: i32 = toI32(r1 >>> 24) & 0xff
-      const r1b: i32 = toI32(r1e >>> 8) & 0xff
-      const r1c: i32 = toI32(r1e) & 0xff
-      const r1d: i32 = toI32(r1) & 0xff
+      const r1e: u32 = ctSelect(r1, 0xffffffff, 0)
+      const r1d: i32 = toI32(r1e) & 0xff
+      const r1c: i32 = toI32(r1e >>> 8) & 0xff
+      const r1f: u32 = ctSelect(r1e >>> 16, 0xffffffff, 0)
+      const r1b: i32 = toI32(r1f) & 0xff
+      const r1a: i32 = toI32(r1f >>> 8) & 0xff
       l1 ^= st[1042 + n + 1] ^ (((st[1060 + r1a] + st[1316 + r1b]) ^ st[1572 + r1c]) + st[1828 + r1d])
-      const r2e: u32 = ctSelect((r2 >>> 8) | (r2 << 24), 0xffffffff, 0)
-      const r2a: i32 = toI32(r2 >>> 24) & 0xff
-      const r2b: i32 = toI32(r2e >>> 8) & 0xff
-      const r2c: i32 = toI32(r2e) & 0xff
-      const r2d: i32 = toI32(r2) & 0xff
+      const r2e: u32 = ctSelect(r2, 0xffffffff, 0)
+      const r2d: i32 = toI32(r2e) & 0xff
+      const r2c: i32 = toI32(r2e >>> 8) & 0xff
+      const r2f: u32 = ctSelect(r2e >>> 16, 0xffffffff, 0)
+      const r2b: i32 = toI32(r2f) & 0xff
+      const r2a: i32 = toI32(r2f >>> 8) & 0xff
       l2 ^= st[2084 + n + 1] ^ (((st[2102 + r2a] + st[2358 + r2b]) ^ st[2614 + r2c]) + st[2870 + r2d])
     }
     const t0: u32 = r0
@@ -1153,17 +1161,20 @@ const bcryptBody3 = (st: u32[]): void => {
  * hot loop of the batch: 2^(cost+1) calls of 521 blocks per lane.
  *
  * Each lane's half-round is written whole, its bytes and then its update,
- * before the next lane's. The two middle index bytes come from one copy of the
- * word rotated right by 8 (`e`: byte 1 is its low byte, byte 2 its second),
- * behind the value barrier: `ctSelect(v, 0xffffffff, 0)` is `v`, opaque, so
- * LLVM cannot fold the two bytes back into two shifts of the word, and copies
- * it once instead of twice; on a BMI2 target the copy is one `rorx`. Three
- * and five lanes rotate the copy the same way; six shift it right by 8, which
- * has the same two low bytes and measured faster there. On a
- * Xeon Platinum 8260 that is 6% less time a hash at the best width, 9% under
- * `--cpu x86-64-v3` (docs/security/crypto-bcrypt.md, "Cascade Lake"). The
- * barrier is an identity on a register: it adds no branch and no load, and
- * the round reads the same four S-box words.
+ * before the next lane's. The bytes come in two pairs, each the low and
+ * second byte of a copy behind the value barrier: `ctSelect(v, 0xffffffff, 0)`
+ * is `v`, opaque. A copy of the word (`e`) gives bytes 0 and 1, and that copy
+ * moved down by 16 (`f`) bytes 2 and 3, so a second byte is one `movzx` from
+ * `ah`, `bh`, `ch` or `dh` and a lane takes its four bytes in six
+ * instructions; without the barriers LLVM folds the pairs back into shifts of
+ * the word. Only four registers have a second byte, and with all six lanes
+ * paired the loop spilled more than it saved (counted), so at six lanes the
+ * sixth lane takes bytes 1 and 2 from one copy moved down by 8 and bytes 0
+ * and 3 by shifts of the word, the way every lane had before. On a Xeon Platinum
+ * 8260 the pairs take about 3.5% less time a hash than that way at the best
+ * width, five lanes, and 5.6% less at six (docs/security/crypto-bcrypt.md,
+ * "Cascade Lake"). The barrier is an identity on a register: it adds no
+ * branch and no load, and the round reads the same four S-box words.
  */
 const bcryptBody4 = (st: u32[]): void => {
   if (st.length < 4168) {
@@ -1183,53 +1194,61 @@ const bcryptBody4 = (st: u32[]): void => {
     l2 ^= st[2084]
     l3 ^= st[3126]
     for (let n: i32 = 1; n < 17; n += 2) {
-      const l0e: u32 = ctSelect((l0 >>> 8) | (l0 << 24), 0xffffffff, 0)
-      const l0a: i32 = toI32(l0 >>> 24) & 0xff
-      const l0b: i32 = toI32(l0e >>> 8) & 0xff
-      const l0c: i32 = toI32(l0e) & 0xff
-      const l0d: i32 = toI32(l0) & 0xff
+      const l0e: u32 = ctSelect(l0, 0xffffffff, 0)
+      const l0d: i32 = toI32(l0e) & 0xff
+      const l0c: i32 = toI32(l0e >>> 8) & 0xff
+      const l0f: u32 = ctSelect(l0e >>> 16, 0xffffffff, 0)
+      const l0b: i32 = toI32(l0f) & 0xff
+      const l0a: i32 = toI32(l0f >>> 8) & 0xff
       r0 ^= st[n] ^ (((st[18 + l0a] + st[274 + l0b]) ^ st[530 + l0c]) + st[786 + l0d])
-      const l1e: u32 = ctSelect((l1 >>> 8) | (l1 << 24), 0xffffffff, 0)
-      const l1a: i32 = toI32(l1 >>> 24) & 0xff
-      const l1b: i32 = toI32(l1e >>> 8) & 0xff
-      const l1c: i32 = toI32(l1e) & 0xff
-      const l1d: i32 = toI32(l1) & 0xff
+      const l1e: u32 = ctSelect(l1, 0xffffffff, 0)
+      const l1d: i32 = toI32(l1e) & 0xff
+      const l1c: i32 = toI32(l1e >>> 8) & 0xff
+      const l1f: u32 = ctSelect(l1e >>> 16, 0xffffffff, 0)
+      const l1b: i32 = toI32(l1f) & 0xff
+      const l1a: i32 = toI32(l1f >>> 8) & 0xff
       r1 ^= st[1042 + n] ^ (((st[1060 + l1a] + st[1316 + l1b]) ^ st[1572 + l1c]) + st[1828 + l1d])
-      const l2e: u32 = ctSelect((l2 >>> 8) | (l2 << 24), 0xffffffff, 0)
-      const l2a: i32 = toI32(l2 >>> 24) & 0xff
-      const l2b: i32 = toI32(l2e >>> 8) & 0xff
-      const l2c: i32 = toI32(l2e) & 0xff
-      const l2d: i32 = toI32(l2) & 0xff
+      const l2e: u32 = ctSelect(l2, 0xffffffff, 0)
+      const l2d: i32 = toI32(l2e) & 0xff
+      const l2c: i32 = toI32(l2e >>> 8) & 0xff
+      const l2f: u32 = ctSelect(l2e >>> 16, 0xffffffff, 0)
+      const l2b: i32 = toI32(l2f) & 0xff
+      const l2a: i32 = toI32(l2f >>> 8) & 0xff
       r2 ^= st[2084 + n] ^ (((st[2102 + l2a] + st[2358 + l2b]) ^ st[2614 + l2c]) + st[2870 + l2d])
-      const l3e: u32 = ctSelect((l3 >>> 8) | (l3 << 24), 0xffffffff, 0)
-      const l3a: i32 = toI32(l3 >>> 24) & 0xff
-      const l3b: i32 = toI32(l3e >>> 8) & 0xff
-      const l3c: i32 = toI32(l3e) & 0xff
-      const l3d: i32 = toI32(l3) & 0xff
+      const l3e: u32 = ctSelect(l3, 0xffffffff, 0)
+      const l3d: i32 = toI32(l3e) & 0xff
+      const l3c: i32 = toI32(l3e >>> 8) & 0xff
+      const l3f: u32 = ctSelect(l3e >>> 16, 0xffffffff, 0)
+      const l3b: i32 = toI32(l3f) & 0xff
+      const l3a: i32 = toI32(l3f >>> 8) & 0xff
       r3 ^= st[3126 + n] ^ (((st[3144 + l3a] + st[3400 + l3b]) ^ st[3656 + l3c]) + st[3912 + l3d])
-      const r0e: u32 = ctSelect((r0 >>> 8) | (r0 << 24), 0xffffffff, 0)
-      const r0a: i32 = toI32(r0 >>> 24) & 0xff
-      const r0b: i32 = toI32(r0e >>> 8) & 0xff
-      const r0c: i32 = toI32(r0e) & 0xff
-      const r0d: i32 = toI32(r0) & 0xff
+      const r0e: u32 = ctSelect(r0, 0xffffffff, 0)
+      const r0d: i32 = toI32(r0e) & 0xff
+      const r0c: i32 = toI32(r0e >>> 8) & 0xff
+      const r0f: u32 = ctSelect(r0e >>> 16, 0xffffffff, 0)
+      const r0b: i32 = toI32(r0f) & 0xff
+      const r0a: i32 = toI32(r0f >>> 8) & 0xff
       l0 ^= st[n + 1] ^ (((st[18 + r0a] + st[274 + r0b]) ^ st[530 + r0c]) + st[786 + r0d])
-      const r1e: u32 = ctSelect((r1 >>> 8) | (r1 << 24), 0xffffffff, 0)
-      const r1a: i32 = toI32(r1 >>> 24) & 0xff
-      const r1b: i32 = toI32(r1e >>> 8) & 0xff
-      const r1c: i32 = toI32(r1e) & 0xff
-      const r1d: i32 = toI32(r1) & 0xff
+      const r1e: u32 = ctSelect(r1, 0xffffffff, 0)
+      const r1d: i32 = toI32(r1e) & 0xff
+      const r1c: i32 = toI32(r1e >>> 8) & 0xff
+      const r1f: u32 = ctSelect(r1e >>> 16, 0xffffffff, 0)
+      const r1b: i32 = toI32(r1f) & 0xff
+      const r1a: i32 = toI32(r1f >>> 8) & 0xff
       l1 ^= st[1042 + n + 1] ^ (((st[1060 + r1a] + st[1316 + r1b]) ^ st[1572 + r1c]) + st[1828 + r1d])
-      const r2e: u32 = ctSelect((r2 >>> 8) | (r2 << 24), 0xffffffff, 0)
-      const r2a: i32 = toI32(r2 >>> 24) & 0xff
-      const r2b: i32 = toI32(r2e >>> 8) & 0xff
-      const r2c: i32 = toI32(r2e) & 0xff
-      const r2d: i32 = toI32(r2) & 0xff
+      const r2e: u32 = ctSelect(r2, 0xffffffff, 0)
+      const r2d: i32 = toI32(r2e) & 0xff
+      const r2c: i32 = toI32(r2e >>> 8) & 0xff
+      const r2f: u32 = ctSelect(r2e >>> 16, 0xffffffff, 0)
+      const r2b: i32 = toI32(r2f) & 0xff
+      const r2a: i32 = toI32(r2f >>> 8) & 0xff
       l2 ^= st[2084 + n + 1] ^ (((st[2102 + r2a] + st[2358 + r2b]) ^ st[2614 + r2c]) + st[2870 + r2d])
-      const r3e: u32 = ctSelect((r3 >>> 8) | (r3 << 24), 0xffffffff, 0)
-      const r3a: i32 = toI32(r3 >>> 24) & 0xff
-      const r3b: i32 = toI32(r3e >>> 8) & 0xff
-      const r3c: i32 = toI32(r3e) & 0xff
-      const r3d: i32 = toI32(r3) & 0xff
+      const r3e: u32 = ctSelect(r3, 0xffffffff, 0)
+      const r3d: i32 = toI32(r3e) & 0xff
+      const r3c: i32 = toI32(r3e >>> 8) & 0xff
+      const r3f: u32 = ctSelect(r3e >>> 16, 0xffffffff, 0)
+      const r3b: i32 = toI32(r3f) & 0xff
+      const r3a: i32 = toI32(r3f >>> 8) & 0xff
       l3 ^= st[3126 + n + 1] ^ (((st[3144 + r3a] + st[3400 + r3b]) ^ st[3656 + r3c]) + st[3912 + r3d])
     }
     const t0: u32 = r0
@@ -1277,65 +1296,75 @@ const bcryptBody5 = (st: u32[]): void => {
     l3 ^= st[3126]
     l4 ^= st[4168]
     for (let n: i32 = 1; n < 17; n += 2) {
-      const l0e: u32 = ctSelect((l0 >>> 8) | (l0 << 24), 0xffffffff, 0)
-      const l0a: i32 = toI32(l0 >>> 24) & 0xff
-      const l0b: i32 = toI32(l0e >>> 8) & 0xff
-      const l0c: i32 = toI32(l0e) & 0xff
-      const l0d: i32 = toI32(l0) & 0xff
+      const l0e: u32 = ctSelect(l0, 0xffffffff, 0)
+      const l0d: i32 = toI32(l0e) & 0xff
+      const l0c: i32 = toI32(l0e >>> 8) & 0xff
+      const l0f: u32 = ctSelect(l0e >>> 16, 0xffffffff, 0)
+      const l0b: i32 = toI32(l0f) & 0xff
+      const l0a: i32 = toI32(l0f >>> 8) & 0xff
       r0 ^= st[n] ^ (((st[18 + l0a] + st[274 + l0b]) ^ st[530 + l0c]) + st[786 + l0d])
-      const l1e: u32 = ctSelect((l1 >>> 8) | (l1 << 24), 0xffffffff, 0)
-      const l1a: i32 = toI32(l1 >>> 24) & 0xff
-      const l1b: i32 = toI32(l1e >>> 8) & 0xff
-      const l1c: i32 = toI32(l1e) & 0xff
-      const l1d: i32 = toI32(l1) & 0xff
+      const l1e: u32 = ctSelect(l1, 0xffffffff, 0)
+      const l1d: i32 = toI32(l1e) & 0xff
+      const l1c: i32 = toI32(l1e >>> 8) & 0xff
+      const l1f: u32 = ctSelect(l1e >>> 16, 0xffffffff, 0)
+      const l1b: i32 = toI32(l1f) & 0xff
+      const l1a: i32 = toI32(l1f >>> 8) & 0xff
       r1 ^= st[1042 + n] ^ (((st[1060 + l1a] + st[1316 + l1b]) ^ st[1572 + l1c]) + st[1828 + l1d])
-      const l2e: u32 = ctSelect((l2 >>> 8) | (l2 << 24), 0xffffffff, 0)
-      const l2a: i32 = toI32(l2 >>> 24) & 0xff
-      const l2b: i32 = toI32(l2e >>> 8) & 0xff
-      const l2c: i32 = toI32(l2e) & 0xff
-      const l2d: i32 = toI32(l2) & 0xff
+      const l2e: u32 = ctSelect(l2, 0xffffffff, 0)
+      const l2d: i32 = toI32(l2e) & 0xff
+      const l2c: i32 = toI32(l2e >>> 8) & 0xff
+      const l2f: u32 = ctSelect(l2e >>> 16, 0xffffffff, 0)
+      const l2b: i32 = toI32(l2f) & 0xff
+      const l2a: i32 = toI32(l2f >>> 8) & 0xff
       r2 ^= st[2084 + n] ^ (((st[2102 + l2a] + st[2358 + l2b]) ^ st[2614 + l2c]) + st[2870 + l2d])
-      const l3e: u32 = ctSelect((l3 >>> 8) | (l3 << 24), 0xffffffff, 0)
-      const l3a: i32 = toI32(l3 >>> 24) & 0xff
-      const l3b: i32 = toI32(l3e >>> 8) & 0xff
-      const l3c: i32 = toI32(l3e) & 0xff
-      const l3d: i32 = toI32(l3) & 0xff
+      const l3e: u32 = ctSelect(l3, 0xffffffff, 0)
+      const l3d: i32 = toI32(l3e) & 0xff
+      const l3c: i32 = toI32(l3e >>> 8) & 0xff
+      const l3f: u32 = ctSelect(l3e >>> 16, 0xffffffff, 0)
+      const l3b: i32 = toI32(l3f) & 0xff
+      const l3a: i32 = toI32(l3f >>> 8) & 0xff
       r3 ^= st[3126 + n] ^ (((st[3144 + l3a] + st[3400 + l3b]) ^ st[3656 + l3c]) + st[3912 + l3d])
-      const l4e: u32 = ctSelect((l4 >>> 8) | (l4 << 24), 0xffffffff, 0)
-      const l4a: i32 = toI32(l4 >>> 24) & 0xff
-      const l4b: i32 = toI32(l4e >>> 8) & 0xff
-      const l4c: i32 = toI32(l4e) & 0xff
-      const l4d: i32 = toI32(l4) & 0xff
+      const l4e: u32 = ctSelect(l4, 0xffffffff, 0)
+      const l4d: i32 = toI32(l4e) & 0xff
+      const l4c: i32 = toI32(l4e >>> 8) & 0xff
+      const l4f: u32 = ctSelect(l4e >>> 16, 0xffffffff, 0)
+      const l4b: i32 = toI32(l4f) & 0xff
+      const l4a: i32 = toI32(l4f >>> 8) & 0xff
       r4 ^= st[4168 + n] ^ (((st[4186 + l4a] + st[4442 + l4b]) ^ st[4698 + l4c]) + st[4954 + l4d])
-      const r0e: u32 = ctSelect((r0 >>> 8) | (r0 << 24), 0xffffffff, 0)
-      const r0a: i32 = toI32(r0 >>> 24) & 0xff
-      const r0b: i32 = toI32(r0e >>> 8) & 0xff
-      const r0c: i32 = toI32(r0e) & 0xff
-      const r0d: i32 = toI32(r0) & 0xff
+      const r0e: u32 = ctSelect(r0, 0xffffffff, 0)
+      const r0d: i32 = toI32(r0e) & 0xff
+      const r0c: i32 = toI32(r0e >>> 8) & 0xff
+      const r0f: u32 = ctSelect(r0e >>> 16, 0xffffffff, 0)
+      const r0b: i32 = toI32(r0f) & 0xff
+      const r0a: i32 = toI32(r0f >>> 8) & 0xff
       l0 ^= st[n + 1] ^ (((st[18 + r0a] + st[274 + r0b]) ^ st[530 + r0c]) + st[786 + r0d])
-      const r1e: u32 = ctSelect((r1 >>> 8) | (r1 << 24), 0xffffffff, 0)
-      const r1a: i32 = toI32(r1 >>> 24) & 0xff
-      const r1b: i32 = toI32(r1e >>> 8) & 0xff
-      const r1c: i32 = toI32(r1e) & 0xff
-      const r1d: i32 = toI32(r1) & 0xff
+      const r1e: u32 = ctSelect(r1, 0xffffffff, 0)
+      const r1d: i32 = toI32(r1e) & 0xff
+      const r1c: i32 = toI32(r1e >>> 8) & 0xff
+      const r1f: u32 = ctSelect(r1e >>> 16, 0xffffffff, 0)
+      const r1b: i32 = toI32(r1f) & 0xff
+      const r1a: i32 = toI32(r1f >>> 8) & 0xff
       l1 ^= st[1042 + n + 1] ^ (((st[1060 + r1a] + st[1316 + r1b]) ^ st[1572 + r1c]) + st[1828 + r1d])
-      const r2e: u32 = ctSelect((r2 >>> 8) | (r2 << 24), 0xffffffff, 0)
-      const r2a: i32 = toI32(r2 >>> 24) & 0xff
-      const r2b: i32 = toI32(r2e >>> 8) & 0xff
-      const r2c: i32 = toI32(r2e) & 0xff
-      const r2d: i32 = toI32(r2) & 0xff
+      const r2e: u32 = ctSelect(r2, 0xffffffff, 0)
+      const r2d: i32 = toI32(r2e) & 0xff
+      const r2c: i32 = toI32(r2e >>> 8) & 0xff
+      const r2f: u32 = ctSelect(r2e >>> 16, 0xffffffff, 0)
+      const r2b: i32 = toI32(r2f) & 0xff
+      const r2a: i32 = toI32(r2f >>> 8) & 0xff
       l2 ^= st[2084 + n + 1] ^ (((st[2102 + r2a] + st[2358 + r2b]) ^ st[2614 + r2c]) + st[2870 + r2d])
-      const r3e: u32 = ctSelect((r3 >>> 8) | (r3 << 24), 0xffffffff, 0)
-      const r3a: i32 = toI32(r3 >>> 24) & 0xff
-      const r3b: i32 = toI32(r3e >>> 8) & 0xff
-      const r3c: i32 = toI32(r3e) & 0xff
-      const r3d: i32 = toI32(r3) & 0xff
+      const r3e: u32 = ctSelect(r3, 0xffffffff, 0)
+      const r3d: i32 = toI32(r3e) & 0xff
+      const r3c: i32 = toI32(r3e >>> 8) & 0xff
+      const r3f: u32 = ctSelect(r3e >>> 16, 0xffffffff, 0)
+      const r3b: i32 = toI32(r3f) & 0xff
+      const r3a: i32 = toI32(r3f >>> 8) & 0xff
       l3 ^= st[3126 + n + 1] ^ (((st[3144 + r3a] + st[3400 + r3b]) ^ st[3656 + r3c]) + st[3912 + r3d])
-      const r4e: u32 = ctSelect((r4 >>> 8) | (r4 << 24), 0xffffffff, 0)
-      const r4a: i32 = toI32(r4 >>> 24) & 0xff
-      const r4b: i32 = toI32(r4e >>> 8) & 0xff
-      const r4c: i32 = toI32(r4e) & 0xff
-      const r4d: i32 = toI32(r4) & 0xff
+      const r4e: u32 = ctSelect(r4, 0xffffffff, 0)
+      const r4d: i32 = toI32(r4e) & 0xff
+      const r4c: i32 = toI32(r4e >>> 8) & 0xff
+      const r4f: u32 = ctSelect(r4e >>> 16, 0xffffffff, 0)
+      const r4b: i32 = toI32(r4f) & 0xff
+      const r4a: i32 = toI32(r4f >>> 8) & 0xff
       l4 ^= st[4168 + n + 1] ^ (((st[4186 + r4a] + st[4442 + r4b]) ^ st[4698 + r4c]) + st[4954 + r4d])
     }
     const t0: u32 = r0
@@ -1391,35 +1420,40 @@ const bcryptBody6 = (st: u32[]): void => {
     l4 ^= st[4168]
     l5 ^= st[5210]
     for (let n: i32 = 1; n < 17; n += 2) {
-      const l0e: u32 = ctSelect(l0 >>> 8, 0xffffffff, 0)
-      const l0a: i32 = toI32(l0 >>> 24) & 0xff
-      const l0b: i32 = toI32(l0e >>> 8) & 0xff
-      const l0c: i32 = toI32(l0e) & 0xff
-      const l0d: i32 = toI32(l0) & 0xff
+      const l0e: u32 = ctSelect(l0, 0xffffffff, 0)
+      const l0d: i32 = toI32(l0e) & 0xff
+      const l0c: i32 = toI32(l0e >>> 8) & 0xff
+      const l0f: u32 = ctSelect(l0e >>> 16, 0xffffffff, 0)
+      const l0b: i32 = toI32(l0f) & 0xff
+      const l0a: i32 = toI32(l0f >>> 8) & 0xff
       r0 ^= st[n] ^ (((st[18 + l0a] + st[274 + l0b]) ^ st[530 + l0c]) + st[786 + l0d])
-      const l1e: u32 = ctSelect(l1 >>> 8, 0xffffffff, 0)
-      const l1a: i32 = toI32(l1 >>> 24) & 0xff
-      const l1b: i32 = toI32(l1e >>> 8) & 0xff
-      const l1c: i32 = toI32(l1e) & 0xff
-      const l1d: i32 = toI32(l1) & 0xff
+      const l1e: u32 = ctSelect(l1, 0xffffffff, 0)
+      const l1d: i32 = toI32(l1e) & 0xff
+      const l1c: i32 = toI32(l1e >>> 8) & 0xff
+      const l1f: u32 = ctSelect(l1e >>> 16, 0xffffffff, 0)
+      const l1b: i32 = toI32(l1f) & 0xff
+      const l1a: i32 = toI32(l1f >>> 8) & 0xff
       r1 ^= st[1042 + n] ^ (((st[1060 + l1a] + st[1316 + l1b]) ^ st[1572 + l1c]) + st[1828 + l1d])
-      const l2e: u32 = ctSelect(l2 >>> 8, 0xffffffff, 0)
-      const l2a: i32 = toI32(l2 >>> 24) & 0xff
-      const l2b: i32 = toI32(l2e >>> 8) & 0xff
-      const l2c: i32 = toI32(l2e) & 0xff
-      const l2d: i32 = toI32(l2) & 0xff
+      const l2e: u32 = ctSelect(l2, 0xffffffff, 0)
+      const l2d: i32 = toI32(l2e) & 0xff
+      const l2c: i32 = toI32(l2e >>> 8) & 0xff
+      const l2f: u32 = ctSelect(l2e >>> 16, 0xffffffff, 0)
+      const l2b: i32 = toI32(l2f) & 0xff
+      const l2a: i32 = toI32(l2f >>> 8) & 0xff
       r2 ^= st[2084 + n] ^ (((st[2102 + l2a] + st[2358 + l2b]) ^ st[2614 + l2c]) + st[2870 + l2d])
-      const l3e: u32 = ctSelect(l3 >>> 8, 0xffffffff, 0)
-      const l3a: i32 = toI32(l3 >>> 24) & 0xff
-      const l3b: i32 = toI32(l3e >>> 8) & 0xff
-      const l3c: i32 = toI32(l3e) & 0xff
-      const l3d: i32 = toI32(l3) & 0xff
+      const l3e: u32 = ctSelect(l3, 0xffffffff, 0)
+      const l3d: i32 = toI32(l3e) & 0xff
+      const l3c: i32 = toI32(l3e >>> 8) & 0xff
+      const l3f: u32 = ctSelect(l3e >>> 16, 0xffffffff, 0)
+      const l3b: i32 = toI32(l3f) & 0xff
+      const l3a: i32 = toI32(l3f >>> 8) & 0xff
       r3 ^= st[3126 + n] ^ (((st[3144 + l3a] + st[3400 + l3b]) ^ st[3656 + l3c]) + st[3912 + l3d])
-      const l4e: u32 = ctSelect(l4 >>> 8, 0xffffffff, 0)
-      const l4a: i32 = toI32(l4 >>> 24) & 0xff
-      const l4b: i32 = toI32(l4e >>> 8) & 0xff
-      const l4c: i32 = toI32(l4e) & 0xff
-      const l4d: i32 = toI32(l4) & 0xff
+      const l4e: u32 = ctSelect(l4, 0xffffffff, 0)
+      const l4d: i32 = toI32(l4e) & 0xff
+      const l4c: i32 = toI32(l4e >>> 8) & 0xff
+      const l4f: u32 = ctSelect(l4e >>> 16, 0xffffffff, 0)
+      const l4b: i32 = toI32(l4f) & 0xff
+      const l4a: i32 = toI32(l4f >>> 8) & 0xff
       r4 ^= st[4168 + n] ^ (((st[4186 + l4a] + st[4442 + l4b]) ^ st[4698 + l4c]) + st[4954 + l4d])
       const l5e: u32 = ctSelect(l5 >>> 8, 0xffffffff, 0)
       const l5a: i32 = toI32(l5 >>> 24) & 0xff
@@ -1427,35 +1461,40 @@ const bcryptBody6 = (st: u32[]): void => {
       const l5c: i32 = toI32(l5e) & 0xff
       const l5d: i32 = toI32(l5) & 0xff
       r5 ^= st[5210 + n] ^ (((st[5228 + l5a] + st[5484 + l5b]) ^ st[5740 + l5c]) + st[5996 + l5d])
-      const r0e: u32 = ctSelect(r0 >>> 8, 0xffffffff, 0)
-      const r0a: i32 = toI32(r0 >>> 24) & 0xff
-      const r0b: i32 = toI32(r0e >>> 8) & 0xff
-      const r0c: i32 = toI32(r0e) & 0xff
-      const r0d: i32 = toI32(r0) & 0xff
+      const r0e: u32 = ctSelect(r0, 0xffffffff, 0)
+      const r0d: i32 = toI32(r0e) & 0xff
+      const r0c: i32 = toI32(r0e >>> 8) & 0xff
+      const r0f: u32 = ctSelect(r0e >>> 16, 0xffffffff, 0)
+      const r0b: i32 = toI32(r0f) & 0xff
+      const r0a: i32 = toI32(r0f >>> 8) & 0xff
       l0 ^= st[n + 1] ^ (((st[18 + r0a] + st[274 + r0b]) ^ st[530 + r0c]) + st[786 + r0d])
-      const r1e: u32 = ctSelect(r1 >>> 8, 0xffffffff, 0)
-      const r1a: i32 = toI32(r1 >>> 24) & 0xff
-      const r1b: i32 = toI32(r1e >>> 8) & 0xff
-      const r1c: i32 = toI32(r1e) & 0xff
-      const r1d: i32 = toI32(r1) & 0xff
+      const r1e: u32 = ctSelect(r1, 0xffffffff, 0)
+      const r1d: i32 = toI32(r1e) & 0xff
+      const r1c: i32 = toI32(r1e >>> 8) & 0xff
+      const r1f: u32 = ctSelect(r1e >>> 16, 0xffffffff, 0)
+      const r1b: i32 = toI32(r1f) & 0xff
+      const r1a: i32 = toI32(r1f >>> 8) & 0xff
       l1 ^= st[1042 + n + 1] ^ (((st[1060 + r1a] + st[1316 + r1b]) ^ st[1572 + r1c]) + st[1828 + r1d])
-      const r2e: u32 = ctSelect(r2 >>> 8, 0xffffffff, 0)
-      const r2a: i32 = toI32(r2 >>> 24) & 0xff
-      const r2b: i32 = toI32(r2e >>> 8) & 0xff
-      const r2c: i32 = toI32(r2e) & 0xff
-      const r2d: i32 = toI32(r2) & 0xff
+      const r2e: u32 = ctSelect(r2, 0xffffffff, 0)
+      const r2d: i32 = toI32(r2e) & 0xff
+      const r2c: i32 = toI32(r2e >>> 8) & 0xff
+      const r2f: u32 = ctSelect(r2e >>> 16, 0xffffffff, 0)
+      const r2b: i32 = toI32(r2f) & 0xff
+      const r2a: i32 = toI32(r2f >>> 8) & 0xff
       l2 ^= st[2084 + n + 1] ^ (((st[2102 + r2a] + st[2358 + r2b]) ^ st[2614 + r2c]) + st[2870 + r2d])
-      const r3e: u32 = ctSelect(r3 >>> 8, 0xffffffff, 0)
-      const r3a: i32 = toI32(r3 >>> 24) & 0xff
-      const r3b: i32 = toI32(r3e >>> 8) & 0xff
-      const r3c: i32 = toI32(r3e) & 0xff
-      const r3d: i32 = toI32(r3) & 0xff
+      const r3e: u32 = ctSelect(r3, 0xffffffff, 0)
+      const r3d: i32 = toI32(r3e) & 0xff
+      const r3c: i32 = toI32(r3e >>> 8) & 0xff
+      const r3f: u32 = ctSelect(r3e >>> 16, 0xffffffff, 0)
+      const r3b: i32 = toI32(r3f) & 0xff
+      const r3a: i32 = toI32(r3f >>> 8) & 0xff
       l3 ^= st[3126 + n + 1] ^ (((st[3144 + r3a] + st[3400 + r3b]) ^ st[3656 + r3c]) + st[3912 + r3d])
-      const r4e: u32 = ctSelect(r4 >>> 8, 0xffffffff, 0)
-      const r4a: i32 = toI32(r4 >>> 24) & 0xff
-      const r4b: i32 = toI32(r4e >>> 8) & 0xff
-      const r4c: i32 = toI32(r4e) & 0xff
-      const r4d: i32 = toI32(r4) & 0xff
+      const r4e: u32 = ctSelect(r4, 0xffffffff, 0)
+      const r4d: i32 = toI32(r4e) & 0xff
+      const r4c: i32 = toI32(r4e >>> 8) & 0xff
+      const r4f: u32 = ctSelect(r4e >>> 16, 0xffffffff, 0)
+      const r4b: i32 = toI32(r4f) & 0xff
+      const r4a: i32 = toI32(r4f >>> 8) & 0xff
       l4 ^= st[4168 + n + 1] ^ (((st[4186 + r4a] + st[4442 + r4b]) ^ st[4698 + r4c]) + st[4954 + r4d])
       const r5e: u32 = ctSelect(r5 >>> 8, 0xffffffff, 0)
       const r5a: i32 = toI32(r5 >>> 24) & 0xff

package/std/net/http1-codec.ts

@@ -81,7 +81,25 @@
  * Written from RFC 9112 and RFC 9110, not ported from another implementation.
  */
 import { copyBytes } from "nish/bytes"
-import { extract, loadU8x16, u8x16 } from "nish:simd"
+import {
+  and,
+  any,
+  bitmask,
+  eq,
+  extract,
+  gt,
+  loadU8x16,
+  lt,
+  mask8x16,
+  ne,
+  or,
+  replace,
+  select,
+  splatU8x16,
+  store,
+  subWrapping,
+  u8x16,
+} from "nish:simd"
 
 /** `next()`: the input so far holds no further event; feed more. */
 export const HTTP1_NEED_MORE: i32 = 0
@@ -669,8 +687,9 @@ const http1TakeLine = (p: Http1Parser, limit: i32, overStatus: i32): i32 => {
  * third (0x57ffffff). No byte below 33 or above 126 is a tchar.
  * `http1IsTokenByte` reads them as two 64-bit masks, one for the bytes 0 to
  * 63 and one for 64 to 127, so the test is a select and a shift with no
- * branch on the byte: a name or method scan is the parser's hottest loop
- * after the line scan (`bench/http1-parse`).
+ * branch on the byte. A field name goes sixteen bytes at a time through
+ * `http1NonTokenLanes`, the same set; this test is for the method, a trailer's
+ * name, and a name's last bytes when fewer than sixteen are left in the head.
  */
 const HTTP1_TCHAR_32: i32 = 67071226
 const HTTP1_TCHAR_64: i32 = -939524098
@@ -684,6 +703,66 @@ export const http1IsTokenByte = (c: i32): boolean => {
   return c >= 0 && c < 128 && ((word >> toU64(c & 63)) & toU64(1)) !== toU64(0)
 }
 
+/**
+ * Which lanes of `v` are not tchars, as `http1IsTokenByte` answers for each,
+ * bit `k` for lane `k`: a byte outside 33 to 126, or one of the seventeen
+ * delimiters among them, `"` `(` `)` `,` `/` `:` to `@` (seven), `[` `\` `]`
+ * `{` and `}`. A name is mostly one vector, so these compares run once for
+ * the sixteen bytes where the table test ran once for each.
+ */
+const http1NonTokenLanes = (v: u8x16): i32 => {
+  const outside: mask8x16 = gt(subWrapping(v, splatU8x16(33)), splatU8x16(93))
+  const quote: mask8x16 = or(eq(v, splatU8x16(34)), lt(subWrapping(v, splatU8x16(40)), splatU8x16(2)))
+  const comma: mask8x16 = or(eq(v, splatU8x16(44)), eq(v, splatU8x16(47)))
+  const colon: mask8x16 = lt(subWrapping(v, splatU8x16(58)), splatU8x16(7))
+  const bracket: mask8x16 = lt(subWrapping(v, splatU8x16(91)), splatU8x16(3))
+  const brace: mask8x16 = or(eq(v, splatU8x16(123)), eq(v, splatU8x16(125)))
+  return bitmask(or(or(or(outside, quote), or(comma, colon)), or(bracket, brace)))
+}
+
+/**
+ * Lowercases a field name in `head` from `k`, sixteen bytes at a time, and
+ * answers where it ends: the first byte before `stop` that is not a tchar, or
+ * `stop`. Each vector's name lanes are lowered, and every other lane is
+ * stored back as it was, so the value after the name and the bytes past the
+ * line keep their case. A tail of under sixteen bytes before `head`'s end
+ * goes a byte at a time. The answer and the bytes written are the byte loop's.
+ */
+const http1LowerName = (head: u8[], k0: i32, stop: i32): i32 => {
+  // Lane `j` holds `j`: the name's lanes are those below its length.
+  const lanes: u8x16 = u8x16(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)
+  let k: i32 = k0
+  while (k >= 0 && k < stop && k <= toI32(head.length) - 16) {
+    const v: u8x16 = loadU8x16(head, k)
+    const bad: i32 = http1NonTokenLanes(v)
+    let run: i32 = 16
+    if (bad !== 0) {
+      run = toI32(31) - toI32(Math.clz32(toU32(bad & -bad)))
+    }
+    if (run > stop - k) {
+      run = stop - k
+    }
+    const upper: mask8x16 = and(
+      lt(subWrapping(v, splatU8x16(65)), splatU8x16(26)),
+      lt(lanes, splatU8x16(toU8(run)))
+    )
+    store(select(upper, or(v, splatU8x16(32)), v), head, k)
+    k += run
+    if (run < 16) {
+      return k
+    }
+  }
+  while (k >= 0 && k < stop && k < toI32(head.length)) {
+    const c: i32 = toI32(head[k])
+    if (!http1IsTokenByte(c)) {
+      break
+    }
+    head[k] = toU8(c >= 65 && c <= 90 ? c + 32 : c)
+    k += 1
+  }
+  return k
+}
+
 /** 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)
 
@@ -1012,18 +1091,7 @@ const http1FieldLine = (p: Http1Parser, keep: boolean): i32 => {
   let i: i32 = a
   if (keep) {
     at = http1HeadAppend(p, a, b)
-    const head: u8[] = p.head
-    let k: i32 = at
-    const stop: i32 = at + (b - a)
-    while (k >= 0 && k < stop && k < toI32(head.length)) {
-      const c: i32 = toI32(head[k])
-      if (!http1IsTokenByte(c)) {
-        break
-      }
-      head[k] = toU8(c >= 65 && c <= 90 ? c + 32 : c)
-      k += 1
-    }
-    i = a + (k - at)
+    i = a + (http1LowerName(p.head, at, at + (b - a)) - at)
   } else {
     while (i >= 0 && i < b && i < toI32(buf.length) && http1IsTokenByte(toI32(buf[i]))) {
       i += 1
@@ -1046,7 +1114,12 @@ const http1FieldLine = (p: Http1Parser, keep: boolean): i32 => {
   if (keep) {
     let valueStart: i32 = nameEnd + 1
     let valueEnd: i32 = b
-    while (valueStart >= 0 && valueStart < valueEnd && valueStart < n && http1IsOws(toI32(buf[valueStart]))) {
+    while (
+      valueStart >= 0 &&
+      valueStart < valueEnd &&
+      valueStart < toI32(buf.length) &&
+      http1IsOws(toI32(buf[valueStart]))
+    ) {
       valueStart += 1
     }
     while (valueEnd > valueStart && valueEnd - 1 >= 0 && http1IsOws(toI32(buf[valueEnd - 1]))) {
@@ -1591,14 +1664,39 @@ const http1BytesAreToken = (bytes: u8[]): boolean => {
   return toI32(bytes.length) > 0
 }
 
-/** Whether every byte of `bytes` may stand in a field value. */
+/**
+ * Whether no lane of `v` is a byte a field value may not hold: below 32 and
+ * not HTAB, or DEL. `http1IsValueByte` on sixteen bytes at once, exactly, so
+ * a vector may overlap one already checked.
+ */
+const http1LanesAreFieldText = (v: u8x16): boolean => {
+  const control: mask8x16 = and(lt(v, splatU8x16(32)), ne(v, splatU8x16(9)))
+  return !any(or(control, eq(v, splatU8x16(127))))
+}
+
+/**
+ * Whether every byte of `bytes` may stand in a field value: sixteen at a
+ * time, the last vector ending at the last byte and overlapping the one
+ * before it, and one at a time below sixteen.
+ */
 const http1BytesAreFieldText = (bytes: u8[]): boolean => {
-  for (const b of bytes) {
-    if (!http1IsValueByte(toI32(b))) {
+  const n: i32 = toI32(bytes.length)
+  if (n < 16) {
+    for (let k: i32 = 0; k < n; k += 1) {
+      if (!http1IsValueByte(toI32(bytes[k]))) {
+        return false
+      }
+    }
+    return true
+  }
+  let k: i32 = 0
+  while (k >= 0 && k <= n - 16) {
+    if (!http1LanesAreFieldText(loadU8x16(bytes, k))) {
       return false
     }
+    k += 16
   }
-  return true
+  return k === n || http1LanesAreFieldText(loadU8x16(bytes, n - 16))
 }
 
 /** Whether the octets of `bytes` spell `word`, which is lowercase, in any ASCII case: a field name compared as RFC 9110 §5.1 says. */
@@ -1628,6 +1726,14 @@ const http1DecimalDigits = (n: i32): i32 => {
 /** Writes `text` at `out[at ..)`, which the caller has made sure holds it, and answers where it ends. */
 export const http1PutText = (out: u8[], at: i32, text: string): i32 => {
   const n: i32 = toI32(text.length)
+  if (at >= 0 && at <= toI32(out.length) - n) {
+    // It fits, the case every caller makes sure of: one test, then a loop
+    // with no bounds check in it.
+    for (let k: i32 = 0; k < n; k += 1) {
+      out[at + k] = toU8(text.charCodeAt(k))
+    }
+    return at + n
+  }
   for (let k: i32 = 0; k < n && at + k < toI32(out.length); k += 1) {
     if (at + k >= 0) {
       out[at + k] = toU8(text.charCodeAt(k))
@@ -1669,6 +1775,50 @@ const http1PutBytes = (out: u8[], at: i32, bytes: u8[]): i32 => {
   return at + n
 }
 
+/**
+ * Writes `text`, at most sixteen ASCII bytes, at `out[at ..)`, likewise, as
+ * one sixteen-byte store of `v`, which holds `text` in its first lanes: when
+ * `at + 16` does not pass `limit`, the end of the head being written, whose
+ * every byte from `at` on is written after this one, so the lanes past
+ * `text` are overwritten before the head is done. Byte by byte otherwise.
+ */
+const http1PutFixed = (out: u8[], at: i32, limit: i32, v: u8x16, text: string): i32 => {
+  if (at >= 0 && at <= limit - 16 && limit <= toI32(out.length)) {
+    store(v, out, at)
+    return at + toI32(text.length)
+  }
+  return http1PutText(out, at, text)
+}
+
+/**
+ * Writes `HTTP/1.1 `, the three digits of `status`, which is 100 to 599, and
+ * a space at `out[at ..)`, likewise: one store, the digits replacing three
+ * lanes of the constant.
+ */
+const http1PutStatusLine = (out: u8[], at: i32, limit: i32, status: i32): i32 => {
+  const hundreds: i32 = status / 100
+  const tens: i32 = (status / 10) % 10
+  const ones: i32 = status % 10
+  if (at >= 0 && at <= limit - 16 && limit <= toI32(out.length)) {
+    // "HTTP/1.1 000 ", and three lanes the head's next bytes overwrite.
+    const line: u8x16 = u8x16(72, 84, 84, 80, 47, 49, 46, 49, 32, 48, 48, 48, 32, 32, 32, 32)
+    store(
+      replace(replace(replace(line, 9, toU8(48 + hundreds)), 10, toU8(48 + tens)), 11, toU8(48 + ones)),
+      out,
+      at
+    )
+    return at + 13
+  }
+  const end: i32 = http1PutText(out, at, "HTTP/1.1 ")
+  if (end >= 0 && end < toI32(out.length) - 3) {
+    out[end] = toU8(48 + hundreds)
+    out[end + 1] = toU8(48 + tens)
+    out[end + 2] = toU8(48 + ones)
+    out[end + 3] = 32
+  }
+  return end + 4
+}
+
 /** Writes the decimal digits of `n`, which is not negative, at `out[at ..)`, likewise. */
 const http1PutDecimal = (out: u8[], at: i32, n: i32): i32 => {
   const digits: i32 = http1DecimalDigits(n)
@@ -1725,7 +1875,7 @@ export const http1WriteResponseHead = (
   // is written, in 64 bits so that no caller's lengths can wrap the sum.
   let need: i64 = toI64(17) + toI64(reason.length)
   let sendDate: boolean = status >= 200 && toI32(date.length) > 0
-  for (let i: i32 = 0; i < count && i < toI32(values.length); i += 1) {
+  for (let i: i32 = 0; i < toI32(names.length) && i < toI32(values.length); i += 1) {
     const name: u8[] = names[i]
     const value: u8[] = values[i]
     if (!http1BytesAreToken(name) || !http1BytesAreFieldText(value)) {
@@ -1757,41 +1907,49 @@ export const http1WriteResponseHead = (
   if (at < 0 || at > toI32(out.length) || need > toI64(toI32(out.length) - at)) {
     return HTTP1_NO_ROOM
   }
-  let end: i32 = http1PutText(out, at, "HTTP/1.1 ")
   // 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
+  const limit: i32 = at + toI32(need)
+  let end: i32 = http1PutStatusLine(out, at, limit, status)
   end = http1PutText(out, end, reason)
   end = http1PutCrlf(out, end)
-  for (let i: i32 = 0; i < count && i < toI32(values.length); i += 1) {
+  for (let i: i32 = 0; i < toI32(names.length) && i < toI32(values.length); i += 1) {
     end = http1PutBytes(out, end, names[i])
     end = http1PutColonSpace(out, end)
     end = http1PutBytes(out, end, values[i])
     end = http1PutCrlf(out, end)
   }
   if (sendDate) {
-    end = http1PutText(out, end, "Date: ")
+    end = http1PutFixed(
+      out,
+      end,
+      limit,
+      u8x16(68, 97, 116, 101, 58, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32),
+      "Date: "
+    )
     end = http1PutBytes(out, end, date)
     end = http1PutCrlf(out, end)
   }
   if (bodyLength >= 0) {
-    end = http1PutText(out, end, "Content-Length: ")
+    end = http1PutFixed(
+      out,
+      end,
+      limit,
+      u8x16(67, 111, 110, 116, 101, 110, 116, 45, 76, 101, 110, 103, 116, 104, 58, 32),
+      "Content-Length: "
+    )
     end = http1PutDecimal(out, end, bodyLength)
     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 = http1PutFixed(
+      out,
+      end,
+      limit,
+      u8x16(67, 111, 110, 110, 101, 99, 116, 105, 111, 110, 58, 32, 32, 32, 32, 32),
+      "Connection: "
+    )
     end = http1PutText(out, end, connection)
     end = http1PutCrlf(out, end)
   }

package/std/net/postgres.ts

@@ -445,13 +445,56 @@ const pgBytesOf = (text: string): u8[] => {
 
 /** How many bytes `value` takes in decimal, its sign included. */
 const pgDecimalLength = (value: i64): i32 => {
+  // Counted on the negative side, where the most negative i64 fits, two digits a step.
   let n: i32 = value < 0 ? 2 : 1
   let v: i64 = value < 0 ? value : -value
-  while (v <= -10) {
-    v = v / 10
-    n += 1
+  while (v <= -100) {
+    v = v / 100
+    n += 2
   }
-  return n
+  return v <= -10 ? n + 1 : n
+}
+
+/**
+ * Writes `value` in decimal into `out[at, at + n)`, where `n` is
+ * `pgDecimalLength(value)`, and answers `at + n`. The digits go once, into
+ * their places, from the last, two a step from the magnitude as a `u64`
+ * (which holds the most negative i64's, and whose `/` and `%` are never
+ * checked). Panics unless the window is inside `out`; each step's guard
+ * restates it in the shape that proves its two stores.
+ */
+const pgPutDecimal = (out: u8[], at: i32, value: i64, n: i32): i32 => {
+  if (!(at >= 0 && at < 2147483620 && n >= 1 && n <= 20 && at + n <= toI32(out.length))) {
+    panic("nish/net/postgres: a decimal outside its room")
+  }
+  const first: i32 = value < 0 ? at + 1 : at
+  let m: u64 = value < 0 ? toU64(0) - toU64(value) : toU64(value)
+  // Where the last two digits start.
+  let j: i32 = at + n - 2
+  while (m >= 100 && j >= first && j >= 0 && j < 2147483640 && j + 2 <= toI32(out.length)) {
+    const pair: u32 = toU32(m % 100)
+    const tens: u32 = pair / 10
+    out[j] = toU8(48 + tens)
+    out[j + 1] = toU8(48 + pair - tens * 10)
+    m = m / 100
+    j -= 2
+  }
+  // One or two digits are left, ending at `j + 2`.
+  const pair: u32 = toU32(m)
+  if (pair >= 10 && j >= first && j >= 0 && j < 2147483640 && j + 2 <= toI32(out.length)) {
+    const tens: u32 = pair / 10
+    out[j] = toU8(48 + tens)
+    out[j + 1] = toU8(48 + pair - tens * 10)
+  } else {
+    const last: i32 = j + 1
+    if (last >= first && last >= 0 && last < toI32(out.length)) {
+      out[last] = toU8(48 + pair)
+    }
+  }
+  if (value < 0 && at < toI32(out.length)) {
+    out[at] = toU8(45)
+  }
+  return at + n
 }
 
 /** Whether `value` is an `int4`, -2^31..2^31-1. */
@@ -2274,32 +2317,9 @@ export class PgConnection {
 
   /** `value` in decimal, `pgDecimalLength(value)` bytes. */
   private putDecimal(value: i64): void {
-    this.reserve(this.outEnd + 20)
-    // The digits are written from the least significant, then reversed; the
-    // value is made negative first so that the most negative i64 has its digits.
-    let v: i64 = value < 0 ? value : -value
-    if (value < 0) {
-      this.out[this.outEnd] = toU8(45)
-      this.outEnd += 1
-    }
-    const first: i32 = this.outEnd
-    while (true) {
-      this.out[this.outEnd] = toU8(48 - toI32(v % 10))
-      this.outEnd += 1
-      v = v / 10
-      if (v === 0) {
-        break
-      }
-    }
-    let lo: i32 = first
-    let hi: i32 = this.outEnd - 1
-    while (lo < hi) {
-      const t: u8 = this.out[lo]
-      this.out[lo] = this.out[hi]
-      this.out[hi] = t
-      lo++
-      hi--
-    }
+    const n: i32 = pgDecimalLength(value)
+    this.reserve(this.outEnd + n)
+    this.outEnd = pgPutDecimal(this.out, this.outEnd, value, n)
   }
 
   /**