ported some more small stuff on my way to websock

src/common/async/aborts.js

···
 
 /**
  * Create an abort signal tied to a timeout.
- * Replaces `AbortSignal.timeout`, which doesn't consistently abort with a TimeoutError cross env.
+ * Replaces `AbortSignal.timeout`, which doesn't consistently abort with a `TimeoutError` cross env.
  *
  * @param   {number} ms - timeout in milliseconds
  * @returns {TimeoutSignal} the timeout signal

src/common/async/sleep.js

···
+/** @module common/async */
+
+/**
+ * @param {number} ms the number of ms to sleep
+ * @param {AbortSignal} [signal] an aptional abort signal, to cancel the sleep
+ * @returns {Promise<void>}
+ * a promise that resolves after given amount of time, and is interruptable with an abort signal.
+ */
+export function sleep(ms, signal) {
+  signal?.throwIfAborted()
+
+  const { resolve, reject, promise } = Promise.withResolvers()
+  const timeout = setTimeout(resolve, ms)
+
+  if (signal) {
+    const abortHandler = () => {
+      clearTimeout(timeout)
+      reject(signal.reason)
+    }
+
+    signal.addEventListener('abort', abortHandler)
+    promise.finally(() => {
+      signal.removeEventListener('abort', abortHandler)
+    })
+  }
+
+  return promise
+}

src/common/strict-map.js

···
+/** @module common */
+
+/**
+ * A map with methods to ensure key presence and safe update.
+ *
+ * @template K, V
+ * @augments {Map<K, V>}
+ */
+export class StrictMap extends Map {
+
+  /**
+   * @param {K} key to lookup in the map, throwing is missing
+   * @returns {V} the value from the map
+   * @throws {Error} if the key is not present in the map
+   */
+  require(key) {
+    if (!this.has(key)) throw Error(`key is required but not in the map`)
+
+    const value = /** @type {V} */ (this.get(key))
+    return value
+  }
+
+  /**
+   * @param {K} key to lookup in the map
+   * @param {function(): V} maker a callback which will create the value in the map if not present.
+   * @returns {V} the value from the map, possibly newly created by {maker}
+   */
+  ensure(key, maker) {
+    if (!this.has(key)) {
+      this.set(key, maker())
+    }
+
+    return /** @type {V} */ (this.get(key))
+  }
+
+  /**
+   * @param {K} key to update in the map
+   * @param {function(V=): V} update function which returns the new value for the map
+   */
+  update(key, update) {
+    const current = this.get(key)
+    this.set(key, update(current))
+  }
+
+}