visaljs 0.0.6 → 0.0.8

package/runtime/src/gc_visit.h

@@ -0,0 +1,87 @@
+/* How the marker visits the runtime's own cell kinds.
+ *
+ * Included by gc.c only, after it defines trace_value and trace_cell: the drain loop switches on
+ * the kind and inlines these, instead of an indirect call per cell. Host cells keep their class's
+ * visit. A visit only reads its cell and traces what it holds: no allocation, no writes.
+ * Flat strings and BigInts hold no cells: they're marked, never visited. */
+#ifndef GC_VISIT_H
+#define GC_VISIT_H
+
+#include "elements.h"
+#include "internal.h"
+#include "js_function.h"
+#include "js_object.h"
+#include "js_symbol.h"
+#include "jsstring.h"
+#include "shape.h"
+
+static inline void visit_object(JSCell *c, JSTracer *trc) {
+    JSObject *o = (JSObject *)c;
+    JSShape *s = o->shape;
+#if defined(__clang__) || defined(__GNUC__)
+    if (o->ool) __builtin_prefetch(o->ool);
+#endif
+    trace_cell(trc, &s->cell);
+    trace_cell(trc, &o->elements->cell);
+    JSValue *slots = js_object_slots(o);
+    for (uint16_t i = 0; i < s->inline_cap; i++) trace_value(trc, slots[i]);
+    if (o->ool) mark_ool(trc, o->ool);
+    if (s->cls->visit) s->cls->visit(c, trc);  /* the object's class: a Map's table, a Promise's reactions */
+}
+
+static inline void visit_env(JSCell *c, JSTracer *trc) {
+    JSEnv *e = (JSEnv *)c;
+    if (e->parent) trace_cell(trc, &e->parent->cell);
+    for (uint32_t i = 0; i < c->aux; i++) trace_value(trc, e->vars[i]);
+}
+
+static inline void visit_value_array(JSCell *c, JSTracer *trc) {
+    JSValueArray *a = (JSValueArray *)c;
+    for (uint32_t i = 0; i < c->aux; i++) trace_value(trc, a->values[i]);
+}
+
+static inline void visit_elements(JSCell *c, JSTracer *trc) {
+    JSElements *e = (JSElements *)c;
+    if (e->kind == JS_ELEMENTS_SPARSE) {
+        JSSparseElements *s = (JSSparseElements *)e;
+        for (uint32_t k = 0; k < s->cap; k++)
+            if (s->entries[k].state == 1) trace_value(trc, s->entries[k].value);
+        return;
+    }
+    for (uint32_t i = 0; i < e->length; i++) trace_value(trc, e->data[i]);
+}
+
+static inline void visit_rope(JSCell *c, JSTracer *trc) {
+    JSRope *r = (JSRope *)c;
+    trace_value(trc, r->left);
+    trace_value(trc, r->right);
+}
+
+static inline void visit_slice(JSCell *c, JSTracer *trc) {
+    trace_value(trc, ((JSSlice *)c)->parent);
+}
+
+static inline void visit_shape(JSCell *c, JSTracer *trc) {
+    JSShape *s = (JSShape *)c;
+    trace_value(trc, s->proto);
+    trace_value(trc, s->key);
+    trace_value(trc, s->enum_keys);
+    if (s->parent) trace_cell(trc, &s->parent->cell);
+    /* a dictionary's keys exist only in its table; a shared table's keys are on the chain */
+    if (s->table && (s->flags & JS_SHAPE_DICTIONARY))
+        for (uint32_t i = 0; i < s->table->count; i++) trace_value(trc, s->table->entries[i].key);
+    /* transitions are weak: children aren't traced (js_shapes_sweep) */
+}
+
+static inline void visit_accessor(JSCell *c, JSTracer *trc) {
+    JSAccessorPair *p = (JSAccessorPair *)c;
+    trace_value(trc, p->get);
+    trace_value(trc, p->set);
+}
+
+static inline void visit_symbol(JSCell *c, JSTracer *trc) {
+    const JSCell *d = ((JSSymbol *)c)->description;
+    if (d) trace_cell(trc, (JSCell *)d);
+}
+
+#endif /* GC_VISIT_H */

package/runtime/src/generator.c

@@ -1,4 +1,4 @@
-/* Generators (ECMAScript §27.3–27.5, §15.5.5; ADR 0007): the generator object, its driver
+/* Generators (ECMAScript §27.3–27.5, §15.5.5): the generator object, its driver
  * (%GeneratorPrototype%.next / return / throw) and yield* delegation. */
 #include "js_generator.h"
 
@@ -95,7 +95,7 @@ static void yield_star_visit(JSCell *c, JSTracer *trc) {
     js_trace_value(trc, y->next);
 }
 
-static const JSCellClass yield_star_class = { "YieldStar", yield_star_visit, NULL };
+static const JSCellClass yield_star_class = { "YieldStar", yield_star_visit, NULL, NULL };
 
 JSValue js_yield_star_start(JSContext *ctx, JSValue iterable) {
     JSValue method = js_is_nullish(iterable) ? JS_UNDEFINED : js_get_value(ctx, iterable, JS_SYMBOL(iterator));
@@ -155,7 +155,7 @@ JSValue js_yield_star_step(JSContext *ctx, JSValue rec, JSValue received, JSValu
     return js_throw_type_error(ctx, "The iterator does not provide a 'throw' method");
 }
 
-/* ---- Async functions (§27.7; ADR 0007) ------------------------------------------------- */
+/* ---- Async functions (§27.7) ----------------------------------------------------------- */
 
 static const JSClass async_class = { "AsyncFunctionState", sizeof(JSGenerator), NULL, NULL, NULL, NULL, js_generator_visit, NULL, NULL };
 
@@ -208,6 +208,7 @@ static void install_generator(JSContext *ctx, JSObject *global) {
     JSObject *gp = js_as_object(in[JS_INTRINSIC_GENERATOR_PROTOTYPE]);
     js_define_data(ctx, gfp, JS_ATOM(prototype), in[JS_INTRINSIC_GENERATOR_PROTOTYPE], JS_PROP_CONFIGURABLE);
     js_define_data(ctx, gfp, JS_SYMBOL(toStringTag), js_atom_from_cstr(ctx, "GeneratorFunction"), JS_PROP_CONFIGURABLE);
+    js_define_function_kind_ctor(ctx, in[JS_INTRINSIC_GENERATOR_FUNCTION_PROTOTYPE], 0);
     js_define_data(ctx, gp, JS_ATOM(constructor), in[JS_INTRINSIC_GENERATOR_FUNCTION_PROTOTYPE], JS_PROP_CONFIGURABLE);
     (void)js_define_method(ctx, gp, "next", generator_next, 1);
     (void)js_define_method(ctx, gp, "return", generator_return, 1);
@@ -222,4 +223,5 @@ void js_async_function_realm_init(JSContext *ctx) {
     in[JS_INTRINSIC_ASYNC_FUNCTION_PROTOTYPE] = js_new_object_proto(ctx, in[JS_INTRINSIC_FUNCTION_PROTOTYPE], 4);
     js_define_data(ctx, js_as_object(in[JS_INTRINSIC_ASYNC_FUNCTION_PROTOTYPE]), JS_SYMBOL(toStringTag),
                    js_atom_from_cstr(ctx, "AsyncFunction"), JS_PROP_CONFIGURABLE);
+    js_define_function_kind_ctor(ctx, in[JS_INTRINSIC_ASYNC_FUNCTION_PROTOTYPE], 1);
 }

package/runtime/src/global.c

@@ -1,4 +1,4 @@
-/* The global object and the primitives' prototypes (ECMAScript §19; ADR 0011, 0012). */
+/* The global object and the primitives' prototypes (ECMAScript §19). */
 #include "internal.h"
 #include "js_atoms.h"
 #include "js_console.h"
@@ -41,11 +41,11 @@ void js_global_realm_init(JSContext *ctx) {
     js_builtins_realm_init(ctx, g);
     js_symbol_realm_init(ctx, g);
     js_iterator_realm_init(ctx);
-    /* Promise, generators, async iteration and the weak collections are components (ADR 0014):
+    /* Promise, generators, async iteration and the weak collections are components:
      * a program gets them when its names or its syntax (async, function*, for await) reach them */
-    js_jobs_realm_init(ctx, g);  /* queueMicrotask (ADR 0008: the v1 host) */
-    define_function(ctx, g, "print", js_print, 1);  /* the test host's print (ADR 0011) */
-    /* console comes from the host prelude, which every program runs first (ADR 0012) */
+    js_jobs_realm_init(ctx, g);  /* queueMicrotask */
+    define_function(ctx, g, "print", js_print, 1);  /* the test host's print */
+    /* console comes from the host prelude, which every program runs first */
 }
 
 /* ---- Global name lookup ------------------------------------------------------- */
@@ -61,9 +61,17 @@ static JSValue global_lookup(JSContext *ctx, const char *name, bool for_typeof)
 }
 
 JSValue js_global_name(JSContext *ctx, const char *name) { return global_lookup(ctx, name, false); }
+
+JSValue js_global_get(JSContext *ctx, JSValue key, const char *name) {
+    JSPropertyDescriptor d;
+    int r = js_get_own_property(ctx, js_as_object(ctx->intrinsics[JS_INTRINSIC_GLOBAL_OBJECT]), key, &d);
+    if (r < 0) return JS_EXCEPTION;
+    if (r && (d.has & JS_DESC_VALUE)) return d.value;
+    return global_lookup(ctx, name, false);  /* an accessor, the prototypes, or a ReferenceError */
+}
 JSValue js_global_typeof_name(JSContext *ctx, const char *name) { return global_lookup(ctx, name, true); }
 
-/* ---- Script globals (§16.1.7 GlobalDeclarationInstantiation; ADR 0009 classic scripts) --- */
+/* ---- Script globals (§16.1.7 GlobalDeclarationInstantiation) ----------------------------- */
 
 static JSObject *global_object(JSContext *ctx) { return js_as_object(ctx->intrinsics[JS_INTRINSIC_GLOBAL_OBJECT]); }
 

package/runtime/src/headers.c

@@ -1,4 +1,4 @@
-/* Headers (Fetch §5.2), the headers component (ADR 0012, layer 2), as Node's (undici's): a list of
+/* Headers (Fetch §5.2), the headers component, as Node's (undici's): a list of
  * (name, value) in the order added, names compared case-insensitively. Iteration is sorted by
  * lowercase name with the values of a name combined (", "), except Set-Cookie's, each its own
  * entry; inspection shows each name as first given (`Headers { 'Content-Type': 'text/plain' }`).
@@ -144,7 +144,7 @@ static bool is_name(JSContext *ctx, JSValue lower, const char *name) {
 
 static void invalidate(JSContext *ctx, HeadersObject *h) { js_store(ctx, &h->obj.cell, &h->sorted, JS_UNDEFINED); }
 
-static void list_push(HeadersObject *h, JSValue lower, JSValue name, JSValue value) {
+static void list_push(JSContext *ctx, HeadersObject *h, JSValue lower, JSValue name, JSValue value) {
     if (h->n + 3 > h->cap) {
         uint32_t cap = h->cap ? h->cap * 2 : 24;
         JSValue *list = realloc(h->list, cap * sizeof *list);
@@ -152,9 +152,9 @@ static void list_push(HeadersObject *h, JSValue lower, JSValue name, JSValue val
         h->list = list;
         h->cap = cap;
     }
-    h->list[h->n++] = lower;
-    h->list[h->n++] = name;
-    h->list[h->n++] = value;
+    js_store(ctx, &h->obj.cell, &h->list[h->n++], lower);
+    js_store(ctx, &h->obj.cell, &h->list[h->n++], name);
+    js_store(ctx, &h->obj.cell, &h->list[h->n++], value);
 }
 
 static int64_t find(JSContext *ctx, HeadersObject *h, JSValue lower, uint32_t from) {
@@ -207,10 +207,10 @@ static int append(JSContext *ctx, HeadersObject *h, const char *method, JSValue
     if (i >= 0) {
         JSValue combined = js_concat(ctx, js_concat(ctx, h->list[i + 2], js_new_string_cstr(ctx, ", ")), value);
         if (js_is_exception(combined)) return -1;
-        h->list[i + 2] = combined;
+        js_store(ctx, &h->obj.cell, &h->list[i + 2], combined);
         return 0;
     }
-    list_push(h, lower, name, value);
+    list_push(ctx, h, lower, name, value);
     return 0;
 }
 
@@ -218,7 +218,7 @@ static int append(JSContext *ctx, HeadersObject *h, const char *method, JSValue
 static int fill(JSContext *ctx, HeadersObject *h, JSValue init) {
     HeadersObject *src = as_headers(init);
     if (src) {
-        for (uint32_t i = 0; i < src->n; i += 3) list_push(h, src->list[i], src->list[i + 1], src->list[i + 2]);
+        for (uint32_t i = 0; i < src->n; i += 3) list_push(ctx, h, src->list[i], src->list[i + 1], src->list[i + 2]);
         return 0;
     }
     if (!js_is_object(init))
@@ -386,10 +386,10 @@ BUILTIN(headers_set) {
     invalidate(ctx, h);
     int64_t i = find(ctx, h, lower, 0);
     if (i < 0) {
-        list_push(h, lower, name, value);
+        list_push(ctx, h, lower, name, value);
         return JS_UNDEFINED;
     }
-    h->list[i + 2] = value;
+    js_store(ctx, &h->obj.cell, &h->list[i + 2], value);
     uint32_t o = (uint32_t)i + 3;
     for (uint32_t k = (uint32_t)i + 3; k < h->n; k += 3) {
         if (js_string_equals(ctx, h->list[k], lower)) continue;

package/runtime/src/inspect.c

@@ -1,9 +1,11 @@
-/* util.inspect and util.format (ADR 0012), natively: Node's algorithms
+/* util.inspect and util.format, natively: Node's algorithms
  * (lib/internal/util/inspect.js), so console output matches Node's byte for byte.
  *
  * Every string built here, and every object reached, is also pushed on `keep`, a JS array
- * the conservative stack scan sees (ADR 0002): user code (getters, toString, custom
- * inspectors) can run and collect, and the C lists below are not roots themselves. */
+ * the conservative stack scan sees: user code (getters, toString, custom
+ * inspectors) can run and collect, and the C lists below are not roots themselves.
+ *
+ * Ported from Node.js (Copyright Node.js contributors, MIT): runtime/third_party/nodejs/LICENSE. */
 #include "js_console.h"
 
 #include <math.h>
@@ -119,7 +121,7 @@ typedef struct {
     JSInspectOptions o;
 } Insp;
 
-const JSInspectOptions js_inspect_defaults = { false, 2, true, 100, 10000, 80, 3, false };
+const JSInspectOptions js_inspect_defaults = { false, 2, true, 100, 10000, 80, 3, false, JS_INSPECT_GETTERS_OFF };
 
 static void insp_init(Insp *ip, JSContext *ctx, const JSInspectOptions *o) {
     *ip = (Insp){ ctx, JS_UNDEFINED, { 0 }, { 0 }, 0, 0, *o };
@@ -517,7 +519,39 @@ static JSValue format_property(Insp *ip, JSValue value, double recurse, JSValue
         ip->indentation -= diff;
         if (js_is_exception(str)) return str;
     } else if ((d.has & JS_DESC_GET) && !js_is_undefined(d.get)) {
-        str = cstr(ip, (d.has & JS_DESC_SET) && !js_is_undefined(d.set) ? "[Getter/Setter]" : "[Getter]");
+        bool setter = (d.has & JS_DESC_SET) && !js_is_undefined(d.set);
+        const char *label = setter ? "Getter/Setter" : "Getter";
+        int g = ip->o.getters;
+        if (g == JS_INSPECT_GETTERS_ALL || (g == JS_INSPECT_GETTERS_GET && !setter) || (g == JS_INSPECT_GETTERS_SET && setter)) {
+            /* the getter's value, as Node shows it: [Getter: 5], [Getter: null], [Getter] { a: 1 } */
+            keep(ip, d.get);
+            JSValue got = js_call(ctx, d.get, value, 0, NULL);
+            Builder g2 = { 0 };
+            if (js_is_exception(got)) {
+                /* what it threw, inspected: <Inspection threw ([Error: nope])> */
+                JSValue err = keep(ip, js_take_exception(ctx));
+                ip->indentation += 2;
+                JSValue shown = format_value(ip, err, recurse);
+                ip->indentation -= 2;
+                if (js_is_exception(shown)) { free(g2.units); return shown; }
+                put_ascii(&g2, "["), put_ascii(&g2, label), put_ascii(&g2, ": <Inspection threw (");
+                put_str(&g2, ctx, shown);
+                put_ascii(&g2, ")>]");
+            } else {
+                keep(ip, got);
+                ip->indentation += 2;
+                JSValue shown = js_is_null(got) ? cstr(ip, "null") : is_object_like(got) ? format_value(ip, got, recurse) : format_primitive(ip, got);
+                ip->indentation -= 2;
+                if (js_is_exception(shown)) { free(g2.units); return shown; }
+                put_ascii(&g2, "["), put_ascii(&g2, label);
+                put_ascii(&g2, is_object_like(got) ? "] " : ": ");
+                put_str(&g2, ctx, shown);
+                if (!is_object_like(got)) put_ascii(&g2, "]");
+            }
+            str = done(ip, &g2);
+        } else {
+            str = cstr(ip, setter ? "[Getter/Setter]" : "[Getter]");
+        }
     } else if ((d.has & JS_DESC_SET) && !js_is_undefined(d.set)) {
         str = cstr(ip, "[Setter]");
     } else {
@@ -525,23 +559,21 @@ static JSValue format_property(Insp *ip, JSValue value, double recurse, JSValue
     }
     if (js_is_exception(str)) return str;
     if (type == ARRAY_TYPE) return str;
+    /* the key: Symbol(s), an identifier as it is, any other quoted; in brackets when it isn't
+       enumerable */
+    if (!enumerable) put_ascii(&b, "[");
     if (js_is_symbol(key)) {
         JSValue s = js_symbol_descriptive_string(ctx, key);
-        if (js_is_exception(s)) return s;
-        put_ascii(&b, "[");
+        if (js_is_exception(s)) { free(b.units); return s; }
         put_escaped(&b, js_string_view(ctx, s));
-        put_ascii(&b, "]");
     } else {
         JSValue k = key_string(ip, key);
-        if (js_is_exception(k)) return k;
+        if (js_is_exception(k)) { free(b.units); return k; }
         if (str_eq_cstr(ctx, k, "__proto__")) put_ascii(&b, "['__proto__']");
-        else if (!enumerable) {
-            put_ascii(&b, "[");
-            put_escaped(&b, js_string_view(ctx, k));
-            put_ascii(&b, "]");
-        } else if (is_identifier_key(ctx, k)) put_str(&b, ctx, k);
+        else if (is_identifier_key(ctx, k)) put_str(&b, ctx, k);
         else put_quoted(&b, js_string_view(ctx, k));
     }
+    if (!enumerable) put_ascii(&b, "]");
     put_ascii(&b, ": ");
     put_str(&b, ctx, str);
     return done(ip, &b);
@@ -859,7 +891,7 @@ static JSValue format_error(Insp *ip, JSValue err, JSValue constructor, JSValue
         if (pos == 0) pos = -1;  /* Node: `(err.message && stack.indexOf(err.message)) || -1` */
         if (pos != -1) pos += js_string_length(m);
     }
-    /* no stack trace (visaljs records none: plan/unsupported.md): the error in brackets */
+    /* no stack trace (visaljs records none): the error in brackets */
     JSValue at = cstr(ip, "\n    at");
     if (js_is_exception(at)) return at;
     if (str_index_of(ctx, stack, at, pos < 0 ? 0 : (uint32_t)pos) == -1) stack = concat3(ip, "[", stack, "]");
@@ -871,6 +903,13 @@ static JSValue format_error(Insp *ip, JSValue err, JSValue constructor, JSValue
 /* ---- Laying out ------------------------------------------------------------------------- */
 
 static bool is_below_break_length(Insp *ip, List *output, double start, JSValue base) {
+    /* an infinite breakLength: one line, unless an entry has a line break of its own */
+    if (isinf(ip->o.break_length)) {
+        if (js_string_length(base) != 0 && str_contains_unit(ip->ctx, base, '\n')) return false;
+        for (size_t i = 0; i < output->n; i++)
+            if (str_contains_unit(ip->ctx, output->v[i], '\n')) return false;
+        return true;
+    }
     double total = output->n + start;
     if (total + output->n > ip->o.break_length) return false;
     for (size_t i = 0; i < output->n; i++) {
@@ -1162,7 +1201,10 @@ static JSValue format_raw(Insp *ip, JSValue value, double recurse) {
     JSValue constructor = get_constructor_name(ip, value, recurse);
     if (js_is_exception(constructor)) return constructor;
     JSValue tag = get(ip, value, JS_SYMBOL(toStringTag));
-    if (js_is_exception(tag)) return tag;
+    if (js_is_exception(tag)) {  /* a getter that throws: no tag */
+        js_discard(js_take_exception(ctx));
+        tag = js_empty_string();
+    }
     /* only listed when not an own enumerable property (it would be printed twice) */
     if (!js_is_string(tag) ||
         (js_string_length(tag) != 0 && (ip->o.show_hidden ? has_own(ctx, value, JS_SYMBOL(toStringTag))
@@ -1411,6 +1453,17 @@ static JSValue format_raw(Insp *ip, JSValue value, double recurse) {
         break;
     }
     ip->seen.n--;
+    if (ip->o.sorted) {
+        /* Node sorts the formatted entries: all of an object's (a Map's, a Set's), only the named
+         * properties after an array's elements */
+        size_t from = extras_type == OBJECT_TYPE ? 0 : keys.n > 1 ? output.n - keys.n : output.n;
+        for (size_t i = from + 1; i < output.n; i++) {
+            JSValue s = output.v[i];
+            size_t j = i;
+            for (; j > from && js_string_compare(ctx, output.v[j - 1], s) > 0; j--) output.v[j] = output.v[j - 1];
+            output.v[j] = s;
+        }
+    }
     result = reduce_to_single_string(ip, &output, base, brace0, brace1, extras_type, recurse, value);
 out:
     list_free(&keys);
@@ -1444,7 +1497,9 @@ static JSValue user_options(Insp *ip) {
     FIELD("breakLength", js_number(p->break_length));
     FIELD("compact", p->compact == COMPACT_TRUE ? JS_TRUE : p->compact == 0 ? JS_FALSE : js_int32(p->compact));
     FIELD("sorted", js_bool(p->sorted));
-    FIELD("getters", JS_FALSE);
+    FIELD("getters", p->getters == JS_INSPECT_GETTERS_ALL ? JS_TRUE
+                     : p->getters == JS_INSPECT_GETTERS_GET ? js_new_string_cstr(ctx, "get")
+                     : p->getters == JS_INSPECT_GETTERS_SET ? js_new_string_cstr(ctx, "set") : JS_FALSE);
     FIELD("numericSeparator", JS_FALSE);
     JSValue stylize = js_new_native(ctx, identity_stylize, js_atom_from_cstr(ctx, "stylize"), 2, JS_FN_STRICT);
     if (js_is_exception(stylize)) return stylize;
@@ -1747,6 +1802,10 @@ int js_inspect_options_from(JSContext *ctx, JSValue opts, JSInspectOptions *o) {
         else if (str_eq_cstr(ctx, key, "breakLength")) o->break_length = js_is_number(v) ? d : o->break_length;
         else if (str_eq_cstr(ctx, key, "compact")) o->compact = js_is_bool(v) ? (js_as_bool(v) ? COMPACT_TRUE : 0) : js_is_number(v) ? (int)d : o->compact;
         else if (str_eq_cstr(ctx, key, "sorted")) o->sorted = js_truthy(v);
+        else if (str_eq_cstr(ctx, key, "getters"))
+            o->getters = js_is_bool(v) ? (js_as_bool(v) ? JS_INSPECT_GETTERS_ALL : JS_INSPECT_GETTERS_OFF)
+                       : js_is_string(v) && str_eq_cstr(ctx, v, "get") ? JS_INSPECT_GETTERS_GET
+                       : js_is_string(v) && str_eq_cstr(ctx, v, "set") ? JS_INSPECT_GETTERS_SET : JS_INSPECT_GETTERS_OFF;
     }
     return 0;
 }

package/runtime/src/internal.h

@@ -23,6 +23,8 @@ void js_function_realm_init(JSContext *ctx);  /* function.c: %Function.prototype
 void js_global_realm_init(JSContext *ctx);    /* global.c: the global object, primitives' prototypes */
 void js_error_realm_init(JSContext *ctx, JSObject *global);  /* error.c: Error and the native errors */
 void js_builtins_realm_init(JSContext *ctx, JSObject *global);  /* builtins.c: Object, Array, String, … */
+/* builtins.c: %GeneratorFunction% (0), %AsyncFunction% (1) or %AsyncGeneratorFunction% (2), for proto */
+void js_define_function_kind_ctor(JSContext *ctx, JSValue proto, int kind);
 
 /* The ordinary internal methods (object.c), for class hooks that add to them. */
 int js_ordinary_get_own_property(JSContext *ctx, JSObject *o, JSValue key, JSPropertyDescriptor *out);
@@ -49,7 +51,7 @@ JSValue js_generator_proto(JSContext *ctx, JSValue callee, JSIntrinsic fallback)
  * handler's result, or undefined (promise.c). */
 void js_promise_then_internal(JSContext *ctx, JSValue promise, JSValue on_fulfilled, JSValue on_rejected, JSValue derived);
 
-/* Weak collections and references (weak.c; ADR 0002): the ephemeron pass (true if it
+/* Weak collections and references (weak.c): the ephemeron pass (true if it
  * marked anything), weak processing after marking, the kept-alive roots, teardown;
  * ClearKeptObjects; the FinalizationRegistry cleanup tasks (0, or -1 after an uncaught
  * error); the realm's WeakMap, WeakSet, WeakRef, FinalizationRegistry. */
@@ -65,7 +67,8 @@ void js_atoms_init(JSRuntime *rt);
 void js_atoms_sweep(JSRuntime *rt);  /* weak processing: drop unmarked atoms */
 void js_atoms_free(JSRuntime *rt);
 
-/* Cell classes defined outside gc.c (ADR 0002: one visit/finalize pair per kind). */
+/* Cell classes defined outside gc.c: each kind's name and finalizer. The marker visits these kinds
+ * itself (gc_visit.h), so their `visit` is NULL; only host cells' classes have one. */
 extern const JSCellClass js_flat_string_class;
 extern const JSCellClass js_symbol_cell_class;
 extern const JSCellClass js_rope_class;

package/runtime/src/iterate.c

@@ -5,10 +5,17 @@
 #include "js_object.h"
 #include "js_symbol.h"
 #include "jscontext.h"
+#include "shape.h"
 
 /* The keys still to visit: `object`'s own keys from `index` on, then its prototype's, and
  * so on. `visited` (a null-prototype object used as a set) holds every key already seen,
- * so a key shadowed by an earlier object (enumerable or not) is skipped. */
+ * so a key shadowed by an earlier object (enumerable or not) is skipped.
+ *
+ * The fast path (`shape` set): an ordinary object without elements, whose prototypes have no
+ * enumerable keys (`{…}`, class instances). Its keys are then its shape's enumerable string keys,
+ * listed once per shape (enum_keys), and there is nothing to shadow, so no `visited`. While the
+ * object keeps that shape (shared shapes never change), each key is still there and enumerable;
+ * after a change, each is looked up as on the slow path. */
 typedef struct ForIn {
     JSHostCell host;
     JSValue    object;   /* null when done */
@@ -17,6 +24,7 @@ typedef struct ForIn {
     JSValue    visited;
     JSValue    string;   /* a string primitive: its indices come first; else undefined */
     uint32_t   index;
+    JSShape   *shape;    /* the fast path: the object's shape when the loop began; else NULL */
 } ForIn;
 
 static void for_in_visit(JSCell *c, JSTracer *trc) {
@@ -26,11 +34,77 @@ static void for_in_visit(JSCell *c, JSTracer *trc) {
     js_trace_value(trc, f->proto);
     js_trace_value(trc, f->visited);
     js_trace_value(trc, f->string);
+    if (f->shape) js_trace_cell(trc, &f->shape->cell);
 }
 
-static const JSCellClass for_in_class = { "ForInIterator", for_in_visit, NULL };
+static const JSCellClass for_in_class = { "ForInIterator", for_in_visit, NULL, NULL };
+
+/* Whether for…in sees `o`'s keys exactly as its shape lists them: an object with the ordinary
+ * internal methods, no own keys outside its shape (Array's `length`, a String's indices), and
+ * no elements. */
+static bool plain_keys(JSObject *o) {
+    const JSClass *cls = o->shape->cls;
+    if (cls->methods || cls->get_own_property || cls->extra_keys) return false;
+    return o->elements->kind == JS_ELEMENTS_DENSE && o->elements->length == 0;
+}
+
+/* The enumerable string keys of `s`'s properties, in order: a new value array. */
+static JSValueArray *enumerable_keys(JSContext *ctx, JSShape *s) {
+    JSPropTable *t = js_shape_entries(s);
+    uint32_t n = 0;
+    for (uint32_t i = 0; i < t->count; i++)
+        n += js_is_string(t->entries[i].key) && (t->entries[i].attrs & JS_PROP_ENUMERABLE);
+    JSValueArray *keys = js_alloc_value_array(ctx, n);
+    t = js_shape_entries(s);  /* the allocation may have collected: the table is malloc'd, not moved */
+    for (uint32_t i = 0, k = 0; i < t->count && k < n; i++)
+        if (js_is_string(t->entries[i].key) && (t->entries[i].attrs & JS_PROP_ENUMERABLE)) keys->values[k++] = t->entries[i].key;  /* barrier: fresh cell */
+    return keys;
+}
+
+/* `s`'s enumerable string keys: cached on a shared shape, listed anew for a dictionary's
+ * (it changes in place). */
+static JSValueArray *shape_enum_keys(JSContext *ctx, JSShape *s) {
+    if (s->flags & JS_SHAPE_DICTIONARY) return enumerable_keys(ctx, s);
+    if (js_is_empty(s->enum_keys)) {
+        JSValueArray *keys = enumerable_keys(ctx, s);
+        js_store(ctx, &s->cell, &s->enum_keys, js_cell(&keys->cell));
+    }
+    return (JSValueArray *)js_as_cell(s->enum_keys);
+}
+
+/* Whether nothing on `o`'s prototype chain is enumerable: then for…in lists only `o`'s own keys. */
+static bool protos_enumerate_nothing(JSContext *ctx, JSObject *o) {
+    for (JSValue p = o->shape->proto; js_is_object(p); p = js_as_object(p)->shape->proto) {
+        JSObject *po = js_as_object(p);
+        if (!plain_keys(po)) return false;
+        JSShape *s = po->shape;
+        if (s->flags & JS_SHAPE_DICTIONARY) {
+            JSPropTable *t = js_shape_entries(s);
+            for (uint32_t i = 0; i < t->count; i++)
+                if (js_is_string(t->entries[i].key) && (t->entries[i].attrs & JS_PROP_ENUMERABLE)) return false;
+        } else if (shape_enum_keys(ctx, s)->cell.aux != 0) {
+            return false;
+        }
+    }
+    return true;
+}
 
 JSValue js_for_in_start(JSContext *ctx, JSValue v) {
+    if (js_is_object(v)) {
+        JSObject *o = js_as_object(v);
+        if (plain_keys(o) && protos_enumerate_nothing(ctx, o)) {
+            JSValueArray *keys = shape_enum_keys(ctx, o->shape);
+            ForIn *f = (ForIn *)js_alloc_host_cell(ctx, &for_in_class, sizeof(ForIn));
+            JSCell *c = &f->host.cell;
+            js_store(ctx, c, &f->object, v);
+            js_store(ctx, c, &f->keys, js_cell(&keys->cell));
+            js_store(ctx, c, &f->proto, JS_NULL);
+            js_store(ctx, c, &f->visited, JS_UNDEFINED);
+            js_store(ctx, c, &f->string, JS_UNDEFINED);
+            f->shape = o->shape;  /* barrier: fresh cell */
+            return js_cell(c);
+        }
+    }
     ForIn *f = (ForIn *)js_alloc_host_cell(ctx, &for_in_class, sizeof(ForIn));
     JSCell *c = &f->host.cell;
     js_store(ctx, c, &f->keys, JS_EMPTY);
@@ -51,10 +125,28 @@ static bool first_visit(JSContext *ctx, ForIn *f, JSValue key) {
     return true;
 }
 
+/* The fast path's next key. */
+static JSValue fast_next(JSContext *ctx, ForIn *f) {
+    JSObject *o = js_as_object(f->object);
+    JSValueArray *keys = (JSValueArray *)js_as_cell(f->keys);
+    bool unchanged = o->shape == f->shape && !(f->shape->flags & JS_SHAPE_DICTIONARY);
+    while (f->index < keys->cell.aux) {
+        JSValue key = keys->values[f->index++];
+        if (unchanged) return key;
+        /* deleted since the loop began, or no longer enumerable: skipped */
+        JSPropertyDescriptor d;
+        int r = js_get_own_property(ctx, o, key, &d);
+        if (r < 0) return JS_EXCEPTION;
+        if (r == 1 && (d.attrs & JS_PROP_ENUMERABLE)) return key;
+    }
+    return JS_UNDEFINED;
+}
+
 /* The next key (a string), undefined when there are no more, or JS_EXCEPTION. */
 JSValue js_for_in_next(JSContext *ctx, JSValue it) {
     ForIn *f = (ForIn *)js_as_cell(it);
     JSCell *c = &f->host.cell;
+    if (f->shape) return fast_next(ctx, f);
     /* a string's own indices, before anything on String.prototype */
     if (js_is_string(f->string)) {
         if (f->index < js_string_length(f->string)) {

package/runtime/src/iterator.c

@@ -176,7 +176,7 @@ static void record_visit(JSCell *c, JSTracer *trc) {
     js_trace_value(trc, r->next);
 }
 
-static const JSCellClass record_class = { "IteratorRecord", record_visit, NULL };
+static const JSCellClass record_class = { "IteratorRecord", record_visit, NULL, NULL };
 
 /* Whether o's own data property `key` holds exactly `expected` (no getter runs). */
 static bool own_data_is(JSContext *ctx, JSValue o, JSValue key, JSValue expected) {

package/runtime/src/jobs.c

@@ -1,5 +1,5 @@
-/* The job queue (ADR 0008, layer 1: microtasks, unhandled rejections) and the event
- * loop (layer 2: timers; the v1 backend has no I/O, so waiting is sleeping). */
+/* The job queue (microtasks, unhandled rejections) and the event loop (timers; without an
+ * I/O backend, waiting is sleeping). */
 #include "js_jobs.h"
 
 #include <stdint.h>
@@ -36,7 +36,7 @@ void js_enqueue_microtask(JSContext *ctx, const JSJob *job) {
     q->count++;
 }
 
-/* ---- The async context (ADR 0020) ---------------------------------------------------- */
+/* ---- The async context --------------------------------------------------------------- */
 
 JSValue js_async_context(JSContext *ctx) { return ctx->rt->async_context; }
 
@@ -337,7 +337,7 @@ HOST_FN(clear_timeout) {
     return JS_UNDEFINED;
 }
 
-/* ---- The event loop (layer 2) ------------------------------------------------------ */
+/* ---- The event loop ---------------------------------------------------------------- */
 
 static JSValue queue_microtask(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc,
                                const JSValue *argv, JSValue new_target) {
@@ -381,6 +381,11 @@ int js_run_event_loop(JSContext *ctx, JSValue main_result) {
             t->now = js_os_now_ms();
             if (!t->count || t->heap[0].deadline > t->now) {
                 int64_t timeout = t->count ? (int64_t)(t->heap[0].deadline - t->now) : -1;
+                /* a long wait with garbage to collect: JS_GC_IDLE_MS of it first, and when nothing
+                 * happened in them, the collector gives memory back */
+                bool idle_gc = (timeout < 0 || timeout > JS_GC_IDLE_MS) && js_gc_idle_wanted(rt);
+                if (idle_gc) timeout = JS_GC_IDLE_MS;
+                uint64_t waited = t->now;
                 /* the output so far appears before the wait, as Node's does (a server's log, say) */
                 fflush(stdout);
                 fflush(stderr);
@@ -389,9 +394,10 @@ int js_run_event_loop(JSContext *ctx, JSValue main_result) {
                     status = rt->io->run(ctx, timeout);
                     if (status) return status;
                 } else {
-                    js_os_sleep_ms(t->heap[0].deadline - t->now);  /* t->refed: a timer is pending */
+                    js_os_sleep_ms((uint64_t)timeout);  /* t->refed: a timer is pending */
                 }
                 t->now = js_os_now_ms();
+                if (idle_gc && t->now - waited >= JS_GC_IDLE_MS) js_gc_idle(ctx);
             }
             continue;
         }

package/runtime/src/jsnum.c

@@ -1,4 +1,4 @@
-/* Number <-> string conversion (ADR 0013). */
+/* Number <-> string conversion. */
 #include "jsnum.h"
 
 #include <math.h>
@@ -44,7 +44,7 @@ static double next_double_up(double d) {
 }
 
 /* Radix other than 10, with V8's algorithm so the output matches Node
- * byte for byte (ADR 0013): fraction digits until they are within half an
+ * byte for byte: fraction digits until they are within half an
  * ulp, and integer digits beyond 2^53 filled with zeros. */
 static size_t radix_to_cstr(char *out, double value, int radix) {
     static const char chars[] = "0123456789abcdefghijklmnopqrstuvwxyz";

package/runtime/src/json.c

@@ -1,4 +1,4 @@
-/* JSON (§25.5): an optional component (ADR 0014), and the serializer util.format's %j uses.
+/* JSON (§25.5): an optional component, and the serializer util.format's %j uses.
  *
  * JSON.parse follows V8's parser closely enough to give its error messages: the same checks in
  * the same order, at the same positions ("Unexpected token '}', "[1,}" is not valid JSON",