@amritk/nish-x86_64-linux 0.31.0 → 0.32.0

package/docs/AI.md

@@ -49,7 +49,7 @@ stdout, nothing on stderr, every field 1-based with `endLine`/`endColumn`
 exclusive:
 
 ```json
-{"file":"p.ts","line":3,"column":17,"endLine":3,"endColumn":20,"severity":"error","code":"NL2249","message":"Unknown method `map` on i32[] (supported: push, pop, indexOf, join, set, fill)"}
+{"file":"p.ts","line":3,"column":17,"endLine":3,"endColumn":20,"severity":"error","code":"NL2249","message":"Unknown method `map` on i32[] (supported: push, pop, indexOf, join, set, fill, sort)"}
 ```
 
 - **Key on `code`, never on `message`.** A code is a promise: `NL2249` means
@@ -159,7 +159,7 @@ rejects. This table is the highest-value part of the page.
 | `x == y` | `Loose equality is forbidden` | `x === y` |
 | `throw new Error(m)` | `` `throw` is forbidden `` | `return Err(m)`, or `panic(m)` to end the process |
 | `try { … } catch { … }` | `` `try`/`catch`/`finally` is forbidden `` | `Result<T, E>` and `isErr()` |
-| `xs.map(f)`, `.filter`, `.reduce`, `.forEach`, `.slice`, `.sort`, `.shift` | `` Unknown method `map` on i32[] (supported: push, pop, indexOf, join, set, fill) `` | a `for` loop, or a top-level `map(xs, f)` with a [function parameter](#function-parameters) |
+| `xs.map(f)`, `.filter`, `.reduce`, `.forEach`, `.slice`, `.shift` | `` Unknown method `map` on i32[] (supported: push, pop, indexOf, join, set, fill, sort) `` | a `for` loop, or a top-level `map(xs, f)` with a [function parameter](#function-parameters) |
 | `s.toUpperCase()`, `s.split()`, `s.trim()`, `s.replace()` | `` Unknown method … on string `` | index bytes with `charCodeAt` / `substring` |
 | `a?.b`, `a ?? b` | `?.` only in a chain that ends in `??`; `??` only on a `T \| null`, a chain or `m.get(k)` | `a?.b ?? d`, `a ?? d`, or `if (a !== null)` first |
 | `x as T`, `<T>x`, `x satisfies T` | `Unsupported expression in Phase 1: AsExpression` (to `any` or `unknown`: `` Type assertion to `any` is forbidden ``); `x!` is a syntax error | there are no casts; `implements` is the only widening |
@@ -852,7 +852,8 @@ export const main = (): i32 => {
   (`` The arrow reads `k`, a `let` of the function it is written in: ... bind the value to a `const` before the call ``),
   read `this` (bind `const self = this`), or read a function parameter of its
   function. An arrow inside another arrow, or given to a method, a
-  constructor, `expose` or `exposeWith`, captures nothing.
+  constructor, `expose` or `exposeWith`, captures nothing; `xs.sort(cmp)`'s
+  comparator is the exception, and captures as an arrow argument does.
 - **The argument's type must match exactly**: `(x: i32) => i64` for a
   `(x: i32) => i32` parameter is refused. A generic function cannot be passed
   by name — write `(x) => identity(x)`.
@@ -2138,7 +2139,12 @@ there is no `undefined` to return), `a.indexOf(v)`, `a.join(sep)` — **`join` i
 `string[]` only** — and, on an array of numbers only, `dst.set(src[, offset])`
 (one `memmove`; a range past the end panics) and `a.fill(v[, start[, end]])`
 (ends clamped and counted back from the end when negative, as in JavaScript;
-never panics). Both are statements. That is every array method there is. A
+never panics). Both are statements. `a.sort(cmp)` sorts in place, stably, and
+answers `a` — the same order Node gives; the comparator is required (`a.sort()`
+is refused, since JavaScript would compare strings), a readonly array and
+`process.argv` are refused, `a - b` panics on `i32` values a full range apart
+(compare with `a > b ? 1 : a < b ? -1 : 0` there), and the comparator may read the caller's `const` locals and parameters but not
+a `let`, as any arrow argument may. That is every array method there is. A
 window into a buffer is `(buf, offset, length)`; there is no view type.
 
 **Strings.** `s.length` (**bytes**), `s.charCodeAt(i)` (the byte, bounds-checked),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amritk/nish-x86_64-linux",
-  "version": "0.31.0",
+  "version": "0.32.0",
   "description": "The nish native compiler for Linux on x86_64",
   "license": "MIT",
   "os": [

package/std/README.md

@@ -12,6 +12,7 @@ whatever program imports it, and subject to the same rules as `examples/` or
 | [`testing.ts`](./testing.ts) | a test runner: a `Suite` a program drives with straight-line assertions, printing the `PASS` / `FAIL` / `SKIP` lines the repository's own harness prints, and answering the exit code |
 | [`text.ts`](./text.ts) | the string operations a program would otherwise write inline: `splitLines`, `splitWhitespace`, `trim` and its halves, `contains`, `replaceAll`, `firstDifference` over two arrays of lines, `codePointLength`, the number of Unicode code points (what JSON Schema's `minLength` counts, where `.length` counts UTF-8 bytes natively and UTF-16 units under Node; it answers the same on both by asking which it is reading), and `indexOfAny(text, bytes, from)`, the first index at or after `from` whose byte is one of 1 to 16 ASCII `bytes`. Its walker is the meaning and what runs under Node; natively the compiler replaces the one call to it with the runtime kernel `nish_str_index_of_any`, which reads 16 or 32 bytes at a time and is variable-time ([`docs/LANGUAGE.md`](../docs/LANGUAGE.md#byte-search-indexofany-in-nishtext)). `tests/link/std_text_index_of_any*` are its programs |
 | [`math.ts`](./math.ts) | `Math.tan`, `Math.atan2` and `Math.hypot` on `f64`, ported from fdlibm (`LICENSE-fdlibm`) so that every target, wasm included, answers alike without libm. A program never imports it: a call to one of the three loads it, and the compiler copies the functions the call reaches into the calling module as `internal` ones. JavaScript's answer for every NaN, signed zero and infinity, and within one ulp elsewhere (0.83, 0.84 and 0.93 ulp measured against mpmath). `tests/cases/math_std_edges` pins the special values |
+| [`sort.ts`](./sort.ts) | `xs.sort(cmp)` on any array: `sortWith`, a stable merge sort over runs of 32 sorted by insertion — one scratch array released before it returns, a pair of runs already in order copied without merging, no bounds check left in it — so its order is element for element Node's `Array.prototype.sort`. Like `math.ts` it is one the compiler knows about: a program never imports it, a `.sort(cmp)` call loads it, the checker rewrites the call to `sortWith`, and each comparator's instantiation — the comparator called directly, no function pointer — is copied into the module that sorts. Under Node the call stays the platform's own. `tests/cases/arr_sort_cmp*` are its programs, a 10,000-element sort with ties among them |
 | [`regex.ts`](./regex.ts) | Regular expressions in JavaScript's syntax with the `u` flag's strictness, matched by a Pike VM in time linear in the input whatever the pattern; finding every match is one search per match, so `findAll` and its kin can be quadratic when a long branch is preferred to a short one that wins ([`docs/security/regex.md`](../docs/security/regex.md)). `regexCompile(pattern, flags)` answers a `Regex` or the error text; `test`, `exec` into a reused `RegexMatch`, `find`, `findAll`, `count`, `replace` and `replaceAll` with `$&`, `$1` and `$<name>`, and `split`. Flags `i`, `m`, `s` and `u`; `i` folds by Unicode's simple case folding, ASCII letters only to ASCII. `\p{…}` and `\P{…}` take Unicode 16.0's General_Category, Script, Script_Extensions and binary properties by JavaScript's names, from tables `scripts/gen-regex-unicode.mjs` generates into the module and checks against Node's `RegExp`; backreferences and lookaround are refused at compile time. Offsets are UTF-8 bytes. A search allocates nothing beyond its answer: the thread lists and capture tables are the `Regex`'s, so one `Regex` serves one thread at a time. A leading literal is found with `indexOf`, a small leading set with `indexOfAny`. `tests/link/std_regex` and `tests/link/std_regex_unicode` check it against JavaScript's own answers |
 | [`json.ts`](./json.ts) | `jsonField(object, name)`: the value of one field of one flat JSON object, which is the shape the compiler's own `--json` diagnostics have. A reader and not a parser — it answers text, answers `null` for a field that is not there, and does not validate. `JsonWriter` is the other direction: any JSON value written into a caller-owned `u8[]`, commas and colons included, byte for byte what `JSON.stringify` writes, and allocating nothing per call except an `f64`'s digits, a temporary string the call gives back before it returns (`text()` and `jsonStringifyString` build strings by design); misuse and a full buffer set a sticky negative `JSON_WRITE_*` code in `failed` rather than panicking. `setIndent(n)` and `setIndentTab()` write what `JSON.stringify(v, null, n)` or `(v, null, "\t")` writes, with no allocation for the indent, and `setStrict(true)` makes NaN and the infinities the sticky `JSON_WRITE_NON_FINITE` instead of `null`; both modes are off by default and kept by `reset`. `jsonStringifyString(s)` is the string rule answered as a string. `stringBytes(bytes, off, len)` and `keyBytes(bytes, off, len)` write a window of a byte array as `string` and `key` write a string of those bytes, allocating nothing, and refuse a window outside the array with `JSON_WRITE_BAD_WINDOW` |
 | [`json-tokenizer.ts`](./json-tokenizer.ts) | `JsonTokenizer`: a validating, streaming tokenizer for RFC 8259 JSON held in a window of a `u8[]`. `next()` answers one `JSON_TOK_*` token at a time — object and array openers and closers, keys, strings, numbers and the three literals — then `JSON_TOK_END`, or a negative `JSON_TOK_ERR_*` code that sticks in `failed`, with the byte in `errorAt`. Strings are checked as UTF-8 and a lone surrogate escape is refused; `stringInto` decodes the current string into the caller's array and `keyEquals` compares it with a name, neither allocating. `numberF64` is correctly rounded; `isInteger` and `numberI64` read an integer that fits an `i64`, and `isU64` and `numberU64` one that fits a `u64`. `isIntegral` asks whether a number's value is whole however it is written (`1.0`, `1e2`, `1e400`), JSON Schema's "integer", from the text and at any exponent. `skipValue` steps over a value. `JsonLimits` caps nesting depth, string, number and total bytes, each with its own code; `reset` reuses the tokenizer, so a reused body keeps the arena flat. Duplicate keys are reported as tokens. No input panics and no byte outside the window is read; [`docs/security/json.md`](../docs/security/json.md) is its record, and `tests/link/std_json_tokenizer` runs JSONTestSuite and a seeded fuzz |

package/std/crypto/bcrypt.ts

@@ -1024,7 +1024,9 @@ const bcryptLoadSlot = (state: Secret<u32[]>, password: Secret<u8[]>, slot: i32)
 // the lane count changed (bench/crypto/bcrypt/gen-body.mjs writes them), 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.
+// 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.
 
 /** `bcryptBody4`'s interleave on two lanes. */
 const bcryptBody2 = (st: u32[]): void => {
@@ -1089,35 +1091,41 @@ 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(l0 >>> 16) & 0xff
-      const l0c: i32 = toI32(l0 >>> 8) & 0xff
+      const l0b: i32 = toI32(l0e >>> 8) & 0xff
+      const l0c: i32 = toI32(l0e) & 0xff
       const l0d: i32 = toI32(l0) & 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(l1 >>> 16) & 0xff
-      const l1c: i32 = toI32(l1 >>> 8) & 0xff
+      const l1b: i32 = toI32(l1e >>> 8) & 0xff
+      const l1c: i32 = toI32(l1e) & 0xff
       const l1d: i32 = toI32(l1) & 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(l2 >>> 16) & 0xff
-      const l2c: i32 = toI32(l2 >>> 8) & 0xff
+      const l2b: i32 = toI32(l2e >>> 8) & 0xff
+      const l2c: i32 = toI32(l2e) & 0xff
       const l2d: i32 = toI32(l2) & 0xff
-      r0 ^= st[n] ^ (((st[18 + l0a] + st[274 + l0b]) ^ st[530 + l0c]) + st[786 + l0d])
-      r1 ^= st[1042 + n] ^ (((st[1060 + l1a] + st[1316 + l1b]) ^ st[1572 + l1c]) + st[1828 + l1d])
       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(r0 >>> 16) & 0xff
-      const r0c: i32 = toI32(r0 >>> 8) & 0xff
+      const r0b: i32 = toI32(r0e >>> 8) & 0xff
+      const r0c: i32 = toI32(r0e) & 0xff
       const r0d: i32 = toI32(r0) & 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(r1 >>> 16) & 0xff
-      const r1c: i32 = toI32(r1 >>> 8) & 0xff
+      const r1b: i32 = toI32(r1e >>> 8) & 0xff
+      const r1c: i32 = toI32(r1e) & 0xff
       const r1d: i32 = toI32(r1) & 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(r2 >>> 16) & 0xff
-      const r2c: i32 = toI32(r2 >>> 8) & 0xff
+      const r2b: i32 = toI32(r2e >>> 8) & 0xff
+      const r2c: i32 = toI32(r2e) & 0xff
       const r2d: i32 = toI32(r2) & 0xff
-      l0 ^= st[n + 1] ^ (((st[18 + r0a] + st[274 + r0b]) ^ st[530 + r0c]) + st[786 + r0d])
-      l1 ^= st[1042 + n + 1] ^ (((st[1060 + r1a] + st[1316 + r1b]) ^ st[1572 + r1c]) + st[1828 + r1d])
       l2 ^= st[2084 + n + 1] ^ (((st[2102 + r2a] + st[2358 + r2b]) ^ st[2614 + r2c]) + st[2870 + r2d])
     }
     const t0: u32 = r0
@@ -1143,6 +1151,19 @@ const bcryptBody3 = (st: u32[]): void => {
  * place, the four encryption chains interleaved round by round so that one
  * lane's S-box loads overlap the others' instead of waiting on their own. The
  * 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.
  */
 const bcryptBody4 = (st: u32[]): void => {
   if (st.length < 4168) {
@@ -1162,45 +1183,53 @@ 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(l0 >>> 16) & 0xff
-      const l0c: i32 = toI32(l0 >>> 8) & 0xff
+      const l0b: i32 = toI32(l0e >>> 8) & 0xff
+      const l0c: i32 = toI32(l0e) & 0xff
       const l0d: i32 = toI32(l0) & 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(l1 >>> 16) & 0xff
-      const l1c: i32 = toI32(l1 >>> 8) & 0xff
+      const l1b: i32 = toI32(l1e >>> 8) & 0xff
+      const l1c: i32 = toI32(l1e) & 0xff
       const l1d: i32 = toI32(l1) & 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(l2 >>> 16) & 0xff
-      const l2c: i32 = toI32(l2 >>> 8) & 0xff
+      const l2b: i32 = toI32(l2e >>> 8) & 0xff
+      const l2c: i32 = toI32(l2e) & 0xff
       const l2d: i32 = toI32(l2) & 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(l3 >>> 16) & 0xff
-      const l3c: i32 = toI32(l3 >>> 8) & 0xff
+      const l3b: i32 = toI32(l3e >>> 8) & 0xff
+      const l3c: i32 = toI32(l3e) & 0xff
       const l3d: i32 = toI32(l3) & 0xff
-      r0 ^= st[n] ^ (((st[18 + l0a] + st[274 + l0b]) ^ st[530 + l0c]) + st[786 + l0d])
-      r1 ^= st[1042 + n] ^ (((st[1060 + l1a] + st[1316 + l1b]) ^ st[1572 + l1c]) + st[1828 + l1d])
-      r2 ^= st[2084 + n] ^ (((st[2102 + l2a] + st[2358 + l2b]) ^ st[2614 + l2c]) + st[2870 + l2d])
       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(r0 >>> 16) & 0xff
-      const r0c: i32 = toI32(r0 >>> 8) & 0xff
+      const r0b: i32 = toI32(r0e >>> 8) & 0xff
+      const r0c: i32 = toI32(r0e) & 0xff
       const r0d: i32 = toI32(r0) & 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(r1 >>> 16) & 0xff
-      const r1c: i32 = toI32(r1 >>> 8) & 0xff
+      const r1b: i32 = toI32(r1e >>> 8) & 0xff
+      const r1c: i32 = toI32(r1e) & 0xff
       const r1d: i32 = toI32(r1) & 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(r2 >>> 16) & 0xff
-      const r2c: i32 = toI32(r2 >>> 8) & 0xff
+      const r2b: i32 = toI32(r2e >>> 8) & 0xff
+      const r2c: i32 = toI32(r2e) & 0xff
       const r2d: i32 = toI32(r2) & 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(r3 >>> 16) & 0xff
-      const r3c: i32 = toI32(r3 >>> 8) & 0xff
+      const r3b: i32 = toI32(r3e >>> 8) & 0xff
+      const r3c: i32 = toI32(r3e) & 0xff
       const r3d: i32 = toI32(r3) & 0xff
-      l0 ^= st[n + 1] ^ (((st[18 + r0a] + st[274 + r0b]) ^ st[530 + r0c]) + st[786 + r0d])
-      l1 ^= st[1042 + n + 1] ^ (((st[1060 + r1a] + st[1316 + r1b]) ^ st[1572 + r1c]) + st[1828 + r1d])
-      l2 ^= st[2084 + n + 1] ^ (((st[2102 + r2a] + st[2358 + r2b]) ^ st[2614 + r2c]) + st[2870 + r2d])
       l3 ^= st[3126 + n + 1] ^ (((st[3144 + r3a] + st[3400 + r3b]) ^ st[3656 + r3c]) + st[3912 + r3d])
     }
     const t0: u32 = r0
@@ -1248,55 +1277,65 @@ 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(l0 >>> 16) & 0xff
-      const l0c: i32 = toI32(l0 >>> 8) & 0xff
+      const l0b: i32 = toI32(l0e >>> 8) & 0xff
+      const l0c: i32 = toI32(l0e) & 0xff
       const l0d: i32 = toI32(l0) & 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(l1 >>> 16) & 0xff
-      const l1c: i32 = toI32(l1 >>> 8) & 0xff
+      const l1b: i32 = toI32(l1e >>> 8) & 0xff
+      const l1c: i32 = toI32(l1e) & 0xff
       const l1d: i32 = toI32(l1) & 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(l2 >>> 16) & 0xff
-      const l2c: i32 = toI32(l2 >>> 8) & 0xff
+      const l2b: i32 = toI32(l2e >>> 8) & 0xff
+      const l2c: i32 = toI32(l2e) & 0xff
       const l2d: i32 = toI32(l2) & 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(l3 >>> 16) & 0xff
-      const l3c: i32 = toI32(l3 >>> 8) & 0xff
+      const l3b: i32 = toI32(l3e >>> 8) & 0xff
+      const l3c: i32 = toI32(l3e) & 0xff
       const l3d: i32 = toI32(l3) & 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(l4 >>> 16) & 0xff
-      const l4c: i32 = toI32(l4 >>> 8) & 0xff
+      const l4b: i32 = toI32(l4e >>> 8) & 0xff
+      const l4c: i32 = toI32(l4e) & 0xff
       const l4d: i32 = toI32(l4) & 0xff
-      r0 ^= st[n] ^ (((st[18 + l0a] + st[274 + l0b]) ^ st[530 + l0c]) + st[786 + l0d])
-      r1 ^= st[1042 + n] ^ (((st[1060 + l1a] + st[1316 + l1b]) ^ st[1572 + l1c]) + st[1828 + l1d])
-      r2 ^= st[2084 + n] ^ (((st[2102 + l2a] + st[2358 + l2b]) ^ st[2614 + l2c]) + st[2870 + l2d])
-      r3 ^= st[3126 + n] ^ (((st[3144 + l3a] + st[3400 + l3b]) ^ st[3656 + l3c]) + st[3912 + l3d])
       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(r0 >>> 16) & 0xff
-      const r0c: i32 = toI32(r0 >>> 8) & 0xff
+      const r0b: i32 = toI32(r0e >>> 8) & 0xff
+      const r0c: i32 = toI32(r0e) & 0xff
       const r0d: i32 = toI32(r0) & 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(r1 >>> 16) & 0xff
-      const r1c: i32 = toI32(r1 >>> 8) & 0xff
+      const r1b: i32 = toI32(r1e >>> 8) & 0xff
+      const r1c: i32 = toI32(r1e) & 0xff
       const r1d: i32 = toI32(r1) & 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(r2 >>> 16) & 0xff
-      const r2c: i32 = toI32(r2 >>> 8) & 0xff
+      const r2b: i32 = toI32(r2e >>> 8) & 0xff
+      const r2c: i32 = toI32(r2e) & 0xff
       const r2d: i32 = toI32(r2) & 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(r3 >>> 16) & 0xff
-      const r3c: i32 = toI32(r3 >>> 8) & 0xff
+      const r3b: i32 = toI32(r3e >>> 8) & 0xff
+      const r3c: i32 = toI32(r3e) & 0xff
       const r3d: i32 = toI32(r3) & 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(r4 >>> 16) & 0xff
-      const r4c: i32 = toI32(r4 >>> 8) & 0xff
+      const r4b: i32 = toI32(r4e >>> 8) & 0xff
+      const r4c: i32 = toI32(r4e) & 0xff
       const r4d: i32 = toI32(r4) & 0xff
-      l0 ^= st[n + 1] ^ (((st[18 + r0a] + st[274 + r0b]) ^ st[530 + r0c]) + st[786 + r0d])
-      l1 ^= st[1042 + n + 1] ^ (((st[1060 + r1a] + st[1316 + r1b]) ^ st[1572 + r1c]) + st[1828 + r1d])
-      l2 ^= st[2084 + n + 1] ^ (((st[2102 + r2a] + st[2358 + r2b]) ^ st[2614 + r2c]) + st[2870 + r2d])
-      l3 ^= st[3126 + n + 1] ^ (((st[3144 + r3a] + st[3400 + r3b]) ^ st[3656 + r3c]) + st[3912 + r3d])
       l4 ^= st[4168 + n + 1] ^ (((st[4186 + r4a] + st[4442 + r4b]) ^ st[4698 + r4c]) + st[4954 + r4d])
     }
     const t0: u32 = r0
@@ -1352,65 +1391,77 @@ 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(l0 >>> 16) & 0xff
-      const l0c: i32 = toI32(l0 >>> 8) & 0xff
+      const l0b: i32 = toI32(l0e >>> 8) & 0xff
+      const l0c: i32 = toI32(l0e) & 0xff
       const l0d: i32 = toI32(l0) & 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(l1 >>> 16) & 0xff
-      const l1c: i32 = toI32(l1 >>> 8) & 0xff
+      const l1b: i32 = toI32(l1e >>> 8) & 0xff
+      const l1c: i32 = toI32(l1e) & 0xff
       const l1d: i32 = toI32(l1) & 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(l2 >>> 16) & 0xff
-      const l2c: i32 = toI32(l2 >>> 8) & 0xff
+      const l2b: i32 = toI32(l2e >>> 8) & 0xff
+      const l2c: i32 = toI32(l2e) & 0xff
       const l2d: i32 = toI32(l2) & 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(l3 >>> 16) & 0xff
-      const l3c: i32 = toI32(l3 >>> 8) & 0xff
+      const l3b: i32 = toI32(l3e >>> 8) & 0xff
+      const l3c: i32 = toI32(l3e) & 0xff
       const l3d: i32 = toI32(l3) & 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(l4 >>> 16) & 0xff
-      const l4c: i32 = toI32(l4 >>> 8) & 0xff
+      const l4b: i32 = toI32(l4e >>> 8) & 0xff
+      const l4c: i32 = toI32(l4e) & 0xff
       const l4d: i32 = toI32(l4) & 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
-      const l5b: i32 = toI32(l5 >>> 16) & 0xff
-      const l5c: i32 = toI32(l5 >>> 8) & 0xff
+      const l5b: i32 = toI32(l5e >>> 8) & 0xff
+      const l5c: i32 = toI32(l5e) & 0xff
       const l5d: i32 = toI32(l5) & 0xff
-      r0 ^= st[n] ^ (((st[18 + l0a] + st[274 + l0b]) ^ st[530 + l0c]) + st[786 + l0d])
-      r1 ^= st[1042 + n] ^ (((st[1060 + l1a] + st[1316 + l1b]) ^ st[1572 + l1c]) + st[1828 + l1d])
-      r2 ^= st[2084 + n] ^ (((st[2102 + l2a] + st[2358 + l2b]) ^ st[2614 + l2c]) + st[2870 + l2d])
-      r3 ^= st[3126 + n] ^ (((st[3144 + l3a] + st[3400 + l3b]) ^ st[3656 + l3c]) + st[3912 + l3d])
-      r4 ^= st[4168 + n] ^ (((st[4186 + l4a] + st[4442 + l4b]) ^ st[4698 + l4c]) + st[4954 + l4d])
       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(r0 >>> 16) & 0xff
-      const r0c: i32 = toI32(r0 >>> 8) & 0xff
+      const r0b: i32 = toI32(r0e >>> 8) & 0xff
+      const r0c: i32 = toI32(r0e) & 0xff
       const r0d: i32 = toI32(r0) & 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(r1 >>> 16) & 0xff
-      const r1c: i32 = toI32(r1 >>> 8) & 0xff
+      const r1b: i32 = toI32(r1e >>> 8) & 0xff
+      const r1c: i32 = toI32(r1e) & 0xff
       const r1d: i32 = toI32(r1) & 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(r2 >>> 16) & 0xff
-      const r2c: i32 = toI32(r2 >>> 8) & 0xff
+      const r2b: i32 = toI32(r2e >>> 8) & 0xff
+      const r2c: i32 = toI32(r2e) & 0xff
       const r2d: i32 = toI32(r2) & 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(r3 >>> 16) & 0xff
-      const r3c: i32 = toI32(r3 >>> 8) & 0xff
+      const r3b: i32 = toI32(r3e >>> 8) & 0xff
+      const r3c: i32 = toI32(r3e) & 0xff
       const r3d: i32 = toI32(r3) & 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(r4 >>> 16) & 0xff
-      const r4c: i32 = toI32(r4 >>> 8) & 0xff
+      const r4b: i32 = toI32(r4e >>> 8) & 0xff
+      const r4c: i32 = toI32(r4e) & 0xff
       const r4d: i32 = toI32(r4) & 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
-      const r5b: i32 = toI32(r5 >>> 16) & 0xff
-      const r5c: i32 = toI32(r5 >>> 8) & 0xff
+      const r5b: i32 = toI32(r5e >>> 8) & 0xff
+      const r5c: i32 = toI32(r5e) & 0xff
       const r5d: i32 = toI32(r5) & 0xff
-      l0 ^= st[n + 1] ^ (((st[18 + r0a] + st[274 + r0b]) ^ st[530 + r0c]) + st[786 + r0d])
-      l1 ^= st[1042 + n + 1] ^ (((st[1060 + r1a] + st[1316 + r1b]) ^ st[1572 + r1c]) + st[1828 + r1d])
-      l2 ^= st[2084 + n + 1] ^ (((st[2102 + r2a] + st[2358 + r2b]) ^ st[2614 + r2c]) + st[2870 + r2d])
-      l3 ^= st[3126 + n + 1] ^ (((st[3144 + r3a] + st[3400 + r3b]) ^ st[3656 + r3c]) + st[3912 + r3d])
-      l4 ^= st[4168 + n + 1] ^ (((st[4186 + r4a] + st[4442 + r4b]) ^ st[4698 + r4c]) + st[4954 + r4d])
       l5 ^= st[5210 + n + 1] ^ (((st[5228 + r5a] + st[5484 + r5b]) ^ st[5740 + r5c]) + st[5996 + r5d])
     }
     const t0: u32 = r0

package/std/sort.ts

@@ -0,0 +1,178 @@
+/**
+ * `std/sort` — `xs.sort(cmp)` on an array, in Nish: a stable merge sort,
+ * compiled once per comparator.
+ *
+ * A program does not import this module. A `.sort(cmp)` call is what loads it
+ * (the checker's `importSort`), and the checker routes the call to `sortWith`
+ * here. `cmp` is a compile-time function parameter, so each comparator is an
+ * instantiation of its own whose body calls the comparator directly — there is
+ * no function pointer. Under Node and `tsc` the call is the platform's
+ * `Array.prototype.sort`, so nothing here runs there.
+ *
+ * **Same order as Node.** `Array.prototype.sort` is stable (ES2019), so for a
+ * comparator that is a consistent total preorder there is exactly one answer,
+ * and any stable sort gives it. A comparator's result is read only as "greater
+ * than zero or not": a later element moves before an earlier one only when
+ * the comparator answers a positive number for (earlier, later), so a negative
+ * zero and NaN are zero, as Node treats them.
+ *
+ * **Shape.** The array is copied once into a scratch array of the same
+ * length, the only allocation, which the function's arena scope gives back
+ * before it returns, so a sort leaves `Arena.used()` where it was. Runs of
+ * `RUN` are sorted by insertion from the scratch into the array (a strictly
+ * descending run is copied reversed instead), then merged
+ * bottom-up, alternating between the two, and copied back once if the last
+ * pass ended in the scratch. A pair of runs already in order is copied without
+ * a merge. Every merge takes from the left run on a tie, which is what makes
+ * it stable.
+ *
+ * **No element is held across a write.** An `interface` element is stored
+ * inline, and `const v = xs[i]` is a pointer into the array, so an insertion
+ * sort in place would overwrite the element it is inserting. Every step here
+ * reads from one array and writes the other, and moves a whole slot, which for
+ * an inline record is one copy of its bytes.
+ *
+ * **Proofs.** Every index is proven in range by the guard written beside it,
+ * so no access keeps its bounds check. The run arithmetic wraps only where
+ * the operands are proven to lie in `0..n`, so it cannot wrap: a difference
+ * of two of them, or a sum taken only when it stays below `n`.
+ */
+
+import { wrappingAdd, wrappingSub } from "nish:unsafe"
+
+/** The length of the runs insertion sort makes before the first merge. */
+const RUN: i32 = 32
+
+/**
+ * `lo + step`, or `n` when that is not below `n`. Every caller has
+ * `0 <= lo <= n`, so `n - lo` cannot wrap, and the sum is taken only below `n`.
+ */
+const stepTo = (lo: i32, step: i32, n: i32): i32 => (wrappingSub(n, lo) > step ? wrappingAdd(lo, step) : n)
+
+/**
+ * `src[lo..hi)` sorted by insertion into `dst[lo..hi)`. The comparator call
+ * forgets every array length, so each access after it repeats its guard.
+ */
+const insertionRun = <T>(src: T[], dst: T[], cmp: (a: T, b: T) => number, lo: i32, hi: i32): void => {
+  // A strictly descending run is copied reversed: no two of its elements are
+  // equal, so reversing it keeps the sort stable, and costs one comparison each.
+  // `lo < hi`, and `d` steps only while below `hi`, so neither `+ 1` wraps.
+  let d = wrappingAdd(lo, 1)
+  while (d > 0 && d < hi && d < toI32(src.length)) {
+    const p = d - 1
+    if (!(cmp(src[p], src[d]) > 0)) {
+      break
+    }
+    d = wrappingAdd(d, 1)
+  }
+  if (d >= hi) {
+    // `hi > lo >= 0`, so `hi - 1` does not wrap, and `r` steps down only from `r >= 0`.
+    let r = wrappingSub(hi, 1)
+    for (let k: i32 = lo; k >= 0 && k < hi && k < toI32(dst.length) && r >= 0 && r < toI32(src.length); k++) {
+      dst[k] = src[r]
+      r = wrappingSub(r, 1)
+    }
+    return
+  }
+  for (let i: i32 = lo; i >= 0 && i < hi; i++) {
+    let j = i
+    while (j > lo && j > 0 && j < toI32(dst.length) && i < toI32(src.length)) {
+      const k = j - 1
+      if (!(cmp(dst[k], src[i]) > 0) || k < 0 || k >= toI32(dst.length) || j >= toI32(dst.length)) {
+        break
+      }
+      dst[j] = dst[k]
+      j = k
+    }
+    if (i < toI32(src.length) && j >= 0 && j < toI32(dst.length)) {
+      dst[j] = src[i]
+    }
+  }
+}
+
+/** `src[lo..hi)` copied into `dst[lo..hi)`. */
+const copyRun = <T>(src: T[], dst: T[], lo: i32, hi: i32): void => {
+  for (let k: i32 = lo; k >= 0 && k < hi && k < toI32(src.length) && k < toI32(dst.length); k++) {
+    dst[k] = src[k]
+  }
+}
+
+/**
+ * The sorted runs `src[lo..mid)` and `src[mid..hi)` merged into `dst[lo..hi)`,
+ * or copied when the last of the left run is not after the first of the right.
+ */
+const mergeRuns = <T>(src: T[], dst: T[], cmp: (a: T, b: T) => number, lo: i32, mid: i32, hi: i32): void => {
+  if (mid > 0 && mid < hi && mid < toI32(src.length)) {
+    const last = mid - 1
+    if (last < toI32(src.length) && !(cmp(src[last], src[mid]) > 0)) {
+      copyRun(src, dst, lo, hi)
+      return
+    }
+  }
+  let i = lo
+  let j = mid
+  for (let k: i32 = lo; k >= 0 && k < hi; k++) {
+    let right = i >= mid
+    if (!right && j < hi && i >= 0 && i < toI32(src.length) && j >= 0 && j < toI32(src.length)) {
+      right = cmp(src[i], src[j]) > 0
+    }
+    if (right) {
+      if (j >= 0 && j < toI32(src.length) && k < toI32(dst.length)) {
+        dst[k] = src[j]
+      }
+      // `j` steps at most `hi - mid` times from `mid`, so it stays at most `hi`.
+      j = wrappingAdd(j, 1)
+    } else {
+      if (i >= 0 && i < toI32(src.length) && k < toI32(dst.length)) {
+        dst[k] = src[i]
+      }
+      // `i` steps at most `mid - lo` times from `lo`, so it stays at most `mid`.
+      i = wrappingAdd(i, 1)
+    }
+  }
+}
+
+/** One bottom-up pass: every pair of adjacent `width`-runs of `src` merged into `dst`. */
+const mergePass = <T>(src: T[], dst: T[], cmp: (a: T, b: T) => number, n: i32, width: i32): void => {
+  let lo: i32 = 0
+  while (lo >= 0 && lo < n) {
+    const mid = stepTo(lo, width, n)
+    const hi = stepTo(mid, width, n)
+    mergeRuns(src, dst, cmp, lo, mid, hi)
+    lo = hi
+  }
+}
+
+/** `xs` sorted in place by `cmp`, stably, and answered: what `xs.sort(cmp)` compiles to. */
+export const sortWith = <T>(xs: T[], cmp: (a: T, b: T) => number): T[] => {
+  const n: i32 = toI32(xs.length)
+  if (n < 2) {
+    return xs
+  }
+  // One allocation at full size, every slot written before any is read: the
+  // checker lets this `new Array<T>(n)` hold any `T`, and neither emitter
+  // zero-fills it (`isSortInstance`).
+  const tmp = new Array<T>(n)
+  copyRun(xs, tmp, 0, n)
+  let lo: i32 = 0
+  while (lo >= 0 && lo < n) {
+    const hi = stepTo(lo, RUN, n)
+    insertionRun(tmp, xs, cmp, lo, hi)
+    lo = hi
+  }
+  let inTmp = false
+  let width: i32 = RUN
+  while (width > 0 && width < n) {
+    if (inTmp) {
+      mergePass(tmp, xs, cmp, n, width)
+    } else {
+      mergePass(xs, tmp, cmp, n, width)
+    }
+    inTmp = !inTmp
+    width = stepTo(width, width, n)
+  }
+  if (inTmp) {
+    copyRun(tmp, xs, 0, n)
+  }
+  return xs
+}