visaljs 0.0.7 → 0.0.9

package/node/src/host_http.c

@@ -1,4 +1,4 @@
-/* Host primitives for node:http (ADR 0012, host prelude): llhttp (Node's parser) on node:net's
+/* Host primitives for node:http: llhttp (Node's parser) on node:net's
  * sockets, for a server's requests and a client's responses. As in Node, a connection is a
  * net.Socket, but its bytes go to the parser in C, not through JS: host_net.c's hook hands them
  * over. The prelude's http.js builds Node's objects from what the parser finds; C does the
@@ -22,6 +22,12 @@
  *                              writes goes out in one write when it (and its microtasks) returns
  *   httpFlush(conn)            sends the corked output now (before the socket is ended)
  *   httpDate() → the Date header's value
+ * A socket whose bytes aren't its handle's (a TLS socket's are decrypted in JS, a Duplex has no
+ * handle) is a fed connection, with a negative id: JS gives its parser the bytes, and its output
+ * goes to a JS writer (which the TLS socket encrypts).
+ *   httpFedOpen(writer) → conn     writer(bytes) gets what the connection's output flushes
+ *   httpFeed(conn, bytes | null) → whether the parser took them (null: the end of the input)
+ *   httpFedClose(conn)             the connection is done with (its socket closed)
  * The loop is host_loop.c's; the sockets are host_net.c's. */
 #define _POSIX_C_SOURCE 200809L  /* libuv's headers: pthread_rwlock_t, struct addrinfo */
 #include <stdio.h>
@@ -44,11 +50,12 @@
 static void flush_pending(void);
 typedef struct Conn Conn;
 static void flush_conn(Conn *c);
+static size_t pending_bytes(Conn *c);
 
 /* ---- Parsers and connections ------------------------------------------------------------- */
 
 typedef struct Parsers {
-    JSValue on_request, on_body, on_complete, on_upgrade, on_error;  /* roots */
+    JSValue on_request, on_body, on_complete, on_upgrade, on_error, on_drain;  /* roots */
 } Parsers;
 
 typedef struct Buf {
@@ -64,9 +71,13 @@ struct Conn {
     bool     detached;   /* upgraded, or a parse error: the parser doesn't read any more */
     bool     executing;  /* llhttp is running on it: it can't be freed yet */
     bool     released;   /* let go of while executing: freed when llhttp returns */
+    bool     detach_after;  /* detached when llhttp is done with the read (httpDetach's afterRead) */
     bool     upgrading;  /* JS took the upgrade the head asked for */
     bool     active;     /* a message is under way (or the connection is new): timeouts count */
     bool     head_done;  /* its head is complete: what follows are its body and trailers */
+    bool     in_message; /* a message has begun and isn't complete: the connection isn't idle */
+    llhttp_errno_t failed;  /* the parse error it stopped at: more bytes report it again, as Node's */
+    bool     need_drain; /* JS waits for its output to drain (a write over the high-water mark) */
     bool     overflow;   /* its head is over max_header bytes */
     uint64_t begin_ms;   /* when the message began (the loop's time) */
     size_t   header_bytes, max_header;
@@ -77,10 +88,18 @@ struct Conn {
     Buf      out;        /* written but not sent: corked, as Node corks a response */
 };
 
+/* A fed connection: its writer, and the parser it has now (a new one per kept-alive request). */
+typedef struct Fed {
+    JSValue writer;  /* a root */
+    Conn   *conn;
+} Fed;
+
 static Parsers **parsers;
 static size_t nparsers;
 static Conn **conns;   /* by net handle id */
 static size_t nconns;
+static Fed **feds;     /* fed connections: id -(k + 1) is feds[k] */
+static size_t nfeds;
 static int *pending;   /* ids of connections with corked output */
 static size_t npending, pending_cap;
 static llhttp_settings_t settings;
@@ -136,6 +155,7 @@ static int on_message_begin(llhttp_t *p) {
     c->headers = js_new_array(ctx_(), 0);
     c->active = true;
     c->head_done = false;
+    c->in_message = true;
     c->header_bytes = 0;
     c->begin_ms = uv_now(js_uv_loop(ctx_()));
     return 0;
@@ -206,21 +226,40 @@ static int on_message_complete(llhttp_t *p) {
     if (c->detached) return -1;  /* let go of by an earlier callback */
     if (c->in_value || c->field.n) push_header(c);  /* the last trailer */
     c->active = false;
+    c->in_message = false;
     JSValue args[2] = { js_int32(c->id), c->headers };
     c->headers = JS_UNDEFINED;
     return js_uv_call(c->parsers->on_complete, 2, args, NULL) ? 0 : -1;
 }
 
-static Conn *conn_of(int id) { return id >= 0 && (size_t)id < nconns ? conns[id] : NULL; }
+static Fed *fed_of(int id) {
+    if (id >= 0) return NULL;
+    size_t k = (size_t)(-(id + 1));
+    return k < nfeds ? feds[k] : NULL;
+}
+
+static Conn *conn_of(int id) {
+    if (id < 0) {
+        Fed *f = fed_of(id);
+        return f ? f->conn : NULL;
+    }
+    return (size_t)id < nconns ? conns[id] : NULL;
+}
 
-static void parse_error(Conn *c, llhttp_errno_t e) {
+/* the parse error, with Node's bytesParsed and rawPacket: how far into the read llhttp got, and
+ * the read (none for a message cut short at the end of the stream) */
+static void parse_error(Conn *c, llhttp_errno_t e, const char *bytes, size_t n) {
     c->detached = true;
+    c->failed = e;
     c->active = false;
     JSContext *ctx = ctx_();
     const char *code = c->overflow ? "HPE_HEADER_OVERFLOW" : llhttp_errno_name(e);
     const char *reason = c->overflow ? "Header overflow" : llhttp_get_error_reason(&c->parser);
-    JSValue args[3] = { js_int32(c->id), js_new_string_cstr(ctx, code), js_new_string_cstr(ctx, reason ? reason : "") };
-    (void)js_uv_call(c->parsers->on_error, 3, args, NULL);
+    const char *pos = bytes ? llhttp_get_error_pos(&c->parser) : NULL;
+    int32_t parsed = pos && pos >= bytes && pos <= bytes + n ? (int32_t)(pos - bytes) : 0;
+    JSValue args[5] = { js_int32(c->id), js_new_string_cstr(ctx, code), js_new_string_cstr(ctx, reason ? reason : ""), js_int32(parsed),
+                        bytes ? bytes_value(ctx, bytes, n) : JS_UNDEFINED };
+    (void)js_uv_call(c->parsers->on_error, 5, args, NULL);
 }
 
 static void free_conn(Conn *c) {
@@ -233,16 +272,45 @@ static void free_conn(Conn *c) {
  * when llhttp returns if a callback let go of it (a client frees its parser in the response's
  * last callback, and starts the next request in a microtask). */
 static void release_conn(Conn *c) {
-    if (conns[c->id] == c) conns[c->id] = NULL;
+    Fed *f = fed_of(c->id);
+    if (f) {
+        if (f->conn == c) f->conn = NULL;
+    } else if (conns[c->id] == c) {
+        conns[c->id] = NULL;
+    }
     c->detached = true;
     if (c->executing) c->released = true;
     else free_conn(c);
 }
 
-/* The socket's bytes, before JS sees them: parsed while attached; EOF and errors go on to JS
- * (the socket's 'end' and 'error'). */
-static bool hook_read(void *data, ssize_t n, const char *bytes) {
-    Conn *c = data;
+/* The socket's bytes go to JS again: the corked output first, then the parser let go of. */
+static void detach_conn(Conn *c) {
+    if (c->queued) flush_conn(c);
+    if (c->id >= 0) js_net_hook(c->id, NULL, NULL);
+    release_conn(c);
+}
+
+/* llhttp is done with a read: a parser let go of meanwhile is freed, or detached if asked to be. */
+static void read_done(Conn *c) {
+    c->executing = false;
+    if (c->released) {
+        free_conn(c);
+    } else if (c->detach_after) {
+        c->detach_after = false;
+        detach_conn(c);
+    }
+}
+
+/* A connection's bytes: parsed while attached; EOF and errors go on to JS (the socket's 'end'
+ * and 'error'). False when the parser doesn't take them. */
+static bool parse_input(Conn *c, ssize_t n, const char *bytes) {
+    if (c->detached && c->failed != HPE_OK && n > 0 && !c->executing) {
+        /* a parser that failed fails again on what follows, with those bytes (Node's execute) */
+        c->executing = true;
+        parse_error(c, c->failed, bytes, (size_t)n);
+        read_done(c);
+        return true;
+    }
     if (c->detached) return false;
     c->executing = true;
     if (n < 0) {
@@ -250,10 +318,9 @@ static bool hook_read(void *data, ssize_t n, const char *bytes) {
             /* a request cut short is the server's parse error; a client's response cut short shows
              * as its 'aborted', when the socket closes (as Node's socketOnEnd ignores finish()) */
             llhttp_errno_t e = llhttp_finish(&c->parser);
-            if (e != HPE_OK && !c->detached && !c->response) parse_error(c, e);
+            if (e != HPE_OK && !c->detached && !c->response) parse_error(c, e, NULL, 0);
         }
-        c->executing = false;
-        if (c->released) free_conn(c);
+        read_done(c);
         return false;
     }
     const char *at = bytes, *end = bytes + n;
@@ -261,7 +328,7 @@ static bool hook_read(void *data, ssize_t n, const char *bytes) {
         llhttp_errno_t e = llhttp_execute(&c->parser, at, (size_t)(end - at));
         if (e == HPE_OK || c->detached) break;  /* released or upgraded by a callback: stop here */
         if (e != HPE_PAUSED_UPGRADE) {
-            parse_error(c, e);  /* nothing runs once a callback failed in JS: the loop is ending */
+            parse_error(c, e, bytes, (size_t)n);  /* nothing runs once a callback failed in JS: the loop is ending */
             break;
         }
         const char *pos = llhttp_get_error_pos(&c->parser);
@@ -276,16 +343,66 @@ static bool hook_read(void *data, ssize_t n, const char *bytes) {
         (void)js_uv_call(c->parsers->on_upgrade, 2, args, NULL);
         break;
     }
-    c->executing = false;
-    if (c->released) free_conn(c);
+    read_done(c);
     return true;
 }
 
+/* A socket's bytes, before JS sees them. */
+/* a socket's read, parsed in C: its callbacks (a body and its end) run before the microtasks and
+ * nextTicks do, as in Node, where one read is one callback scope */
+static bool hook_read(void *data, ssize_t n, const char *bytes) {
+    js_uv_nest(1);
+    bool ok = parse_input(data, n, bytes);
+    js_uv_nest(-1);
+    return js_uv_drain() && ok;
+}
+
 static void hook_close(void *data) { release_conn(data); }
 
 static const JSNetHook http_hook = { hook_read, hook_close };
 
-/* httpParsers(onHead, onBody, onComplete, onUpgrade, onError) → id */
+/* ---- An idle client socket's guard --------------------------------------------------------- */
+
+/* Bytes a socket reads while it waits in an agent's pool (no request on it): a server sending what
+ * nobody asked for, which the next request would take for its response. Node's free socket data
+ * guard: the bytes are dropped and JS destroys the socket. Its end and errors go on to JS. */
+static JSValue guard_callback = JS_UNDEFINED;
+static bool guard_rooted;
+
+static bool guard_read(void *data, ssize_t n, const char *bytes) {
+    (void)bytes;
+    if (n <= 0) return false;
+    int id = (int)(intptr_t)data;
+    js_net_hook(id, NULL, NULL);
+    if (js_is_callable(guard_callback)) {
+        JSValue arg = js_int32(id);
+        js_uv_nest(1);
+        (void)js_uv_call(guard_callback, 1, &arg, NULL);
+        js_uv_nest(-1);
+        (void)js_uv_drain();
+    }
+    return true;
+}
+
+static void guard_close(void *data) { (void)data; }
+
+static const JSNetHook guard_hook = { guard_read, guard_close };
+
+/* httpGuard(conn, onData) → whether it's guarded: onData(conn) when the socket reads while idle */
+JSValue js_host_http_guard(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target) {
+    (void)callee, (void)this_val, (void)new_target;
+    if (argc < 2 || !js_is_int32(argv[0])) return JS_FALSE;
+    int id = js_as_int32(argv[0]);
+    if (id < 0 || ((size_t)id < nconns && conns[id])) return JS_FALSE;  /* a parser has it */
+    if (!guard_rooted) {
+        js_add_root(ctx->rt, &guard_callback);
+        guard_rooted = true;
+    }
+    guard_callback = argv[1];
+    return js_bool(js_net_hook(id, &guard_hook, (void *)(intptr_t)id));
+}
+
+/* httpParsers(onHead, onBody, onComplete, onUpgrade, onError, onDrain) → id */
 JSValue js_host_http_parsers(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target) {
     (void)callee, (void)this_val, (void)new_target;
     if (argc < 5) return js_throw_type_error(ctx, "httpParsers: 5 arguments expected");
@@ -305,8 +422,9 @@ JSValue js_host_http_parsers(JSContext *ctx, JSValue callee, JSValue this_val, u
     Parsers *p = malloc(sizeof *p);
     if (!p) js_fatal("out of memory in http");
     p->on_request = argv[0], p->on_body = argv[1], p->on_complete = argv[2], p->on_upgrade = argv[3], p->on_error = argv[4];
+    p->on_drain = argc > 5 ? argv[5] : JS_UNDEFINED;
     js_add_root(ctx->rt, &p->on_request), js_add_root(ctx->rt, &p->on_body), js_add_root(ctx->rt, &p->on_complete);
-    js_add_root(ctx->rt, &p->on_upgrade), js_add_root(ctx->rt, &p->on_error);
+    js_add_root(ctx->rt, &p->on_upgrade), js_add_root(ctx->rt, &p->on_error), js_add_root(ctx->rt, &p->on_drain);
     Parsers **v = realloc(parsers, (nparsers + 1) * sizeof *v);
     if (!v) js_fatal("out of memory in http");
     parsers = v;
@@ -320,8 +438,11 @@ JSValue js_host_http_attach(JSContext *ctx, JSValue callee, JSValue this_val, ui
     if (argc < 2 || !js_is_int32(argv[0]) || !js_is_int32(argv[1])) return js_throw_type_error(ctx, "httpAttach: (conn, parsers) expected");
     int id = js_as_int32(argv[0]);
     int32_t pi = js_as_int32(argv[1]);
-    if (pi < 0 || (size_t)pi >= nparsers || !js_net_stream(id)) return js_int32(UV_EBADF);
-    if ((size_t)id >= nconns) {
+    Fed *f = fed_of(id);
+    if (pi < 0 || (size_t)pi >= nparsers || (id < 0 ? !f : !js_net_stream(id))) return js_int32(UV_EBADF);
+    if (f) {
+        if (f->conn) release_conn(f->conn);
+    } else if ((size_t)id >= nconns) {
         size_t n = nconns ? nconns : 64;
         while (n <= (size_t)id) n *= 2;
         Conn **v = realloc(conns, n * sizeof *v);
@@ -330,7 +451,7 @@ JSValue js_host_http_attach(JSContext *ctx, JSValue callee, JSValue this_val, ui
         conns = v;
         nconns = n;
     }
-    if (conns[id]) release_conn(conns[id]);  /* a kept-alive socket's next request: a fresh parser */
+    if (!f && conns[id]) release_conn(conns[id]);  /* a kept-alive socket's next request: a fresh parser */
     Conn *c = calloc(1, sizeof *c);
     if (!c) js_fatal("out of memory in http");
     c->id = id;
@@ -343,23 +464,52 @@ JSValue js_host_http_attach(JSContext *ctx, JSValue callee, JSValue this_val, ui
     js_add_root(ctx->rt, &c->headers);
     llhttp_init(&c->parser, c->response ? HTTP_RESPONSE : HTTP_REQUEST, &settings);
     c->parser.data = c;
-    conns[id] = c;
-    js_net_hook(id, &http_hook, c);
+    if (f) {
+        f->conn = c;  /* its bytes come from httpFeed */
+    } else {
+        conns[id] = c;
+        js_net_hook(id, &http_hook, c);
+    }
     return js_int32(0);
 }
 
-/* httpDetach(conn): the socket's bytes go to JS again (its corked output goes first) */
+/* httpDetach(conn, afterRead): the socket's bytes go to JS again (its corked output goes first);
+ * with afterRead, from a parser callback, once llhttp is done with the read, as Node's client frees
+ * its parser after the read (what follows a response in it is still parsed) */
 JSValue js_host_http_detach(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target) {
     (void)ctx, (void)callee, (void)this_val, (void)new_target;
     Conn *c = argc > 0 && js_is_int32(argv[0]) ? conn_of(js_as_int32(argv[0])) : NULL;
-    if (c) {
-        if (c->queued) flush_conn(c);
-        js_net_hook(c->id, NULL, NULL);
-        release_conn(c);
-    }
+    if (!c) return JS_UNDEFINED;
+    if (argc > 1 && js_truthy(argv[1]) && c->executing) c->detach_after = true;
+    else detach_conn(c);
     return JS_UNDEFINED;
 }
 
+/* httpBusy(conn): whether a message is under way on the connection (begun, not complete), as Node's
+ * ConnectionsList tells an idle connection from an active one */
+JSValue js_host_http_busy(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target) {
+    (void)ctx, (void)callee, (void)this_val, (void)new_target;
+    Conn *c = argc > 0 && js_is_int32(argv[0]) ? conn_of(js_as_int32(argv[0])) : NULL;
+    return js_bool(c && c->in_message && !c->detached);
+}
+
+/* httpPending(conn) → the bytes written to it that haven't gone out yet (a response's backpressure) */
+JSValue js_host_http_pending(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target) {
+    (void)ctx, (void)callee, (void)this_val, (void)new_target;
+    Conn *c = argc > 0 && js_is_int32(argv[0]) ? conn_of(js_as_int32(argv[0])) : NULL;
+    return js_number(c ? (double)pending_bytes(c) : 0);
+}
+
+/* httpWatchDrain(conn) → true when nothing is pending (drained already), else the parsers' onDrain
+ * is called once it all has gone out */
+JSValue js_host_http_watch_drain(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target) {
+    (void)ctx, (void)callee, (void)this_val, (void)new_target;
+    Conn *c = argc > 0 && js_is_int32(argv[0]) ? conn_of(js_as_int32(argv[0])) : NULL;
+    if (!c || pending_bytes(c) == 0) return JS_TRUE;
+    c->need_drain = true;
+    return JS_FALSE;
+}
+
 /* httpExpired(parsers, headersTimeout, requestTimeout) → the connections over time, as Node's
  * ConnectionsList::Expired: a head not complete within headersTimeout, or a request not
  * complete within requestTimeout, from its start (or the connection's); 0 turns one off */
@@ -372,8 +522,8 @@ JSValue js_host_http_expired(JSContext *ctx, JSValue callee, JSValue this_val, u
     JSValue list = js_new_array(ctx, 0);
     if (pi < 0 || (size_t)pi >= nparsers) return list;
     uint64_t now = uv_now(js_uv_loop(ctx));
-    for (size_t i = 0; i < nconns; i++) {
-        Conn *c = conns[i];
+    for (size_t i = 0; i < nconns + nfeds; i++) {
+        Conn *c = i < nconns ? conns[i] : feds[i - nconns] ? feds[i - nconns]->conn : NULL;
         if (!c || c->parsers != parsers[pi] || !c->active || c->detached) continue;
         uint64_t age = now - c->begin_ms;
         if ((!c->head_done && headers_timeout > 0 && (double)age > headers_timeout) || (request_timeout > 0 && (double)age > request_timeout)) {
@@ -389,18 +539,44 @@ JSValue js_host_http_expired(JSContext *ctx, JSValue callee, JSValue this_val, u
 typedef struct WriteReq {
     uv_write_t req;
     char      *data;
+    int        id;  /* the connection's: whether its output has drained, once written */
 } WriteReq;
 
+/* bytes written to the connection but not yet sent: corked, or in libuv's write queue */
+static size_t pending_bytes(Conn *c) {
+    uv_stream_t *s = c->id >= 0 ? js_net_stream(c->id) : NULL;
+    return c->out.n + (s ? uv_stream_get_write_queue_size(s) : 0);
+}
+
 static void on_written(uv_write_t *req, int status) {
     (void)status;  /* a failed write shows as the socket's read error, or its close */
     WriteReq *w = (WriteReq *)req;
+    int id = w->id;
     free(w->data);
     free(w);
+    /* JS waited for the output to drain (Node's 'drain' on the response) */
+    Conn *c = conn_of(id);
+    if (c && c->need_drain && pending_bytes(c) == 0) {
+        c->need_drain = false;
+        if (js_is_callable(c->parsers->on_drain)) {
+            JSValue arg = js_int32(id);
+            (void)js_uv_call(c->parsers->on_drain, 1, &arg, NULL);
+        }
+    }
 }
 
 /* Sends a connection's corked output as one write. */
 static void flush_conn(Conn *c) {
     c->queued = false;
+    Fed *f = fed_of(c->id);
+    if (f) {  /* to its writer: the connection may be gone when it returns */
+        if (c->out.n == 0) return;
+        JSValue bytes = bytes_value(ctx_(), c->out.v, c->out.n);
+        c->out.n = 0;
+        JSValue writer = f->writer;
+        (void)js_uv_call(writer, 1, &bytes, NULL);
+        return;
+    }
     uv_stream_t *s = js_net_stream(c->id);
     if (!s || c->out.n == 0) {
         c->out.n = 0;
@@ -409,6 +585,7 @@ static void flush_conn(Conn *c) {
     WriteReq *w = malloc(sizeof *w);
     if (!w) js_fatal("out of memory in http");
     w->data = c->out.v;  /* the buffer goes with the write; the connection starts a new one */
+    w->id = c->id;
     uv_buf_t b = uv_buf_init(c->out.v, (unsigned)c->out.n);
     c->out = (Buf){ 0 };
     if (uv_write(&w->req, s, &b, 1, on_written) < 0) {
@@ -417,20 +594,35 @@ static void flush_conn(Conn *c) {
     }
 }
 
+/* Taken over before it runs: a fed connection's writer runs JS, which may write (and flush) more. */
 static void flush_pending(void) {
-    for (size_t i = 0; i < npending; i++) {
-        Conn *c = conn_of(pending[i]);
-        if (c && c->queued) flush_conn(c);
+    while (npending > 0) {
+        int *ids = pending;
+        size_t n = npending;
+        pending = NULL;
+        npending = pending_cap = 0;
+        for (size_t i = 0; i < n; i++) {
+            Conn *c = conn_of(ids[i]);
+            if (c && c->queued) flush_conn(c);
+        }
+        free(ids);
     }
-    npending = 0;
 }
 
-/* httpWrite(conn, data): corked until the current callback (and its microtasks) returns */
+/* httpWrite(conn, data, latin1): corked until the current callback (and its microtasks) returns; a
+ * string as UTF-8, or with latin1 a byte a character (its low byte), as Node writes a head */
 JSValue js_host_http_write(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target) {
     (void)callee, (void)this_val, (void)new_target;
     Conn *c = argc > 0 && js_is_int32(argv[0]) ? conn_of(js_as_int32(argv[0])) : NULL;
-    if (!c || argc < 2 || !js_net_stream(c->id)) return JS_FALSE;
-    if (js_is_string(argv[1])) {
+    if (!c || argc < 2 || (c->id >= 0 && !js_net_stream(c->id))) return JS_FALSE;
+    if (js_is_string(argv[1]) && argc > 2 && js_truthy(argv[2])) {
+        JSStrView v = js_string_view(ctx, argv[1]);
+        if (v.length == 0) return JS_TRUE;
+        buf_reserve(&c->out, v.length);
+        if (v.latin1) memcpy(c->out.v + c->out.n, v.chars, v.length);
+        else for (uint32_t i = 0; i < v.length; i++) c->out.v[c->out.n + i] = (char)(js_view_at(v, i) & 0xff);
+        c->out.n += v.length;
+    } else if (js_is_string(argv[1])) {
         JSStrView v = js_string_view(ctx, argv[1]);
         size_t n = js_view_to_utf8(v, NULL, 0);
         if (n == 0) return JS_TRUE;
@@ -465,6 +657,67 @@ JSValue js_host_http_flush(JSContext *ctx, JSValue callee, JSValue this_val, uin
     return JS_UNDEFINED;
 }
 
+/* ---- Fed connections --------------------------------------------------------------------- */
+
+/* httpFedOpen(writer) → conn: a connection whose bytes JS feeds */
+JSValue js_host_http_fed_open(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target) {
+    (void)callee, (void)this_val, (void)new_target;
+    if (argc < 1 || !js_is_callable(argv[0])) return js_throw_type_error(ctx, "httpFedOpen: a writer expected");
+    size_t k = 0;
+    while (k < nfeds && feds[k]) k++;
+    if (k == nfeds) {
+        size_t n = nfeds ? nfeds * 2 : 16;
+        Fed **v = realloc(feds, n * sizeof *v);
+        if (!v) js_fatal("out of memory in http");
+        memset(v + nfeds, 0, (n - nfeds) * sizeof *v);
+        feds = v;
+        nfeds = n;
+    }
+    Fed *f = calloc(1, sizeof *f);  /* by itself: its writer is a root at a fixed address */
+    if (!f) js_fatal("out of memory in http");
+    f->writer = argv[0];
+    js_add_root(ctx->rt, &f->writer);
+    feds[k] = f;
+    return js_int32(-(int32_t)k - 1);
+}
+
+/* httpFeed(conn, bytes | null) → whether the parser took them; null: the input ended */
+JSValue js_host_http_feed(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target) {
+    (void)callee, (void)this_val, (void)new_target;
+    /* a fed connection's bytes; or a socket's that JS read before the parser took the socket */
+    Conn *c = argc > 0 && js_is_int32(argv[0]) ? conn_of(js_as_int32(argv[0])) : NULL;
+    if (!c) return JS_FALSE;
+    /* called from JS: the parser's callbacks run in it, so no microtask or nextTick runs between
+     * two of them (a body and its end come in the same turn, as in Node) */
+    if (argc < 2 || js_is_null(argv[1]) || js_is_undefined(argv[1])) {
+        js_uv_nest(1);
+        bool ok = parse_input(c, UV_EOF, NULL);
+        js_uv_nest(-1);
+        return js_bool(ok);
+    }
+    uint8_t *bytes;
+    size_t n;
+    if (!js_buffer_source_bytes(argv[1], &bytes, &n)) return js_throw_type_error(ctx, "httpFeed: bytes expected");
+    if (n == 0) return JS_TRUE;
+    js_uv_nest(1);
+    bool ok = parse_input(c, (ssize_t)n, (const char *)bytes);
+    js_uv_nest(-1);
+    return js_bool(ok);
+}
+
+/* httpFedClose(conn): its parser and writer go */
+JSValue js_host_http_fed_close(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target) {
+    (void)callee, (void)this_val, (void)new_target;
+    int id = argc > 0 && js_is_int32(argv[0]) ? js_as_int32(argv[0]) : 0;
+    Fed *f = fed_of(id);
+    if (!f) return JS_UNDEFINED;
+    if (f->conn) release_conn(f->conn);
+    feds[-(id + 1)] = NULL;
+    js_remove_root(ctx->rt, &f->writer);
+    free(f);
+    return JS_UNDEFINED;
+}
+
 /* httpDate(): the Date header's value, IMF-fixdate, formatted once per second (as Node caches it) */
 JSValue js_host_http_date(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target) {
     (void)callee, (void)this_val, (void)argc, (void)argv, (void)new_target;

package/node/src/host_loop.c

@@ -1,4 +1,4 @@
-/* The libuv loop the host modules share (ADR 0008's I/O backend): node:http and node:net
+/* The libuv loop the host modules share: node:http and node:net
  * install it on first use, so programs without I/O don't link libuv. */
 #define _POSIX_C_SOURCE 200809L  /* libuv's headers: pthread_rwlock_t, struct addrinfo */
 #ifndef _WIN32
@@ -16,6 +16,7 @@ static uv_timer_t wake;      /* ends uv_run at the next timer's deadline; unref'
 static JSContext *loop_ctx;  /* the realm callbacks run in */
 static int failed;           /* exit status after an uncaught error in a callback */
 static void (*flush_hook)(void);
+static int call_depth;       /* js_uv_calls under way: one made from JS (a fed http parser's) nests */
 
 static void on_wake(uv_timer_t *t) { (void)t; }
 
@@ -63,13 +64,29 @@ JSContext *js_uv_context(void) { return loop_ctx; }
 
 void js_uv_set_flush(void (*fn)(void)) { flush_hook = fn; }
 
+void js_uv_nest(int delta) { call_depth += delta; }
+
+bool js_uv_drain(void) {
+    if (failed) return false;
+    if (call_depth > 0) return true;
+    if (js_run_microtasks(loop_ctx) < 0) {
+        failed = loop_ctx->rt->failure;
+        uv_stop(loop);
+        return false;
+    }
+    flush();
+    return true;
+}
+
 bool js_uv_call(JSValue fn, uint32_t argc, JSValue *argv, JSValue *result) {
     if (failed) return false;
     JSContext *ctx = loop_ctx;
-    /* under no async context (ADR 0020): the prelude binds a callback to the one it was given in */
+    /* under no async context: the prelude binds a callback to the one it was given in */
     JSValue saved = js_async_context(ctx);
     js_set_async_context(ctx, JS_UNDEFINED);
+    call_depth++;
     JSValue r = js_call(ctx, fn, JS_UNDEFINED, argc, argv);
+    call_depth--;
     js_set_async_context(ctx, saved);
     if (js_is_exception(r)) {
         failed = js_report_uncaught(ctx);
@@ -79,6 +96,12 @@ bool js_uv_call(JSValue fn, uint32_t argc, JSValue *argv, JSValue *result) {
         }
         r = JS_UNDEFINED;  /* handled ('uncaughtException'): the program goes on */
     }
+    /* microtasks run, and output goes out, when the outermost callback returns, as in Node: a call
+     * made while JS is running (a parser fed from a 'data' listener) leaves them to it */
+    if (call_depth > 0) {
+        if (result) *result = r;
+        return true;
+    }
     if (js_run_microtasks(ctx) < 0) {
         failed = ctx->rt->failure;
         uv_stop(loop);