@amritk/nish 0.11.0 → 0.13.0

package/std/collections.ts

@@ -47,10 +47,10 @@
  * what the 24-bit index field holds as an index plus one. Node's own `Map` and
  * `Set` hold one more, 2^24, and throw on the next insert.
  */
-const INDEX_CAP: i32 = 16777215;
+const INDEX_CAP: i32 = 16777215
 
 /** The first bucket count. A power of two, as every bucket count is. */
-const INITIAL_SLOTS: i32 = 8;
+const INITIAL_SLOTS: i32 = 8
 
 /**
  * The key's hash, never 0: FNV-1a over a string's bytes, murmur3's `fmix32`
@@ -60,11 +60,11 @@ const INITIAL_SLOTS: i32 = 8;
  * constants are public domain.
  *
  * The body is never emitted. Every call is lowered in place, per key type, by
- * `self/emit_map.ts`; the constant is what the checker and the whole-program
+ * `src/emit-map.ts`; the constant is what the checker and the whole-program
  * facts see, and the facts of the function that calls it are what decide its
  * attributes, because every call is inside a probe that reads the table.
  */
-const hashKey = <K>(key: K): u32 => 1;
+const hashKey = <K>(_key: K): u32 => 1
 
 /**
  * JavaScript's key equality, SameValueZero: `===`, except that NaN equals NaN.
@@ -72,19 +72,19 @@ const hashKey = <K>(key: K): u32 => 1;
  * `icmp` for an integer, a boolean, an enum and a class instance, and for a
  * float `a == b` or both unordered.
  */
-const sameKey = <K>(a: K, b: K): boolean => a === b;
+const sameKey = <K>(a: K, b: K): boolean => a === b
 
 /** The first bucket for `h`: its low bits, folded with the high half. */
-const homeBucket = (h: u32, mask: i32): i32 => toI32(h ^ (h >>> 16)) & mask;
+const homeBucket = (h: u32, mask: i32): i32 => toI32(h ^ (h >>> 16)) & mask
 
 /** The bucket word for entry `index` of hash `h`. */
-const slotWord = (h: u32, index: i32): u32 => ((h >>> 24) << 24) | toU32(index + 1);
+const slotWord = (h: u32, index: i32): u32 => ((h >>> 24) << 24) | toU32(index + 1)
 
 /** A probe that found entry `index`, pointed at by `bucket`. Never negative. */
-const foundAt = (bucket: i32, index: i32): i64 => (toI64(bucket) << 32) | toI64(index);
+const foundAt = (bucket: i32, index: i32): i64 => (toI64(bucket) << 32) | toI64(index)
 
 /** A probe that stopped at the empty `bucket` for hash `h`. Always negative. */
-const absentAt = (bucket: i32, h: u32): i64 => toI64(-1) - ((toI64(bucket) << 32) | toI64(h));
+const absentAt = (bucket: i32, h: u32): i64 => toI64(-1) - ((toI64(bucket) << 32) | toI64(h))
 
 /**
  * The one probe, for both classes: linear probing from `h`'s home bucket to
@@ -94,26 +94,32 @@ const absentAt = (bucket: i32, h: u32): i64 => toI64(-1) - ((toI64(bucket) << 32
  * empty, so the walk ends.
  */
 const probeTable = <K>(slots: u32[], mask: i32, hashes: u32[], keys: K[], key: K): i64 => {
-  const h = hashKey(key);
-  const fingerprint = h >>> 24;
-  let bucket = homeBucket(h, mask);
+  const h = hashKey(key)
+  const fingerprint = h >>> 24
+  let bucket = homeBucket(h, mask)
   // The length is read in the condition rather than once: the key compare is
   // a call, and a call ends every length fact the bounds proof holds.
   while (bucket >= 0 && bucket < toI32(slots.length)) {
-    const word = slots[bucket];
+    const word = slots[bucket]
     if (word === 0) {
-      return absentAt(bucket, h);
+      return absentAt(bucket, h)
     }
     if (word >>> 24 === fingerprint) {
-      const at = toI32(word & 16777215) - 1;
-      if (at >= 0 && at < toI32(hashes.length) && hashes[at] === h && at < toI32(keys.length) && sameKey(keys[at], key)) {
-        return foundAt(bucket, at);
+      const at = toI32(word & 16777215) - 1
+      if (
+        at >= 0 &&
+        at < toI32(hashes.length) &&
+        hashes[at] === h &&
+        at < toI32(keys.length) &&
+        sameKey(keys[at], key)
+      ) {
+        return foundAt(bucket, at)
       }
     }
-    bucket = (bucket + 1) & mask;
+    bucket = (bucket + 1) & mask
   }
-  panic("collections: a probe ran out of buckets");
-};
+  panic("collections: a probe ran out of buckets")
+}
 
 /**
  * Point the first empty bucket from `h`'s home at entry `index`. A rebuild's
@@ -121,47 +127,47 @@ const probeTable = <K>(slots: u32[], mask: i32, hashes: u32[], keys: K[], key: K
  * compared, and the stored hash is all it needs.
  */
 const fileEntry = (slots: u32[], mask: i32, h: u32, index: i32): void => {
-  const word = slotWord(h, index);
-  let bucket = homeBucket(h, mask);
+  const word = slotWord(h, index)
+  let bucket = homeBucket(h, mask)
   while (bucket >= 0 && bucket < toI32(slots.length)) {
     if (slots[bucket] === 0) {
-      slots[bucket] = word;
-      return;
+      slots[bucket] = word
+      return
     }
-    bucket = (bucket + 1) & mask;
+    bucket = (bucket + 1) & mask
   }
-};
+}
 
 /** Slide the live entries of `items` down over the dead ones, in order, and drop the tail. */
 const compactEntries = <T>(items: T[], hashes: u32[]): void => {
-  const used = toI32(items.length);
-  let to: i32 = 0;
+  const used = toI32(items.length)
+  let to: i32 = 0
   for (let from: i32 = 0; from < used && from < toI32(hashes.length); from++) {
     if (hashes[from] !== 0 && to >= 0 && to < used && from < toI32(items.length)) {
-      items[to] = items[from];
-      to++;
+      items[to] = items[from]
+      to++
     }
   }
   while (toI32(items.length) > to) {
-    items.pop();
+    items.pop()
   }
-};
+}
 
 /** The stored hashes compacted the same way, last, since the two above read them. */
 const compactHashes = (hashes: u32[]): void => {
-  const used = toI32(hashes.length);
-  let to: i32 = 0;
+  const used = toI32(hashes.length)
+  let to: i32 = 0
   for (let from: i32 = 0; from < used; from++) {
-    const h = hashes[from];
+    const h = hashes[from]
     if (h !== 0 && to >= 0 && to < used) {
-      hashes[to] = h;
-      to++;
+      hashes[to] = h
+      to++
     }
   }
   while (toI32(hashes.length) > to) {
-    hashes.pop();
+    hashes.pop()
   }
-};
+}
 
 /**
  * The bucket table after a rebuild of `live` entries out of `used`. More than
@@ -171,13 +177,13 @@ const compactHashes = (hashes: u32[]): void => {
  * the table never shrinks.
  */
 const rebuiltSlots = (slots: u32[], live: i32, used: i32): u32[] => {
-  const n = toI32(slots.length);
+  const n = toI32(slots.length)
   if (live * 2 < used) {
-    clearSlots(slots);
-    return slots;
+    clearSlots(slots)
+    return slots
   }
-  return new Array<u32>(n * 2);
-};
+  return new Array<u32>(n * 2)
+}
 
 /**
  * Re-file every live entry from its stored hash. After a compaction none is
@@ -185,14 +191,14 @@ const rebuiltSlots = (slots: u32[], live: i32, used: i32): u32[] => {
  * keeps its place and takes no bucket, since no probe can find it.
  */
 const refile = (slots: u32[], hashes: u32[]): void => {
-  const mask = toI32(slots.length) - 1;
+  const mask = toI32(slots.length) - 1
   for (let i: i32 = 0; i < toI32(hashes.length); i++) {
-    const h = hashes[i];
+    const h = hashes[i]
     if (h !== 0) {
-      fileEntry(slots, mask, h, i);
+      fileEntry(slots, mask, h, i)
     }
   }
-};
+}
 
 /**
  * `delete`'s write through a found probe result: the bucket becomes a
@@ -200,15 +206,15 @@ const refile = (slots: u32[], hashes: u32[]): void => {
  * until a rebuild compacts them away (§6.1).
  */
 const killEntry = (slots: u32[], hashes: u32[], found: i64): void => {
-  const at = toI32(found);
-  const bucket = toI32(found >> 32);
+  const at = toI32(found)
+  const bucket = toI32(found >> 32)
   if (bucket >= 0 && bucket < toI32(slots.length)) {
-    slots[bucket] = 16777216;
+    slots[bucket] = 16777216
   }
   if (at >= 0 && at < toI32(hashes.length)) {
-    hashes[at] = 0;
+    hashes[at] = 0
   }
-};
+}
 
 /**
  * Zero every element in place: the buckets, which emptying a table and
@@ -217,9 +223,9 @@ const killEntry = (slots: u32[], hashes: u32[], found: i64): void => {
  */
 const clearSlots = (slots: u32[]): void => {
   for (let i: i32 = 0; i < toI32(slots.length); i++) {
-    slots[i] = 0;
+    slots[i] = 0
   }
-};
+}
 
 /**
  * The index of the first live entry at `from` or after it, or -1 when there is
@@ -231,18 +237,18 @@ const clearSlots = (slots: u32[]): void => {
 const nextLive = (hashes: u32[], from: i32): i32 => {
   for (let i: i32 = from; i >= 0 && i < toI32(hashes.length); i++) {
     if (hashes[i] !== 0) {
-      return i;
+      return i
     }
   }
-  return -1;
-};
+  return -1
+}
 
 /** Drop every element of `items`, keeping its capacity. */
 const truncate = <T>(items: T[]): void => {
   while (toI32(items.length) > 0) {
-    items.pop();
+    items.pop()
   }
-};
+}
 
 /**
  * Point bucket `bucket`, the empty one an absent probe stopped at, at the entry
@@ -251,11 +257,11 @@ const truncate = <T>(items: T[]): void => {
  */
 const fileAppended = (slots: u32[], mask: i32, bucket: i32, h: u32, used: i32): void => {
   if (bucket >= 0 && bucket < toI32(slots.length)) {
-    slots[bucket] = slotWord(h, used - 1);
+    slots[bucket] = slotWord(h, used - 1)
   } else {
-    fileEntry(slots, mask, h, used - 1);
+    fileEntry(slots, mask, h, used - 1)
   }
-};
+}
 
 /**
  * A key-value table in insertion order, with JavaScript's semantics: keys are
@@ -265,60 +271,60 @@ const fileAppended = (slots: u32[], mask: i32, bucket: i32, h: u32, used: i32):
 // biome-ignore lint/suspicious/noShadowRestrictedNames: this is the global `Map`, which the compiler loads for a program that names it
 export class Map<K, V> {
   /** How many entries are live. The one field a program may read, and it may not write it. */
-  size: number = 0;
+  size: number = 0
   /** Bucket -> fingerprint and entry index plus one; see the header. */
-  slots: u32[];
+  slots: u32[]
   /** `slots.length - 1`: the table is a power of two. */
-  mask: i32 = 7;
+  mask: i32 = 7
   /** Live entries, as an `i32` for the load and compaction arithmetic. */
-  live: i32 = 0;
-  entryKeys: K[];
-  entryValues: V[];
+  live: i32 = 0
+  entryKeys: K[]
+  entryValues: V[]
   /** The full hash of each entry; 0 once the entry is deleted. */
-  entryHashes: u32[];
+  entryHashes: u32[]
   /**
    * How many `for...of` loops are walking the table now. While it is above 0
    * a rebuild doubles rather than compacts, and `clear` marks entries dead
    * rather than truncating, so no entry moves under a walk's cursor (§6.2).
    */
-  walks: i32 = 0;
+  walks: i32 = 0
 
   constructor() {
-    this.slots = new Array<u32>(INITIAL_SLOTS);
-    this.entryKeys = [];
-    this.entryValues = [];
-    this.entryHashes = [];
+    this.slots = new Array<u32>(INITIAL_SLOTS)
+    this.entryKeys = []
+    this.entryValues = []
+    this.entryHashes = []
   }
 
   /** The packed probe result for `key`: see `probeTable`, `foundAt` and `absentAt`. */
   probe(key: K): i64 {
-    return probeTable(this.slots, this.mask, this.entryHashes, this.entryKeys, key);
+    return probeTable(this.slots, this.mask, this.entryHashes, this.entryKeys, key)
   }
 
   has(key: K): boolean {
-    return this.probe(key) >= 0;
+    return this.probe(key) >= 0
   }
 
   /** Set `key` to `value`, in place when it is there and at the end when it is not: one probe. */
   set(key: K, value: V): Map<K, V> {
-    const found = this.probe(key);
+    const found = this.probe(key)
     if (found >= 0) {
-      this.setValueAt(toI32(found), value);
+      this.setValueAt(toI32(found), value)
     } else {
-      this.insertAt(found, key, value);
+      this.insertAt(found, key, value)
     }
-    return this;
+    return this
   }
 
   delete(key: K): boolean {
-    const found = this.probe(key);
+    const found = this.probe(key)
     if (found < 0) {
-      return false;
+      return false
     }
-    killEntry(this.slots, this.entryHashes, found);
-    this.live = this.live - 1;
-    this.size = this.size - 1;
-    return true;
+    killEntry(this.slots, this.entryHashes, found)
+    this.live = this.live - 1
+    this.size = this.size - 1
+    return true
   }
 
   /**
@@ -326,16 +332,16 @@ export class Map<K, V> {
    * truncated, or, while a loop walks the table, marked dead and kept (§6.1).
    */
   clear(): void {
-    clearSlots(this.slots);
+    clearSlots(this.slots)
     if (this.walks > 0) {
-      clearSlots(this.entryHashes); // every entry dead, and the count kept
+      clearSlots(this.entryHashes) // every entry dead, and the count kept
     } else {
-      truncate(this.entryKeys);
-      truncate(this.entryValues);
-      truncate(this.entryHashes);
+      truncate(this.entryKeys)
+      truncate(this.entryValues)
+      truncate(this.entryHashes)
     }
-    this.live = 0;
-    this.size = 0;
+    this.live = 0
+    this.size = 0
   }
 
   /**
@@ -346,66 +352,66 @@ export class Map<K, V> {
    * that leaves the loop. Two stores a loop, and none per entry.
    */
   walkOpen(): void {
-    this.walks = this.walks + 1;
+    this.walks = this.walks + 1
   }
 
   walkNext(from: i32): i32 {
-    return nextLive(this.entryHashes, from);
+    return nextLive(this.entryHashes, from)
   }
 
   walkClose(): void {
-    this.walks = this.walks - 1;
+    this.walks = this.walks - 1
   }
 
   /** The key of entry `index`, which `walkNext` answered. */
   keyAt(index: i32): K {
     if (index < 0 || index >= toI32(this.entryKeys.length)) {
-      panic("Map: no entry at this index");
+      panic("Map: no entry at this index")
     }
-    return this.entryKeys[index];
+    return this.entryKeys[index]
   }
 
   /** The value of the entry a probe found, or a walk reached. */
   valueAt(index: i32): V {
     if (index < 0 || index >= toI32(this.entryValues.length)) {
-      panic("Map: no entry at this index");
+      panic("Map: no entry at this index")
     }
-    return this.entryValues[index];
+    return this.entryValues[index]
   }
 
   /** Overwrite the value of the entry a probe found; it keeps its place. */
   setValueAt(index: i32, value: V): void {
     if (index >= 0 && index < toI32(this.entryValues.length)) {
-      this.entryValues[index] = value;
+      this.entryValues[index] = value
     }
   }
 
   /** Append an entry for `key` at the empty bucket an absent probe result names, reusing its hash. */
   insertAt(absent: i64, key: K, value: V): void {
-    const packed = -1 - absent;
-    let bucket = toI32(packed >> 32);
-    const h = toU32(packed);
+    const packed = -1 - absent
+    let bucket = toI32(packed >> 32)
+    const h = toU32(packed)
     if (toI32(this.entryKeys.length) >= INDEX_CAP) {
       // Dead entries hold the cap: compact them away, then find the bucket
       // again. A walk defers compaction, so under one the cap is full.
       if (this.live >= INDEX_CAP || this.walks > 0) {
-        panic("Map maximum size exceeded");
+        panic("Map maximum size exceeded")
       }
-      this.rebuild();
-      bucket = -1;
+      this.rebuild()
+      bucket = -1
     }
-    this.entryKeys.push(key);
-    this.entryValues.push(value);
-    this.entryHashes.push(h);
-    this.live = this.live + 1;
-    this.size = this.size + 1;
+    this.entryKeys.push(storedKey(key))
+    this.entryValues.push(value)
+    this.entryHashes.push(h)
+    this.live = this.live + 1
+    this.size = this.size + 1
     // Every entry takes a bucket, live or dead, until a rebuild, which files
     // the new entry with the rest; otherwise it takes the bucket the probe found.
-    const used = toI32(this.entryKeys.length);
+    const used = toI32(this.entryKeys.length)
     if (used * 4 > toI32(this.slots.length) * 3) {
-      this.rebuild();
+      this.rebuild()
     } else {
-      fileAppended(this.slots, this.mask, bucket, h, used);
+      fileAppended(this.slots, this.mask, bucket, h, used)
     }
   }
 
@@ -415,17 +421,44 @@ export class Map<K, V> {
    * first rebuild after the walk compacts (§6.2).
    */
   rebuild(): void {
-    const used = toI32(this.entryKeys.length);
-    const walking = this.walks > 0;
-    const slots = rebuiltSlots(this.slots, walking ? used : this.live, used);
+    const used = toI32(this.entryKeys.length)
+    const walking = this.walks > 0
+    const slots = rebuiltSlots(this.slots, walking ? used : this.live, used)
     if (!walking && this.live < used) {
-      compactEntries(this.entryKeys, this.entryHashes);
-      compactEntries(this.entryValues, this.entryHashes);
-      compactHashes(this.entryHashes);
+      compactEntries(this.entryKeys, this.entryHashes)
+      compactEntries(this.entryValues, this.entryHashes)
+      compactHashes(this.entryHashes)
+    }
+    this.slots = slots
+    this.mask = toI32(slots.length) - 1
+    refile(slots, this.entryHashes)
+  }
+
+  /**
+   * `reserve(m, n)` from `nish/map` (docs/wp32-map.md §9.2): grow the bucket
+   * table until `n` entries, dead ones included, fit under the load bound, so
+   * that the inserts up to `n` rebuild nothing. It only ever grows the buckets
+   * and re-files them from the stored hashes, so no entry moves and it is as
+   * safe under a walk as the doubling a walk already allows (§6.2). A count
+   * that is not positive, or not a number, does nothing, as `reserve` does
+   * under Node; one past the entry cap is the cap.
+   */
+  reserveSlots(n: number): void {
+    if (!(n > 0)) {
+      return
+    }
+    const want: i32 = n >= 16777215 ? INDEX_CAP : toI32(n)
+    const have = toI32(this.slots.length)
+    let size = have
+    while (want * 4 > size * 3) {
+      size = size * 2
+    }
+    if (size > have) {
+      const slots = new Array<u32>(size)
+      this.slots = slots
+      this.mask = size - 1
+      refile(slots, this.entryHashes)
     }
-    this.slots = slots;
-    this.mask = toI32(slots.length) - 1;
-    refile(slots, this.entryHashes);
   }
 }
 
@@ -433,116 +466,126 @@ export class Map<K, V> {
 // biome-ignore lint/suspicious/noShadowRestrictedNames: this is the global `Set`, which the compiler loads for a program that names it
 export class Set<T> {
   /** How many elements are live. The one field a program may read, and it may not write it. */
-  size: number = 0;
-  slots: u32[];
-  mask: i32 = 7;
-  live: i32 = 0;
-  entryKeys: T[];
-  entryHashes: u32[];
+  size: number = 0
+  slots: u32[]
+  mask: i32 = 7
+  live: i32 = 0
+  entryKeys: T[]
+  entryHashes: u32[]
   /** `Map`'s walk count: how many `for...of` loops are walking the table now. */
-  walks: i32 = 0;
+  walks: i32 = 0
 
   constructor() {
-    this.slots = new Array<u32>(INITIAL_SLOTS);
-    this.entryKeys = [];
-    this.entryHashes = [];
+    this.slots = new Array<u32>(INITIAL_SLOTS)
+    this.entryKeys = []
+    this.entryHashes = []
   }
 
   probe(key: T): i64 {
-    return probeTable(this.slots, this.mask, this.entryHashes, this.entryKeys, key);
+    return probeTable(this.slots, this.mask, this.entryHashes, this.entryKeys, key)
   }
 
   has(key: T): boolean {
-    return this.probe(key) >= 0;
+    return this.probe(key) >= 0
   }
 
   /** Add `key` at the end when it is not there already: one probe. */
   add(key: T): Set<T> {
-    const found = this.probe(key);
+    const found = this.probe(key)
     if (found < 0) {
-      this.insertAt(found, key);
+      this.insertAt(found, key)
     }
-    return this;
+    return this
   }
 
   delete(key: T): boolean {
-    const found = this.probe(key);
+    const found = this.probe(key)
     if (found < 0) {
-      return false;
+      return false
     }
-    killEntry(this.slots, this.entryHashes, found);
-    this.live = this.live - 1;
-    this.size = this.size - 1;
-    return true;
+    killEntry(this.slots, this.entryHashes, found)
+    this.live = this.live - 1
+    this.size = this.size - 1
+    return true
   }
 
   clear(): void {
-    clearSlots(this.slots);
+    clearSlots(this.slots)
     if (this.walks > 0) {
-      clearSlots(this.entryHashes); // every entry dead, and the count kept
+      clearSlots(this.entryHashes) // every entry dead, and the count kept
     } else {
-      truncate(this.entryKeys);
-      truncate(this.entryHashes);
+      truncate(this.entryKeys)
+      truncate(this.entryHashes)
     }
-    this.live = 0;
-    this.size = 0;
+    this.live = 0
+    this.size = 0
   }
 
   /** `Map`'s walk: `for (const x of s)`, `s.keys()` and `s.values()` are all this one. */
   walkOpen(): void {
-    this.walks = this.walks + 1;
+    this.walks = this.walks + 1
   }
 
   walkNext(from: i32): i32 {
-    return nextLive(this.entryHashes, from);
+    return nextLive(this.entryHashes, from)
   }
 
   walkClose(): void {
-    this.walks = this.walks - 1;
+    this.walks = this.walks - 1
   }
 
   keyAt(index: i32): T {
     if (index < 0 || index >= toI32(this.entryKeys.length)) {
-      panic("Set: no entry at this index");
+      panic("Set: no entry at this index")
     }
-    return this.entryKeys[index];
+    return this.entryKeys[index]
   }
 
   insertAt(absent: i64, key: T): void {
-    const packed = -1 - absent;
-    let bucket = toI32(packed >> 32);
-    const h = toU32(packed);
+    const packed = -1 - absent
+    let bucket = toI32(packed >> 32)
+    const h = toU32(packed)
     if (toI32(this.entryKeys.length) >= INDEX_CAP) {
       if (this.live >= INDEX_CAP || this.walks > 0) {
-        panic("Set maximum size exceeded");
+        panic("Set maximum size exceeded")
       }
-      this.rebuild();
-      bucket = -1;
+      this.rebuild()
+      bucket = -1
     }
-    this.entryKeys.push(key);
-    this.entryHashes.push(h);
-    this.live = this.live + 1;
-    this.size = this.size + 1;
+    this.entryKeys.push(storedKey(key))
+    this.entryHashes.push(h)
+    this.live = this.live + 1
+    this.size = this.size + 1
     // Every entry takes a bucket, live or dead, until a rebuild, which files
     // the new entry with the rest; otherwise it takes the bucket the probe found.
-    const used = toI32(this.entryKeys.length);
+    const used = toI32(this.entryKeys.length)
     if (used * 4 > toI32(this.slots.length) * 3) {
-      this.rebuild();
+      this.rebuild()
     } else {
-      fileAppended(this.slots, this.mask, bucket, h, used);
+      fileAppended(this.slots, this.mask, bucket, h, used)
     }
   }
 
   rebuild(): void {
-    const used = toI32(this.entryKeys.length);
-    const walking = this.walks > 0;
-    const slots = rebuiltSlots(this.slots, walking ? used : this.live, used);
+    const used = toI32(this.entryKeys.length)
+    const walking = this.walks > 0
+    const slots = rebuiltSlots(this.slots, walking ? used : this.live, used)
     if (!walking && this.live < used) {
-      compactEntries(this.entryKeys, this.entryHashes);
-      compactHashes(this.entryHashes);
+      compactEntries(this.entryKeys, this.entryHashes)
+      compactHashes(this.entryHashes)
     }
-    this.slots = slots;
-    this.mask = toI32(slots.length) - 1;
-    refile(slots, this.entryHashes);
+    this.slots = slots
+    this.mask = toI32(slots.length) - 1
+    refile(slots, this.entryHashes)
   }
 }
+
+/**
+ * The key as an entry stores it: a float's -0 becomes +0, as ECMA-262's
+ * `Map.prototype.set` and `Set.prototype.add` store it, so a walk over the
+ * keys yields +0 whichever zero was inserted. Lowered in place, like `hashKey`
+ * and `sameKey`: `fadd` of +0 for a float, and nothing at all for every other
+ * key. It sits last in the file so that adding it moved no line a `-g` build
+ * of an earlier function records.
+ */
+const storedKey = <K>(key: K): K => key