remove HTTP builders; minor tweaks in other modules

`http.mjs`:

* Dropped `HttpBui`.
* Dropped `ReqBui`.
* Dropped `ResBui`.
* Dropped `ReqRou..method` in favor of `ReqRou..req.method`.
* Dropped `ReqRou..signal` in favor of `ReqRou..req.signal`.
* Renamed `ReqRou..meth` → `ReqRou..method` and `ReqRou..someMeth` →
  `ReqRou..someMethod` for consistency with the `fetch` / `Request` API.
* Renamed `HttpErr` → `ErrHttp`.
* Renamed all constants.
* Added various constants.
* Added `resOk`.
* When `Cookie..install` invokes the `document.cookie` setter, it passes a
  string rather than an object. This avoids exceptions in badly programmed
  scripts that monkeypatch the `document.cookie` setter with their own buggy
  implementation.

Motivation for dropping request and response builders: the implementation
had forward compatibility problems and caused edge case breakages in some
browsers, and any alternative design has ergonomic problems. As a result,
the abstraction is not worth it.

`coll.mjs`:

* Methods `.added` in various collection classes now return a boolean
  indicating whether the entry was newly added or had already existed.
  Sets detect this by value. Maps detect this by key.
* Dropped `Bset..addedOpt`.
* Dropped `ClsVec..added`.

`test.mjs`:

* `no` is also exported as `false`.
* `ok` is also exported as `true`.

Author: mitranim

coll.mjs

@@ -22,8 +22,7 @@ export class Bset extends Set {
     return this
   }
 
-  added(val) {return this.add(val), val}
-  addedOpt(val) {return this.addOpt(val), val}
+  added(val) {return !this.has(val) && (this.add(val), true)}
   reset(src) {return this.clear(), this.mut(src)}
   clear() {return (super.size && super.clear()), this}
   clone() {return new this.constructor(this)}
@@ -143,7 +142,14 @@ export class Coll extends TypedMap {
   reqVal(val) {return val}
   add(val) {return this.set(this.getKey(val), val)}
   addOpt(val) {return this.setOpt(this.getKeyOpt(val), val)}
-  added(val) {return this.add(val), val}
+
+  added(val) {
+    const key = this.getKey(val)
+    const got = this.has(key)
+    this.set(key, val)
+    return got
+  }
+
   toArray() {return [...this.values()]}
   toJSON() {return this.toArray()}
   [Symbol.iterator]() {return this.values()}
@@ -152,9 +158,9 @@ export class Coll extends TypedMap {
 export class ClsColl extends Coll {
   get cls() {return Object}
   reqVal(val) {return l.reqInst(val, this.cls)}
-  add(val) {return super.add(this.make(val))}
+  add(val) {return (val = this.make(val)), this.set(this.getKey(val), val)}
   addOpt(val) {return l.isSome(val) ? super.addOpt(this.make(val)) : this}
-  added(val) {return this.add((val = this.make(val))), val}
+  added(val) {return super.added(this.make(val))}
   make(val) {return l.toInst(val, this.cls)}
 }
 
@@ -217,7 +223,6 @@ export class ClsVec extends TypedVec {
   constructor(src) {super().mut(src)}
   reqVal(val) {return l.reqInst(val, this.cls)}
   add(val) {return super.add(this.make(val))}
-  added(val) {return this.add((val = this.make(val))), val}
   make(val) {return l.toInst(val, this.cls)}
 }
 

doc/cmd_doc.mjs

@@ -20,7 +20,6 @@ const FEATS = [
   [`coll`, `extended versions of JS data structure classes, with better APIs.`],
   [`url`, `better URL implementation.`],
   [`time`, `tools for datetimes and intervals.`],
-  [`http`, `shortcuts for the native fetch/Request/Response APIs.`],
   [`path`, `various functions for working with FS paths.`],
   [`dom`, `shortcuts for working with the DOM.`],
   [`dom_shim`, `lightweight and performant shim for DOM nodes and elements.`],
@@ -30,6 +29,10 @@ const FEATS = [
   [`prax`, `simple system for rendering DOM elements. React-inspired syntax, better semantics and performance.`],
   [`obs`, `observables via proxies.`],
   [`obs_dom`, `automatic reactivity for custom DOM elements.`],
+  [`http`, `shortcuts for the fetch/Response APIs, URL routing, cookie decoding/encoding.`],
+  [`http_deno`, `tools for HTTP servers running in Deno.`],
+  [`http_srv`, `streaming and broadcasting tools for generic HTTP servers.`],
+  [`live_deno`, `tools for live-reloading in development.`],
   [`cli`, `essential tools for CLI apps.`],
   [`test`, `tools for testing and benchmarking.`],
 ]

doc/http/_HttpErr.md doc/http/_ErrHttp.mddoc/http/_HttpErr.md renamed to doc/http/_ErrHttp.md

@@ -1,7 +1,7 @@
 Subclass of `Error` for HTTP responses. The error message includes the HTTP status code, if any.
 
 ```ts
-class HttpErr extends Error {
+class ErrHttp extends Error {
   message: string
   status: int
   res?: Response

doc/http/_ReqBui.md

@@ -0,0 +1,12 @@
+Signature: `(res: Response | Promise<Response>) => Promise<Response>`.
+
+Missing feature of the [fetch API](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API). If the response is OK (HTTP code between 200 and 299, `.ok === true`), the resulting promise resolves to that response as-is. Otherwise the resulting promise is rejected with a descriptive {{link http ErrHttp}} which includes the response status code, the response body (if any) as the error message, and the response itself for introspection if needed.
+
+```js
+import * as h from '{{featUrl http}}'
+
+// If response is unsuccessful, this will throw `h.ErrHttp`.
+const res = await h.resOk(await fetch(someUrl, someOpt))
+
+const body = res.json()
+```

doc/http/_ReqRou.md

@@ -0,0 +1,43 @@
+## Overview
+
+{{codeHead}} provides essential tools for HTTP servers running in [Deno](https://deno.land).
+
+* Tools for serving files (with content type detection) and directories (with optional file filtering / whitelisting / blacklisting).
+* Tools for simple HTML file servers, with automatic matching of "clean" URL paths such as `/` and `/posts` to HTML files such as `index.html` and `posts.html`.
+
+Also see {{featLink http}} for routing and cookies, and {{featLink live_deno}} for live-reload tools for development.
+
+## TOC
+
+* [#Usage](#usage)
+* [#API](#api)
+* [#Misc](#misc)
+{{toc}}
+
+## Usage
+
+Simple example of a server that serves files from the current directory, automatically matching URL paths to HTML files:
+
+```js
+import * as hd from '{{featUrl http_deno}}'
+
+const srv = new class Srv extends hd.Srv {
+  // Serves files from the current folder, with no filtering.
+  dirs = hd.Dirs.of(hd.dirRel(`.`))
+
+  async res(req) {
+    const rou = new h.ReqRou(req)
+
+    return (
+      (await this.dirs.resolveSiteFileWithNotFound(req.url))?.res() ||
+      rou.notFound()
+    )
+  }
+}()
+
+await srv.listen({port: somePort})
+```
+
+## API
+
+{{api}}

doc/http/_Res.md

@@ -1,17 +1,12 @@
 ## Overview
 
-{{codeHead}} provides tiny syntactic shortcuts for native `Request`/`Response`/`Headers`/`fetch`.
+{{codeHead}} provides essential tools for HTTP servers and clients:
 
-* Fluent builder-style API.
-* Interoperable with built-ins.
-* Shortcuts for common actions, such as:
-  * Building HTTP requests via {{link http ReqBui}}.
-    * A builder-style API is more concise and flexible than the native one.
-  * Handling HTTP errors in responses via {{link http Res}}.
-    * Constructing descriptive exceptions with HTTP status and response text.
-  * Routing incoming HTTP requests via {{link http Rou}}.
+* Shortcuts for making requests via native `fetch`.
+* Cookie decoding and encoding.
+* URL-based routing for SSR and SPA apps.
 
-HTTP request/response utils are ported and reworked from https://github.com/mitranim/xhttp. Routing utils are ported and reworked from https://github.com/mitranim/imperouter.
+Also see {{featLink http_deno}} for Deno HTTP servers, {{featLink http_srv}} for generic tools for HTTP servers using native stream APIs, and {{featLink live_deno}} for live-reload tools for development.
 
 ## TOC
 
@@ -32,9 +27,3 @@ const resBody = await h.reqBui().to(`/api`).post().json(reqBody).fetchOkJson()
 ## API
 
 {{api}}
-
-## Misc
-
-`Req..headers` is a null-prototype dict, rather than `Headers`, for performance and compatibility reasons. In Deno, many operations involving `Headers` are stupidly slow. Using plain dicts for headers seems to performs better, and is automatically compatible with object rest/spread and `Object.assign`.
-
-Each header is stored as a single string. When appending, values are joined with `, `. This matches the limitations of the `Headers` and `fetch` APIs, which don't seem to support multiple occurrences of the same header.