visaljs 0.0.6 → 0.0.8

package/runtime/src/encoding.c

@@ -1,4 +1,4 @@
-/* TextEncoder and TextDecoder (WHATWG Encoding), the encoding component (ADR 0012, layer 2),
+/* TextEncoder and TextDecoder (WHATWG Encoding), the encoding component,
  * which needs the typedarray component. As in Node: TextEncoder writes UTF-8 (lone surrogates
  * become U+FFFD); TextDecoder reads UTF-8, UTF-16LE, UTF-16BE and windows-1252 (the labels
  * latin1, ascii, …), streaming, with `fatal` and `ignoreBOM`, and Node's errors and inspection.

package/runtime/src/error.c

@@ -1,4 +1,4 @@
-/* Error objects and constructors (ECMAScript §20.5; ADR 0004). */
+/* Error objects and constructors (ECMAScript §20.5). */
 #include "js_error.h"
 
 #include "internal.h"
@@ -32,12 +32,12 @@ static JSValue error_name(JSErrorKind kind) {
     }
 }
 
-/* ---- `stack` (not in the spec; ADR 0006) ---------------------------------------------- */
+/* ---- `stack` (not in the spec) -------------------------------------------------------- */
 
 /* `stack`, as V8 has it: an own, non-enumerable accessor installed first, whose getter formats
  * "Name: message" on the first read, with the name and message the error has then (a subclass
  * that sets this.name in its constructor shows it), and keeps it; the setter replaces it. Only
- * that first line: frames aren't recorded (plan/unsupported.md), so creating an error costs no
+ * that first line: frames aren't recorded, so creating an error costs no
  * stack walk. */
 static JSValue stack_get(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc,
                          const JSValue *argv, JSValue new_target) {
@@ -188,7 +188,7 @@ static JSValue error_proto_to_string(JSContext *ctx, JSValue callee, JSValue thi
 /* ---- Error.captureStackTrace and Error.stackTraceLimit (V8's; not in the spec) ------------- */
 
 /* Error.captureStackTrace(target, constructorOpt): V8's way to give any object a `stack`. Frames
- * aren't recorded (plan/unsupported.md), so it is the first line, as an error's own: "Name:
+ * aren't recorded, so it is the first line, as an error's own: "Name:
  * message" from the target. With Error.prepareStackTrace set (depd does it), that function makes
  * the value from the target and the call sites, which are Error.stackTraceLimit placeholders (up
  * to 10) that know no file, line or function. */

package/runtime/src/events.c

@@ -1,5 +1,5 @@
-/* Event, EventTarget, AbortController and AbortSignal (DOM §2, §3.1), the events component
- * (ADR 0012, layer 2), as Node has them: a target has no tree, so dispatch runs the target's
+/* Event, EventTarget, AbortController and AbortSignal (DOM §2, §3.1), the events component,
+ * as Node has them: a target has no tree, so dispatch runs the target's
  * own listeners for the type, in the order added, walking the list as Node walks its linked
  * list (a listener removed meanwhile doesn't run). A listener's exception doesn't stop
  * the dispatch: it is rethrown from a microtask, as Node rethrows it from process.nextTick,
@@ -317,7 +317,7 @@ static JSValue add_listener(JSContext *ctx, EventTargetObject *t, JSValue type,
         t->listeners = list;
         t->cap = cap;
     }
-    t->listeners[t->n++] = js_object_value(&l->obj);
+    js_store(ctx, &t->obj.cell, &t->listeners[t->n++], js_object_value(&l->obj));
     return js_object_value(&l->obj);
 }
 
@@ -617,19 +617,28 @@ BUILTIN(signal_timeout) {
 /* AbortSignal.any(signals): aborted when any of them is */
 BUILTIN(signal_any) {
     UNUSED_ARGS;
-    JSValue list = ARG(0);
-    JSValueArray *signals = js_is_object(list) ? js_list_from_array_like(ctx, list) : NULL;
-    if (!signals) {
-        if (js_has_exception(ctx)) return JS_EXCEPTION;
-        return js_throw_invalid_arg_type(ctx, "signals", "an instance of Array", list);
-    }
-    for (uint32_t i = 0; i < signals->cell.aux; i++) {
-        if (!as_signal(signals->values[i])) {
-            char name[32];
-            snprintf(name, sizeof name, "signals[%u]", i);
-            return js_throw_invalid_arg_type(ctx, name, "an instance of AbortSignal", signals->values[i]);
+    /* WebIDL's sequence<AbortSignal>, as Node converts it: an iterable object, each value a signal */
+    JSValue iterable = ARG(0);
+    JSValue method = js_is_object(iterable) ? js_get_value(ctx, iterable, JS_SYMBOL(iterator)) : JS_UNDEFINED;
+    if (js_is_exception(method)) return method;
+    if (!js_is_callable(method))
+        return js_throw_node_error(ctx, JS_TYPE_ERROR, "ERR_INVALID_ARG_TYPE", "signals cannot be converted to sequence.");
+    JSValue list = js_new_array(ctx, 4);
+    JSValue rec = js_iter_start(ctx, iterable);
+    if (js_is_exception(rec)) return rec;
+    for (uint32_t i = 0;; i++) {
+        JSValue v = js_iter_next(ctx, rec);
+        if (js_is_exception(v)) return v;
+        if (js_is_empty(v)) break;
+        if (!as_signal(v)) {
+            JSValue err = js_throw_node_error(ctx, JS_TYPE_ERROR, "ERR_INVALID_ARG_TYPE", "signals[%u] is not of type AbortSignal.", i);
+            js_iter_close_throw(ctx, rec);
+            return err;
         }
+        if (js_array_append(ctx, list, v) < 0) return JS_EXCEPTION;
     }
+    JSValueArray *signals = js_list_from_array_like(ctx, list);
+    if (!signals) return JS_EXCEPTION;
     JSValue result = new_signal(ctx);
     for (uint32_t i = 0; i < signals->cell.aux; i++) {
         AbortSignalObject *s = as_signal(signals->values[i]);

package/runtime/src/exception.c

@@ -1,4 +1,4 @@
-/* Exception propagation (ADR 0004). */
+/* Exception propagation. */
 #include "js_exception.h"
 
 #include <stdarg.h>

package/runtime/src/fetch.c

@@ -1,9 +1,9 @@
-/* Request and Response (Fetch §5.4, §5.5), the fetch component (ADR 0012, layer 2), as Node's
+/* Request and Response (Fetch §5.4, §5.5), the fetch component, as Node's
  * (undici's): their headers (the headers component), their bodies (the Body mixin, §5.3) and
  * Node's errors and inspection. A body made from bytes (a string, a buffer source, a Blob,
  * URLSearchParams) keeps them: text(), json(), arrayBuffer(), bytes() and blob() read them
  * directly, and `body` makes a ReadableStream of them only when asked. A ReadableStream body is
- * read through the streams component. fetch() itself (the client) isn't provided yet. */
+ * read through the streams component. fetch() itself is node:http's client\n * (node/prelude/internal/fetch.js), through the js_host_fetch_* primitives at the end. */
 #include <math.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -14,9 +14,12 @@
 #include "js_atoms.h"
 #include "js_buffer.h"
 #include "js_convert.h"
+#include "js_generator.h"
 #include "js_exception.h"
+#include "js_host.h"
 #include "js_ops.h"
 #include "js_promise.h"
+#include "js_symbol.h"
 #include "js_web.h"
 #include "jscontext.h"
 #include "jsstring.h"
@@ -27,6 +30,33 @@ static int fail(JSValue thrown) {
     return -1;
 }
 
+/* undici's TypeError for a URL that doesn't parse: "Failed to parse URL from …", its cause
+ * new URL's error (ERR_INVALID_URL). */
+static JSValue throw_unparsable(JSContext *ctx, JSValue input) {
+    JSValue cause = js_new_error(ctx, JS_TYPE_ERROR, js_new_string_cstr(ctx, "Invalid URL"));
+    js_define_data(ctx, js_as_object(cause), js_atom_from_cstr(ctx, "code"), js_new_string_cstr(ctx, "ERR_INVALID_URL"), JS_PROP_DEFAULT);
+    js_define_data(ctx, js_as_object(cause), js_atom_from_cstr(ctx, "input"), input, JS_PROP_DEFAULT);
+    JSValue message = js_concat(ctx, js_new_string_cstr(ctx, "Failed to parse URL from "), input);
+    if (js_is_exception(message)) return message;
+    JSValue e = js_new_error(ctx, JS_TYPE_ERROR, message);
+    js_define_data(ctx, js_as_object(e), JS_ATOM(cause), cause, JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE);
+    return js_throw(ctx, e);
+}
+
+/* Whether a serialized URL has a username or password: an '@' in its authority. */
+static bool has_credentials(JSContext *ctx, JSValue href) {
+    JSStrView v = js_string_view(ctx, href);
+    uint32_t i = 0;
+    while (i < v.length && js_view_at(v, i) != ':') i++;
+    if (i + 2 >= v.length || js_view_at(v, i + 1) != '/' || js_view_at(v, i + 2) != '/') return false;
+    for (i += 3; i < v.length; i++) {
+        uint32_t c = js_view_at(v, i);
+        if (c == '@') return true;
+        if (c == '/' || c == '?' || c == '#') return false;
+    }
+    return false;
+}
+
 /* ---- Bodies (§5.3) -------------------------------------------------------------------------- */
 
 typedef struct Body {
@@ -104,6 +134,70 @@ static bool class_named(JSValue v, const char *name) {
     return js_is_object(v) && strcmp(js_as_object(v)->shape->cls->name, name) == 0;
 }
 
+/* FormData (node/prelude/internal/form_data.js, linked into programs that name it) registers
+ * its body's serializer and formData()'s parser here (fetchFormDataHooks); until then a FormData
+ * is an ordinary object to a body, and formData() rejects. */
+static JSValue form_data_serialize, form_data_parse;  /* EMPTY (zero) until set: not callable */
+
+/* An async iterable body, as undici (Node's fetch) takes one: a Node Readable (what Next.js passes,
+ * a request's body), an async generator. Its stream pulls each chunk from the iterator: bytes (a
+ * buffer source, copied) or a string (as UTF-8). The source's data is the iterator record; the
+ * closures' is [controller, record]. */
+static JSValue chunk_bytes(JSContext *ctx, JSValue v) {
+    uint8_t *p;
+    size_t n;
+    if (js_buffer_source_bytes(v, &p, &n)) return u8_of(ctx, p, n);
+    if (!js_is_string(v)) return js_throw_type_error(ctx, "Received non-Uint8Array chunk");
+    JSStrView view = js_string_view(ctx, v);
+    size_t len = js_view_to_utf8(view, NULL, 0);
+    JSValue bytes = js_new_uint8_array(ctx, len);
+    if (js_is_exception(bytes)) return JS_EXCEPTION;
+    js_buffer_source_bytes(bytes, &p, &n);
+    js_view_to_utf8(view, (char *)p, len);
+    return bytes;
+}
+
+BUILTIN(iterable_next) {
+    (void)this_val, (void)new_target, (void)argc;
+    JSValue data = js_closure_data(callee);
+    JSValue controller = js_get_elem(ctx, data, js_int32(0)), rec = js_get_elem(ctx, data, js_int32(1));
+    JSValue value = js_async_iter_value(ctx, rec, ARG(0));  /* EMPTY when done */
+    if (!js_is_exception(value) && js_is_empty(value)) return js_readable_stream_close(ctx, controller) < 0 ? JS_EXCEPTION : JS_UNDEFINED;
+    JSValue bytes = js_is_exception(value) ? JS_EXCEPTION : chunk_bytes(ctx, value);
+    if (js_is_exception(bytes) || js_readable_stream_enqueue(ctx, controller, bytes) < 0) {
+        js_readable_stream_error(ctx, controller, js_take_exception(ctx));
+    }
+    return JS_UNDEFINED;
+}
+
+BUILTIN(iterable_failed) {
+    (void)this_val, (void)new_target, (void)argc;
+    js_readable_stream_error(ctx, js_get_elem(ctx, js_closure_data(callee), js_int32(0)), ARG(0));
+    return JS_UNDEFINED;
+}
+
+static JSValue iterable_pull(JSContext *ctx, JSValue controller, JSValue rec) {
+    JSValue result = js_async_iter_next(ctx, rec);
+    if (js_is_exception(result)) return JS_EXCEPTION;
+    JSValue settled_result = js_promise_resolve(ctx, result);
+    if (js_is_exception(settled_result)) return JS_EXCEPTION;
+    JSValue items[2] = { controller, rec };
+    JSValue data = js_new_array_from(ctx, items, 2);
+    if (js_is_exception(data)) return JS_EXCEPTION;
+    JSValue derived = js_new_promise(ctx);
+    js_promise_then_internal(ctx, settled_result, js_new_closure_native(ctx, iterable_next, 1, data),
+        js_new_closure_native(ctx, iterable_failed, 1, data), derived);
+    return derived;
+}
+
+static JSValue iterable_cancel(JSContext *ctx, JSValue rec, JSValue reason) {
+    (void)reason;
+    JSValue r = js_async_iter_return(ctx, rec);
+    return js_is_empty(r) ? JS_UNDEFINED : r;
+}
+
+static const JSStreamSource ITERABLE_SOURCE = { iterable_pull, iterable_cancel };
+
 /* Extract a body (§5.3 "extract"): its bytes or stream, and the Content-Type it implies (EMPTY
  * for none). 0, or -1. */
 static int extract(JSContext *ctx, JSCell *owner, Body *b, JSValue init, JSValue *content_type) {
@@ -128,6 +222,38 @@ static int extract(JSContext *ctx, JSCell *owner, Body *b, JSValue init, JSValue
     } else if (js_buffer_source_bytes(init, &p, &n)) {
         bytes = u8_of(ctx, p, n);
     } else {
+        if (js_is_object(init) && js_is_callable(form_data_serialize)) {
+            /* a FormData: [the multipart body as a Blob, its Content-Type], else undefined */
+            JSValue parts = js_call(ctx, form_data_serialize, JS_UNDEFINED, 1, &init);
+            if (js_is_exception(parts)) return -1;
+            if (js_is_array(parts)) {
+                JSValue blob = js_get_index(ctx, parts, js_int32(0)), type = js_get_index(ctx, parts, js_int32(1));
+                if (js_is_exception(blob) || js_is_exception(type)) return -1;
+                if (js_is_blob(blob)) {
+                    const uint8_t *data;
+                    size_t size;
+                    JSValue blob_type;
+                    js_blob_bytes(blob, &data, &size, &blob_type);
+                    bytes = u8_of(ctx, data, size);
+                    if (js_is_exception(bytes)) return -1;
+                    js_store(ctx, owner, &b->bytes, bytes);
+                    *content_type = type;
+                    return 0;
+                }
+            }
+        }
+        if (js_is_object(init)) {
+            JSValue method = js_get_value(ctx, init, JS_SYMBOL(asyncIterator));
+            if (js_is_exception(method)) return -1;
+            if (js_is_callable(method)) {
+                JSValue rec = js_async_iter_start(ctx, init);
+                if (js_is_exception(rec)) return -1;
+                JSValue stream = js_new_readable_stream(ctx, &ITERABLE_SOURCE, rec, 0);
+                if (js_is_exception(stream)) return -1;
+                js_store(ctx, owner, &b->stream, stream);
+                return 0;
+            }
+        }
         bool params = class_named(init, "URLSearchParams");
         JSValue s = js_to_string(ctx, init);
         if (js_is_exception(s)) return -1;
@@ -308,10 +434,11 @@ BUILTIN(request_ctor) {
         if (js_is_exception(s)) return s;
         JSValue u = js_parse_url_href(ctx, s);
         if (js_is_exception(u)) return u;
-        if (js_is_undefined(u)) {
-            char text[256];
-            text[js_view_to_utf8(js_string_view(ctx, s), text, sizeof text - 1)] = '\0';
-            return js_throw_type_error(ctx, "Failed to parse URL from %s", text);
+        if (js_is_undefined(u)) return throw_unparsable(ctx, s);
+        if (has_credentials(ctx, u)) {
+            JSValue message = js_concat(ctx, js_new_string_cstr(ctx, "Request cannot be constructed from a URL that includes credentials: "), u);
+            if (js_is_exception(message)) return message;
+            return js_throw(ctx, js_new_error(ctx, JS_TYPE_ERROR, message));
         }
         url = u;
     }
@@ -378,6 +505,8 @@ BUILTIN(request_ctor) {
     } else if (src && src->body.has_body) {  /* the input request's body moves to this one */
         if (body_used(&src->body)) return js_throw_type_error(ctx, "Cannot construct a Request with a Request object that has already been used.");
         r->body = src->body;
+        js_write_barrier(ctx, &r->obj.cell, &r->body.bytes, r->body.bytes);
+        js_write_barrier(ctx, &r->obj.cell, &r->body.stream, r->body.stream);
         init_body(&src->body);
         src->body.used = 1;
         src->body.has_body = 1;
@@ -456,11 +585,29 @@ CONSUMER(request_array_buffer, request_consume, AS_ARRAY_BUFFER)
 CONSUMER(request_bytes, request_consume, AS_BYTES)
 CONSUMER(request_blob, request_consume, AS_BLOB)
 
-BUILTIN(form_data_unsupported) {
+/* formData(): the body's bytes, parsed by FormData's module as the Content-Type says */
+static JSValue form_data(JSContext *ctx, JSCell *owner, Body *b, JSValue headers) {
+    if (!js_is_callable(form_data_parse)) {
+        JSValue e = js_throw_node_error(ctx, JS_TYPE_ERROR, "ERR_VISALJS_UNSUPPORTED", "formData() (named only at run time)");
+        (void)e;
+        return rejected(ctx, js_take_exception(ctx));
+    }
+    JSValue type = js_headers_get(ctx, headers, "content-type");
+    if (js_is_exception(type)) return rejected(ctx, js_take_exception(ctx));
+    JSValue args[2] = { consume(ctx, owner, b, headers, AS_BYTES), type };
+    JSValue parsed = js_call(ctx, form_data_parse, JS_UNDEFINED, 2, args);
+    return js_is_exception(parsed) ? rejected(ctx, js_take_exception(ctx)) : parsed;
+}
+
+BUILTIN(request_form_data) {
     UNUSED_ARGS;
-    JSValue e = js_throw_node_error(ctx, JS_TYPE_ERROR, "ERR_VISALJS_UNSUPPORTED", "formData() is not supported yet");
-    (void)e;
-    return rejected(ctx, js_take_exception(ctx));
+    RequestObject *r = as_request(this_val);
+    if (!r) {
+        JSValue e = js_throw_invalid_this(ctx, "Request");
+        (void)e;
+        return rejected(ctx, js_take_exception(ctx));
+    }
+    return form_data(ctx, &r->obj.cell, &r->body, r->headers);
 }
 
 static void field(JSContext *ctx, JSValue o, const char *name, JSValue v) {
@@ -606,11 +753,7 @@ BUILTIN(response_redirect) {
     if (js_is_exception(s)) return s;
     JSValue url = js_parse_url_href(ctx, s);
     if (js_is_exception(url)) return url;
-    if (js_is_undefined(url)) {
-        char text[256];
-        text[js_view_to_utf8(js_string_view(ctx, s), text, sizeof text - 1)] = '\0';
-        return js_throw_type_error(ctx, "Failed to parse URL from %s", text);
-    }
+    if (js_is_undefined(url)) return throw_unparsable(ctx, s);
     double status = 302;
     if (!js_is_undefined(ARG(1)) && js_to_number(ctx, &status, ARG(1)) < 0) return JS_EXCEPTION;
     if (status != 301 && status != 302 && status != 303 && status != 307 && status != 308)
@@ -674,6 +817,16 @@ static JSValue response_consume(JSContext *ctx, JSValue this_val, int kind) {
     return consume(ctx, &r->obj.cell, &r->body, r->headers, kind);
 }
 
+BUILTIN(response_form_data) {
+    UNUSED_ARGS;
+    ResponseObject *r = as_response(this_val);
+    if (!r) {
+        JSValue e = js_throw_invalid_this(ctx, "Response");
+        (void)e;
+        return rejected(ctx, js_take_exception(ctx));
+    }
+    return form_data(ctx, &r->obj.cell, &r->body, r->headers);
+}
 CONSUMER(response_text, response_consume, AS_TEXT)
 CONSUMER(response_json, response_consume, AS_JSON)
 CONSUMER(response_array_buffer, response_consume, AS_ARRAY_BUFFER)
@@ -724,7 +877,7 @@ static const JSBuiltin request_proto[] = {
     WEBIDL_OPERATION("arrayBuffer", request_array_buffer, 0),
     WEBIDL_OPERATION("text", request_text, 0),
     WEBIDL_OPERATION("json", request_json, 0),
-    WEBIDL_OPERATION("formData", form_data_unsupported, 0),
+    WEBIDL_OPERATION("formData", request_form_data, 0),
     WEBIDL_OPERATION("bytes", request_bytes, 0),
 };
 
@@ -749,10 +902,81 @@ static const JSBuiltin response_proto[] = {
     WEBIDL_OPERATION("arrayBuffer", response_array_buffer, 0),
     WEBIDL_OPERATION("text", response_text, 0),
     WEBIDL_OPERATION("json", response_json, 0),
-    WEBIDL_OPERATION("formData", form_data_unsupported, 0),
+    WEBIDL_OPERATION("formData", response_form_data, 0),
     WEBIDL_OPERATION("bytes", response_bytes, 0),
 };
 
+/* ---- fetch() (node/prelude/internal/fetch.js) ---------------------------------------------- */
+
+/* fetchHeaderList(headers): a Headers' entries as sent, [name, value, …] in the order they were
+ * added, with the names' case kept. */
+JSValue js_host_fetch_header_list(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target) {
+    UNUSED_ARGS;
+    JSValue headers = ARG(0);
+    if (!js_is_headers(headers)) return js_throw_type_error(ctx, "fetchHeaderList: not a Headers");
+    uint32_t n = js_headers_count(headers);
+    JSValue list = js_new_array(ctx, n * 2);
+    if (js_is_exception(list)) return list;
+    for (uint32_t i = 0; i < n; i++) {
+        JSValue lower, name, value;
+        js_headers_at(headers, i, &lower, &name, &value);
+        if (js_array_append(ctx, list, name) < 0 || js_array_append(ctx, list, value) < 0) return JS_EXCEPTION;
+    }
+    return list;
+}
+
+/* fetchRequestBody(request): the body a fetch sends, taken from the request (it is then used):
+ * its bytes (a Uint8Array, sent with a Content-Length), its ReadableStream (sent chunked), or
+ * null. */
+JSValue js_host_fetch_request_body(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target) {
+    UNUSED_ARGS;
+    RequestObject *r = as_request(ARG(0));
+    if (!r) return js_throw_invalid_this(ctx, "Request");
+    Body *b = &r->body;
+    if (!b->has_body) return JS_NULL;
+    if (body_used(b)) return js_throw_type_error(ctx, "Body is unusable: Body has already been read");
+    if (!js_is_undefined(b->stream)) return b->stream;
+    b->used = 1;
+    return js_is_undefined(b->bytes) ? js_new_uint8_array(ctx, 0) : b->bytes;
+}
+
+/* fetchResponse(status, statusText, headers, body, url, redirected): a fetched response, its
+ * headers (a Headers) made immutable and its body a ReadableStream or null. */
+JSValue js_host_fetch_response(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target) {
+    UNUSED_ARGS;
+    double status;
+    if (js_to_number(ctx, &status, ARG(0)) < 0) return JS_EXCEPTION;
+    if (!js_is_headers(ARG(2))) return js_throw_type_error(ctx, "fetchResponse: not a Headers");
+    ResponseObject *r = alloc_response(ctx, ctx->intrinsics[JS_INTRINSIC_RESPONSE_PROTOTYPE]);
+    JSValue rv = js_object_value(&r->obj);
+    r->status = (uint16_t)status;
+    r->type = 2;
+    r->redirected = js_truthy(ARG(5));
+    if (js_is_string(ARG(1))) js_store(ctx, &r->obj.cell, &r->status_text, ARG(1));
+    js_headers_set_guard(ARG(2), JS_HEADERS_IMMUTABLE);
+    js_store(ctx, &r->obj.cell, &r->headers, ARG(2));
+    if (js_is_string(ARG(4))) js_store(ctx, &r->obj.cell, &r->url, ARG(4));
+    if (js_is_readable_stream(ARG(3))) {
+        r->body.has_body = 1;
+        js_store(ctx, &r->obj.cell, &r->body.stream, ARG(3));
+    }
+    return rv;
+}
+
+/* fetchFormDataHooks(serialize, parse): FormData's module's body serializer and formData() parser */
+JSValue js_host_fetch_form_data_hooks(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target) {
+    UNUSED_ARGS;
+    static bool rooted;
+    if (!rooted) {
+        js_add_root(ctx->rt, &form_data_serialize);
+        js_add_root(ctx->rt, &form_data_parse);
+        rooted = true;
+    }
+    form_data_serialize = ARG(0);
+    form_data_parse = ARG(1);
+    return JS_UNDEFINED;
+}
+
 static void install_fetch(JSContext *ctx, JSObject *global) {
     JSValue object_proto = ctx->intrinsics[JS_INTRINSIC_OBJECT_PROTOTYPE];
     js_define_web_class(ctx, global, "Request", request_ctor, 1, object_proto, JS_INTRINSIC_REQUEST_PROTOTYPE);

package/runtime/src/function.c

@@ -1,4 +1,4 @@
-/* Function objects and calls (ADR 0006; ECMAScript §10.2, §10.3). */
+/* Function objects and calls (ECMAScript §10.2, §10.3). */
 #include "js_function.h"
 
 #include <math.h>
@@ -12,15 +12,15 @@
 #include "js_ops.h"
 #include "jscontext.h"
 
-/* cell.reserved: `prototype` hasn't been created yet (ADR 0006: lazily, on first observation) */
-#define PROTOTYPE_PENDING 0x40u
+/* cell flags (kind-specific): `prototype` hasn't been created yet (lazily, on first observation) */
+#define PROTOTYPE_PENDING 0x01u
 
 /* ---- The class: lazy `prototype`, GC fields ------------------------------- */
 
 /* Creates F.prototype = { constructor: F } if it's still pending. */
 static void materialize_prototype(JSContext *ctx, JSObject *f) {
-    if (!(f->cell.reserved & PROTOTYPE_PENDING)) return;
-    f->cell.reserved &= (uint8_t)~PROTOTYPE_PENDING;
+    if (!(f->cell.flags & PROTOTYPE_PENDING)) return;
+    f->cell.flags &= (uint16_t)~PROTOTYPE_PENDING;
     JSValue proto = js_new_object(ctx);
     js_define_data(ctx, js_as_object(proto), JS_ATOM(constructor), js_object_value(f), JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE);
     js_define_data(ctx, f, JS_ATOM(prototype), proto, JS_PROP_WRITABLE);
@@ -59,6 +59,7 @@ static void fn_visit(JSCell *c, JSTracer *trc) {
     js_trace_value(trc, f->home_object);
     js_trace_value(trc, f->bound_this);
     if (f->env) js_trace_cell(trc, &f->env->cell);
+    if (f->instance_shape) js_trace_cell(trc, &f->instance_shape->cell);
 }
 
 const JSClass js_class_function = {
@@ -98,7 +99,7 @@ JSValue js_new_function(JSContext *ctx, const JSFunctionInfo *info) {
     JSFunction *f = alloc_function(ctx, info->generic, info->flags, name, info->length);
     f->info = info;
     if ((info->flags & (JS_FN_CONSTRUCTOR | JS_FN_ORDINARY)) == (JS_FN_CONSTRUCTOR | JS_FN_ORDINARY))
-        f->obj.cell.reserved |= PROTOTYPE_PENDING;
+        f->obj.cell.flags |= PROTOTYPE_PENDING;
     if (info->flags & JS_FN_GENERATOR) {
         /* its own prototype: what its generators inherit from; no `constructor` (§15.5.4) */
         JSIntrinsic gp = info->flags & JS_FN_ASYNC ? JS_INTRINSIC_ASYNC_GENERATOR_PROTOTYPE : JS_INTRINSIC_GENERATOR_PROTOTYPE;
@@ -110,23 +111,19 @@ JSValue js_new_function(JSContext *ctx, const JSFunctionInfo *info) {
 
 JSValue js_new_closure(JSContext *ctx, const JSFunctionInfo *info, JSValue env) {
     JSValue f = js_new_function(ctx, info);
-    js_as_function(f)->env = js_as_env(env);  /* a fresh cell: no barrier needed (ADR 0002) */
+    /* not an initializing store: a generator function allocates its prototype after the cell */
+    js_store_ptr(ctx, &js_as_function(f)->obj.cell, &js_as_function(f)->env, js_as_env(env));
     return f;
 }
 
 /* ---- Environments ---------------------------------------------------------------- */
 
-static void env_visit(JSCell *c, JSTracer *trc) {
-    JSEnv *e = (JSEnv *)c;
-    if (e->parent) js_trace_cell(trc, &e->parent->cell);
-    for (uint32_t i = 0; i < c->aux; i++) js_trace_value(trc, e->vars[i]);
-}
-const JSCellClass js_env_cell_class = { "Env", env_visit, NULL };
+const JSCellClass js_env_cell_class = { "Env", NULL, NULL, NULL };  /* gc_visit.h visits it */
 
 JSValue js_new_env(JSContext *ctx, JSValue parent, uint32_t count) {
     JSEnv *e = (JSEnv *)js_alloc_cell(ctx, JS_CELL_ENV, sizeof(JSEnv) + (size_t)count * sizeof(JSValue));
     e->cell.aux = count;
-    e->parent = js_as_env(parent);
+    e->parent = js_as_env(parent);  /* barrier: fresh cell */
     return js_cell(&e->cell);
 }
 
@@ -231,6 +228,21 @@ JSValue js_create_from_constructor(JSContext *ctx, JSValue new_target, JSIntrins
     return js_new_object_proto(ctx, proto, JS_DEFAULT_INLINE_SLOTS);
 }
 
+JSValue js_new_instance(JSContext *ctx, JSValue fv, uint16_t slots, JSPropCache *ic) {
+    JSObject *fo = js_as_object(fv);
+    JSValue proto = fo->shape == ic->shape && ic->kind == JS_IC_OWN ? *js_object_slot(fo, ic->slot)  /* out of line, often */
+                                                                    : js_get_prop(ctx, fv, JS_ATOM(prototype), ic);
+    if (js_is_exception(proto)) return JS_EXCEPTION;
+    if (!js_is_object(proto)) proto = ctx->intrinsics[JS_INTRINSIC_OBJECT_PROTOTYPE];  /* OrdinaryCreateFromConstructor's fallback */
+    JSFunction *f = js_as_function(fv);
+    JSShape *s = f->instance_shape;
+    if (JS_UNLIKELY(!s || !js_same_bits(s->proto, proto) || s->inline_cap != slots)) {
+        s = js_shape_root(ctx, &js_class_object, proto, slots);
+        js_store_ptr(ctx, &f->obj.cell, &f->instance_shape, s);
+    }
+    return js_object_value(js_alloc_object(ctx, JS_CELL_OBJECT, s));
+}
+
 JSValue js_construct(JSContext *ctx, JSValue f, uint32_t argc, const JSValue *argv, JSValue new_target, const char *callee_text) {
     if (JS_UNLIKELY(!js_is_constructor(f))) return not_callable(ctx, f, callee_text, "constructor");
     JSFunction *fn = js_as_function(f);
@@ -279,7 +291,7 @@ JSValue js_class_setup(JSContext *ctx, JSValue ctor, JSValue heritage) {
     }
     JSValue proto = js_new_object_proto(ctx, proto_parent, JS_DEFAULT_INLINE_SLOTS);
     JSObject *f = js_as_object(ctor);
-    f->cell.reserved &= (uint8_t)~PROTOTYPE_PENDING;  /* set here, not lazily */
+    f->cell.flags &= (uint16_t)~PROTOTYPE_PENDING;  /* set here, not lazily */
     if (!js_same_bits(ctor_parent, ctx->intrinsics[JS_INTRINSIC_FUNCTION_PROTOTYPE])) {
         int r = js_set_prototype_of(ctx, f, ctor_parent);  /* a fresh function: can't fail */
         (void)r;
@@ -378,8 +390,8 @@ static JSValue bound_entry(JSContext *ctx, JSValue callee, JSValue this_val, uin
     JSValue target = b->home_object;
     uint32_t nbound = b->env ? b->env->cell.aux : 0;
     JSValueArray *all = js_alloc_value_array(ctx, nbound + argc);  /* GC-visible while the callee runs */
-    for (uint32_t i = 0; i < nbound; i++) all->values[i] = b->env->vars[i];
-    for (uint32_t i = 0; i < argc; i++) all->values[nbound + i] = argv[i];
+    for (uint32_t i = 0; i < nbound; i++) all->values[i] = b->env->vars[i];  /* barrier: fresh cell */
+    for (uint32_t i = 0; i < argc; i++) all->values[nbound + i] = argv[i];  /* barrier: fresh cell */
     JSValue held = js_cell(&all->cell);
     JSValue r;
     if (js_is_undefined(new_target)) {
@@ -433,8 +445,8 @@ JSValue js_bind_function(JSContext *ctx, JSValue target, JSValue bound_this, uin
     js_store(ctx, &b->obj.cell, &b->bound_this, bound_this);
     if (argc) {
         JSValue env = js_new_env(ctx, JS_UNDEFINED, argc);
-        for (uint32_t i = 0; i < argc; i++) js_as_env(env)->vars[i] = argv[i];
-        b->env = js_as_env(env);
+        for (uint32_t i = 0; i < argc; i++) js_as_env(env)->vars[i] = argv[i];  /* barrier: fresh cell */
+        js_store_ptr(ctx, &b->obj.cell, &b->env, js_as_env(env));
     }
     return f;
 }