visaljs 0.0.7 → 0.0.9

package/runtime/src/typedarray.c

@@ -1,6 +1,6 @@
-/* Typed arrays (ECMAScript §23.2, §10.4.5), the typedarray component (ADR 0014), which needs the
+/* Typed arrays (ECMAScript §23.2, §10.4.5), the typedarray component, which needs the
  * arraybuffer component: %TypedArray%, its prototype's methods, and one constructor per element
- * type. BigInt64Array and BigUint64Array exist when the bigint component does (ADR 0016), which
+ * type. BigInt64Array and BigUint64Array exist when the bigint component does, which
  * is installed before this one; their elements are 64-bit integers read and written as BigInts.
  *
  * A typed array is an integer-indexed exotic object. Its class hooks and internal methods
@@ -94,7 +94,7 @@ static double load_number(const JSTypedArray *ta, size_t i) {
     }
 }
 
-/* An element: a Number, or for BigInt64Array and BigUint64Array its 64 bits (ADR 0016). */
+/* An element: a Number, or for BigInt64Array and BigUint64Array its 64 bits. */
 typedef union {
     double   num;
     uint64_t raw;
@@ -1234,6 +1234,10 @@ static double hook_typed_array_length(JSValue v) {
     return out_of_bounds(as_ta(v)) ? -1 : (double)ta_length(as_ta(v));
 }
 
+static bool hook_view_bytes(JSValue v, uint8_t **data, size_t *length) {
+    return !js_is_array_buffer(v) && js_buffer_source_bytes(v, data, length);
+}
+
 /* ---- Realm ----------------------------------------------------------------------------------- */
 
 static const JSBuiltin typed_array_statics[] = {
@@ -1325,6 +1329,7 @@ static void install_typedarray(JSContext *ctx, JSObject *global) {
     }
     ctx->rt->is_typed_array = hook_is_typed_array;
     ctx->rt->typed_array_length = hook_typed_array_length;
+    ctx->rt->view_bytes = hook_view_bytes;
 }
 
 const JSComponent js_component_typedarray = { "typedarray", install_typedarray };

package/runtime/src/tznames.gen.h

@@ -1,4 +1,5 @@
-/* Generated by runtime/tools/gen_tznames.mjs from the ICU data of Node v22.22.2. Do not edit. */
+/* Generated by runtime/tools/gen_tznames.mjs from the ICU data of Node v24.21.0. Do not edit. */
+/* CLDR data, Copyright Unicode, Inc. (Unicode License v3): runtime/third_party/unicode/LICENSE. */
 /* Each zone's standard and daylight names (indices into tz_names), sorted by zone id. */
 static const char *const tz_names[] = {
     "Greenwich Mean Time",

package/runtime/src/uri.c

@@ -1,5 +1,5 @@
 /* The URI handling functions (§19.2.6): encodeURI, encodeURIComponent, decodeURI and
- * decodeURIComponent. Core built-ins (ADR 0014): their entries are in js_core.def. */
+ * decodeURIComponent. Core built-ins: their entries are in js_core.def. */
 #include "builtins_util.h"
 
 #include <stdlib.h>

package/runtime/src/url.c

@@ -1,7 +1,7 @@
-/* URL and URLSearchParams (WHATWG URL), the url component (ADR 0017), which needs nothing else.
+/* URL and URLSearchParams (WHATWG URL), the url component, which needs nothing else.
  * The basic URL parser is the standard's state machine, in C, on code points; hosts go
  * through IDNA as Ada does it (runtime/third_party/ada-idna), so results match Node's, whose
- * URL is Ada (2.9.2 in Node v22). A record keeps each component serialized (ASCII): a
+ * URL is Ada (4.0.0 in Node v24). A record keeps each component serialized (ASCII): a
  * non-opaque path is its serialization, "/a/b", whose segments are what the slashes delimit.
  * The API is Node's: its errors, its inspection, and URLSearchParams' iteration. */
 #include <stdio.h>
@@ -122,8 +122,8 @@ static bool in_set(int set, uint32_t c) {
     case SET_USERINFO:
         if (c == '/' || c == ':' || c == ';' || c == '=' || c == '@' || (c >= '[' && c <= '^') || c == '|') return true;
         /* fallthrough */
-    case SET_PATH:  /* without ^, which the standard added after Ada 2.9.2 (Node v22) */
-        if (c == '?' || c == '`' || c == '{' || c == '}') return true;
+    case SET_PATH:
+        if (c == '?' || c == '^' || c == '`' || c == '{' || c == '}') return true;
         /* fallthrough */
     case SET_QUERY:
         return c == ' ' || c == '"' || c == '#' || c == '<' || c == '>';
@@ -724,12 +724,6 @@ static bool basic_parse(const uint32_t *in, size_t n, const URLRecord *base, URL
                 p--;
                 state = ST_FILE_HOST;
             } else if (c == ':' && !inside_brackets) {
-                if (buffer.n == 0 && override == ST_HOST && !is_special(url)) {  /* Ada: host "" and a port */
-                    buf_clear(&url->host);
-                    url->has_host = true;
-                    state = ST_PORT;
-                    break;
-                }
                 if (buffer.n == 0) FAIL();
                 if (override == ST_HOSTNAME) FAIL();
                 if (!parse_host(buffer.v, buffer.n, !is_special(url), &url->host)) FAIL();
@@ -863,9 +857,8 @@ static bool basic_parse(const uint32_t *in, size_t n, const URLRecord *base, URL
             if (c == END || c == '/' || (is_special(url) && c == '\\') || (!override && (c == '?' || c == '#'))) {
                 bool slash = c == '/' || (is_special(url) && c == '\\');
                 if (is_double_dot(&pbuf)) {
-                    bool was_empty = url->path.n == 0;  /* Ada: nothing to shorten adds no segment, unless special */
                     shorten_path(url);
-                    if (!slash && (is_special(url) || !was_empty)) path_append(url, "", 0);
+                    if (!slash) path_append(url, "", 0);
                 } else if (is_single_dot(&pbuf) && !slash) {
                     path_append(url, "", 0);
                 } else if (!is_single_dot(&pbuf)) {
@@ -890,6 +883,11 @@ static bool basic_parse(const uint32_t *in, size_t n, const URLRecord *base, URL
             }
             break;
         case ST_OPAQUE_PATH:
+            /* a space just before the query or fragment: %20, so the path doesn't end in one */
+            if ((c == '?' || c == '#') && url->path.n && url->path.v[url->path.n - 1] == ' ') {
+                url->path.v[--url->path.n] = '\0';
+                buf_append(&url->path, "%20", 3);
+            }
             if (c == '?') {
                 buf_clear(&url->query);
                 url->has_query = true;
@@ -1088,14 +1086,14 @@ static ParamsObject *as_params(JSValue v) {
 static JSValue buf_string(JSContext *ctx, const char *s, size_t n) { return js_new_string_latin1(ctx, (const uint8_t *)(s ? s : ""), (uint32_t)n); }
 
 /* Appends a name/value pair to a params list. */
-static void params_append(ParamsObject *p, JSValue name, JSValue value) {
+static void params_append(JSContext *ctx, ParamsObject *p, JSValue name, JSValue value) {
     if (p->n + 2 > p->cap) {
         size_t cap = p->cap;
         p->list = grow(p->list, &cap, p->n + 2, sizeof *p->list);
         p->cap = (uint32_t)cap;
     }
-    p->list[p->n++] = name;
-    p->list[p->n++] = value;
+    js_store(ctx, &p->obj.cell, &p->list[p->n++], name);
+    js_store(ctx, &p->obj.cell, &p->list[p->n++], value);
 }
 
 /* The application/x-www-form-urlencoded parser (URL §5.1) into a params list. */
@@ -1121,7 +1119,7 @@ static int params_parse(JSContext *ctx, ParamsObject *p, const uint8_t *in, size
             free(name.v);
             free(value.v);
             if (js_is_exception(vs)) return -1;
-            params_append(p, ns, vs);
+            params_append(ctx, p, ns, vs);
         }
         if (!amp) break;
         start = end + 1;
@@ -1487,11 +1485,16 @@ BUILTIN(url_set_port) {
     CPs in = { 0 };
     if (setter_input(ctx, ARG(0), &in) < 0) return JS_EXCEPTION;
     if (!cannot_have_credentials(u->rec)) {
-        size_t k = 0;  /* Ada removes tabs and newlines before the empty check */
-        for (size_t i = 0; i < in.n; i++)
-            if (in.v[i] != '\t' && in.v[i] != '\n' && in.v[i] != '\r') in.v[k++] = in.v[i];
-        if (k == 0) u->rec->port = -1;
-        else parse_override(ctx, in.v, k, u->rec, ST_PORT);
+        /* the empty string clears the port; anything else is parsed, its tabs and newlines removed
+           first (only those: nothing changes) */
+        if (in.n == 0) {
+            u->rec->port = -1;
+        } else {
+            size_t k = 0;
+            for (size_t i = 0; i < in.n; i++)
+                if (in.v[i] != '\t' && in.v[i] != '\n' && in.v[i] != '\r') in.v[k++] = in.v[i];
+            if (k) parse_override(ctx, in.v, k, u->rec, ST_PORT);
+        }
     }
     free(in.v);
     return JS_UNDEFINED;
@@ -1552,7 +1555,7 @@ BUILTIN(url_search_params) {
     THIS_URL();
     if (js_is_empty(u->search_params)) {
         JSValue p = new_params(ctx, ctx->intrinsics[JS_INTRINSIC_URL_SEARCH_PARAMS_PROTOTYPE]);
-        js_store(ctx, &u->obj.cell, &((ParamsObject *)js_as_object(p))->url, this_val);
+        js_store(ctx, &js_as_object(p)->cell, &((ParamsObject *)js_as_object(p))->url, this_val);
         js_store(ctx, &u->obj.cell, &u->search_params, p);
         if (refresh_params(ctx, u) < 0) return JS_EXCEPTION;
     }
@@ -1651,7 +1654,7 @@ static int pair_from_iterable(JSContext *ctx, ParamsObject *p, JSValue pair) {
         if (js_is_exception(name) || js_is_exception(name = to_usv(ctx, name))) return -1;
         JSValue value = js_get_value(ctx, pair, js_int32(1));
         if (js_is_exception(value) || js_is_exception(value = to_usv(ctx, value))) return -1;
-        params_append(p, name, value);
+        params_append(ctx, p, name, value);
         return 0;
     }
     if (!js_is_object(pair)) goto bad;
@@ -1673,7 +1676,7 @@ static int pair_from_iterable(JSContext *ctx, ParamsObject *p, JSValue pair) {
             p->list = grow(p->list, &cap, p->n + 1, sizeof *p->list);
             p->cap = (uint32_t)cap;
         }
-        p->list[p->n++] = e;
+        js_store(ctx, &p->obj.cell, &p->list[p->n++], e);
     }
     if (length != 2) goto bad;
     return 0;
@@ -1691,13 +1694,13 @@ BUILTIN(params_ctor) {
     JSValue self = new_params(ctx, proto);
     ParamsObject *p = (ParamsObject *)js_as_object(self);
     JSValue init = ARG(0);
-    if (js_is_nullish(init)) return self;
+    if (js_is_undefined(init)) return self;  /* null is the string "null" (Node 24, the standard) */
     if (js_is_object(init)) {
         ParamsObject *other = as_params(init);
         JSValue method = js_get_value(ctx, init, JS_SYMBOL(iterator));
         if (js_is_exception(method)) return method;
         if (other && js_same_bits(method, ctx->intrinsics[JS_INTRINSIC_URL_SEARCH_PARAMS_ENTRIES])) {
-            for (uint32_t i = 0; i < other->n; i += 2) params_append(p, other->list[i], other->list[i + 1]);
+            for (uint32_t i = 0; i < other->n; i += 2) params_append(ctx, p, other->list[i], other->list[i + 1]);
             return self;
         }
         if (!js_is_nullish(method)) {  /* sequence<sequence<USVString>> */
@@ -1729,8 +1732,8 @@ BUILTIN(params_ctor) {
             if (js_is_exception(value) || js_is_exception(value = to_usv(ctx, value))) return JS_EXCEPTION;
             uint32_t k = 0;
             while (k < p->n && !js_string_equals(ctx, p->list[k], name)) k += 2;
-            if (k < p->n) p->list[k + 1] = value;
-            else params_append(p, name, value);
+            if (k < p->n) js_store(ctx, &p->obj.cell, &p->list[k + 1], value);
+            else params_append(ctx, p, name, value);
         }
         return self;
     }
@@ -1767,7 +1770,7 @@ BUILTIN(params_append_method) {
     if (js_is_exception(name)) return name;
     JSValue value = to_usv(ctx, argv[1]);
     if (js_is_exception(value)) return value;
-    params_append(sp, name, value);
+    params_append(ctx, sp, name, value);
     update_url(ctx, sp);
     return JS_UNDEFINED;
 }
@@ -1800,8 +1803,8 @@ BUILTIN(params_delete) {
     uint32_t k = 0;
     for (uint32_t i = 0; i < sp->n; i += 2) {
         if (pair_matches(ctx, sp, i, name, value)) continue;
-        sp->list[k++] = sp->list[i];
-        sp->list[k++] = sp->list[i + 1];
+        sp->list[k++] = sp->list[i];  /* barrier: same owner */
+        sp->list[k++] = sp->list[i + 1];  /* barrier: same owner */
     }
     sp->n = k;
     update_url(ctx, sp);
@@ -1855,13 +1858,13 @@ BUILTIN(params_set) {
         if (js_string_equals(ctx, sp->list[i], name)) {
             if (found) continue;
             found = true;
-            sp->list[i + 1] = value;
+            js_store(ctx, &sp->obj.cell, &sp->list[i + 1], value);
         }
-        sp->list[k++] = sp->list[i];
-        sp->list[k++] = sp->list[i + 1];
+        sp->list[k++] = sp->list[i];  /* barrier: same owner */
+        sp->list[k++] = sp->list[i + 1];  /* barrier: same owner */
     }
     sp->n = k;
-    if (!found) params_append(sp, name, value);
+    if (!found) params_append(ctx, sp, name, value);
     update_url(ctx, sp);
     return JS_UNDEFINED;
 }
@@ -1874,12 +1877,12 @@ BUILTIN(params_sort) {
         JSValue name = sp->list[i], value = sp->list[i + 1];
         uint32_t k = i;
         while (k > 0 && js_string_compare(ctx, sp->list[k - 2], name) > 0) {
-            sp->list[k] = sp->list[k - 2];
-            sp->list[k + 1] = sp->list[k - 1];
+            sp->list[k] = sp->list[k - 2];  /* barrier: same owner */
+            sp->list[k + 1] = sp->list[k - 1];  /* barrier: same owner */
             k -= 2;
         }
-        sp->list[k] = name;
-        sp->list[k + 1] = value;
+        sp->list[k] = name;  /* barrier: same owner */
+        sp->list[k + 1] = value;  /* barrier: same owner */
     }
     update_url(ctx, sp);
     return JS_UNDEFINED;

package/runtime/src/weak.c

@@ -1,4 +1,4 @@
-/* Weak collections and references (ECMAScript §24.3–24.4, §26.1–26.2; ADR 0002): WeakMap
+/* Weak collections and references (ECMAScript §24.3–24.4, §26.1–26.2): WeakMap
  * and WeakSet (ephemerons), WeakRef with the kept-alive set, FinalizationRegistry.
  *
  * Each such object keeps its weak slots in malloc'd memory its class visit doesn't trace,
@@ -59,8 +59,10 @@ typedef struct WeakEntry {
 
 typedef struct WeakTable {
     JSObject   obj;
-    WeakEntry *entries;  /* malloc'd; NULL until the first key */
+    WeakEntry *entries;  /* malloc'd, the heap's external memory; NULL until the first key */
     uint32_t   cap, count, used;  /* used: count + tombstones */
+    uint32_t   writes;       /* entries set since the last collection, listed in rt->weak_writes */
+    bool       all_written;  /* too many to list: a young collection looks at every entry */
 } WeakTable;
 
 static uint32_t hash_key(JSValue k) {
@@ -83,10 +85,30 @@ static void insert_fresh(WeakEntry *entries, uint32_t cap, JSValue key, JSValue
     entries[i] = (WeakEntry){ key, value };
 }
 
-static void table_set(WeakTable *t, JSValue key, JSValue value) {
+/* Lists an entry set since the last collection. An entry set before has an old key and an old
+ * value (the last collection marked both, or dropped the entry), so a young collection can't free
+ * either: it looks only at the listed ones (js_weak_ephemerons, js_weak_sweep). Past a quarter of
+ * the table, the table is listed whole instead, which bounds the list. */
+static void note_write(JSRuntime *rt, WeakTable *t, JSValue key) {
+    if (t->all_written) return;
+    if (t->writes >= 64 && t->writes >= t->count / 4) {
+        t->all_written = true;
+        key = JS_EMPTY;
+    }
+    t->writes++;
+    struct JSWeakWrites *l = &rt->weak_writes;
+    if (l->count == l->cap) {
+        l->cap = l->cap ? l->cap * 2 : 64;
+        l->items = xrealloc(l->items, l->cap * sizeof *l->items);
+    }
+    l->items[l->count++] = (struct JSWeakWrite){ &t->obj, key };
+}
+
+static void table_set(JSContext *ctx, WeakTable *t, JSValue key, JSValue value) {
+    note_write(ctx->rt, t, key);
     WeakEntry *e = find(t, key);
     if (e) {
-        e->value = value;  /* malloc'd memory: no write barrier (ADR 0002) */
+        e->value = value;  /* malloc'd memory: no write barrier */
         return;
     }
     if ((t->used + 1) * 4 > t->cap * 3) {  /* grow (or just drop tombstones) at 3/4 */
@@ -99,6 +121,7 @@ static void table_set(WeakTable *t, JSValue key, JSValue value) {
             if (!js_is_empty(k) && !js_same_bits(k, TOMBSTONE)) insert_fresh(entries, cap, k, t->entries[i].value);
         }
         free(t->entries);
+        js_gc_external_add(ctx->rt, ((size_t)cap - t->cap) * sizeof *entries);  /* external memory */
         t->entries = entries;
         t->cap = cap;
         t->used = t->count;
@@ -118,8 +141,9 @@ static bool table_delete(WeakTable *t, JSValue key) {
 }
 
 static void table_finalize(JSRuntime *rt, JSCell *c) {
-    (void)rt;
-    free(((WeakTable *)c)->entries);
+    WeakTable *t = (WeakTable *)c;
+    js_gc_external_sub(rt, (size_t)t->cap * sizeof *t->entries);
+    free(t->entries);
 }
 
 static const JSClass weak_map_class = { "WeakMap", sizeof(WeakTable), NULL, NULL, NULL, NULL, NULL, table_finalize, NULL };
@@ -200,7 +224,7 @@ BUILTIN(weak_map_set) {
     WeakTable *t = this_table(ctx, this_val, &weak_map_class, "WeakMap.prototype.set");
     if (!t) return JS_EXCEPTION;
     if (!can_be_held_weakly(ARG(0))) return js_throw_type_error(ctx, "Invalid value used as weak map key");
-    table_set(t, ARG(0), ARG(1));
+    table_set(ctx, t, ARG(0), ARG(1));
     return this_val;
 }
 
@@ -209,7 +233,7 @@ BUILTIN(weak_set_add) {
     WeakTable *t = this_table(ctx, this_val, &weak_set_class, "WeakSet.prototype.add");
     if (!t) return JS_EXCEPTION;
     if (!can_be_held_weakly(ARG(0))) return js_throw_type_error(ctx, "Invalid value used in weak set");
-    if (!find(t, ARG(0))) table_set(t, ARG(0), JS_UNDEFINED);
+    if (!find(t, ARG(0))) table_set(ctx, t, ARG(0), JS_UNDEFINED);
     return this_val;
 }
 BUILTIN(weak_set_has) {
@@ -333,7 +357,8 @@ BUILTIN(registry_register) {
         r->cap = r->cap ? r->cap * 2 : 8;
         r->cells = xrealloc(r->cells, r->cap * sizeof *r->cells);
     }
-    r->cells[r->count++] = (Registration){ target, held, token };
+    r->cells[r->count++] = (Registration){ target, held, token };  /* barrier: below */
+    js_write_barrier(ctx, &r->obj.cell, NULL, held);  /* target and token are weak */
     return JS_UNDEFINED;
 }
 
@@ -347,7 +372,7 @@ BUILTIN(registry_unregister) {
     uint32_t n = 0;
     for (uint32_t i = 0; i < r->count; i++) {
         if (js_same_bits(r->cells[i].token, token)) removed = true;
-        else r->cells[n++] = r->cells[i];
+        else r->cells[n++] = r->cells[i];  /* barrier: same owner */
     }
     r->count = n;
     return js_bool(removed);
@@ -363,7 +388,7 @@ static int cleanup_registry(Registry *r) {
             continue;
         }
         JSValue held = r->cells[i].held;  /* on the C stack: still alive after the removal */
-        r->cells[i] = r->cells[--r->count];
+        r->cells[i] = r->cells[--r->count];  /* barrier: same owner */
         JSValue result = js_call(ctx, r->cleanup, JS_UNDEFINED, 1, &held);
         if (js_is_exception(result)) return -1;
         i = 0;  /* the callback may have registered or unregistered */
@@ -371,7 +396,7 @@ static int cleanup_registry(Registry *r) {
     return 0;
 }
 
-/* The host's FINALIZATION_CLEANUP tasks (ADR 0008): one registry at a time, each followed by
+/* The host's FINALIZATION_CLEANUP tasks: one registry at a time, each followed by
  * a checkpoint. 0, or -1 after an uncaught error (reported). */
 int js_run_finalization_cleanups(JSContext *ctx) {
     JSRuntime *rt = ctx->rt;
@@ -389,27 +414,83 @@ int js_run_finalization_cleanups(JSContext *ctx) {
 
 /* ---- The collector's side (gc.c) ------------------------------------------------------- */
 
-/* The ephemeron pass: marks the value of every live WeakMap entry whose key is marked.
- * true if anything new was marked (the caller drains and calls again). */
-bool js_weak_ephemerons(JSRuntime *rt, JSTracer *trc) {
+/* An entry's ephemeron step: its value marked when its key is. Returns whether it marked it. */
+static bool mark_value(JSTracer *trc, const WeakEntry *e) {
+    if (!js_is_cell(e->key) || !js_gc_is_marked(js_as_cell(e->key)) || is_live(e->value)) return false;
+    js_trace_value(trc, e->value);
+    return true;
+}
+
+static bool mark_values(JSTracer *trc, const WeakTable *t) {
     bool marked = false;
-    for (size_t i = 0; i < rt->weak.count; i++) {
-        JSObject *o = rt->weak.items[i];
-        if (o->shape->cls != &weak_map_class || !js_gc_is_marked(&o->cell)) continue;
-        WeakTable *t = (WeakTable *)o;
-        for (uint32_t k = 0; k < t->cap; k++) {
-            WeakEntry *e = &t->entries[k];
-            if (!js_is_cell(e->key) || !js_gc_is_marked(js_as_cell(e->key)) || is_live(e->value)) continue;
-            js_trace_value(trc, e->value);
-            marked = true;
+    for (uint32_t k = 0; k < t->cap; k++) marked |= mark_value(trc, &t->entries[k]);
+    return marked;
+}
+
+/* Drops the entry if its key died. */
+static void sweep_entry(WeakTable *t, WeakEntry *e) {
+    if (js_is_cell(e->key) && !js_gc_is_marked(js_as_cell(e->key))) {
+        e->key = TOMBSTONE;
+        e->value = JS_UNDEFINED;
+        t->count--;
+    }
+}
+
+static void sweep_entries(WeakTable *t) {
+    for (uint32_t k = 0; k < t->cap; k++) sweep_entry(t, &t->entries[k]);
+}
+
+/* The ephemeron pass: marks the value of every live WeakMap entry whose key is marked; a young
+ * collection, of the entries set since the last collection (note_write). true if anything new was
+ * marked (the caller drains and calls again). */
+bool js_weak_ephemerons(JSRuntime *rt, JSTracer *trc, bool full) {
+    bool marked = false;
+    if (full) {
+        for (size_t i = 0; i < rt->weak.count; i++) {
+            JSObject *o = rt->weak.items[i];
+            if (o->shape->cls == &weak_map_class && js_gc_is_marked(&o->cell)) marked |= mark_values(trc, (WeakTable *)o);
+        }
+        return marked;
+    }
+    for (size_t i = 0; i < rt->weak_writes.count; i++) {
+        struct JSWeakWrite w = rt->weak_writes.items[i];
+        if (w.table->shape->cls != &weak_map_class || !js_gc_is_marked(&w.table->cell)) continue;
+        WeakTable *t = (WeakTable *)w.table;
+        if (js_is_empty(w.key)) {
+            marked |= mark_values(trc, t);
+        } else {
+            WeakEntry *e = find(t, w.key);
+            if (e) marked |= mark_value(trc, e);
         }
     }
     return marked;
 }
 
-/* After marking: forget dead containers, drop dead keys, clear dead WeakRef targets, and
- * queue the registrations whose target died. */
-void js_weak_sweep(JSRuntime *rt) {
+/* After marking: forget dead containers, drop dead keys (a young collection: of the entries set
+ * since the last collection), clear dead WeakRef targets, and queue the registrations whose
+ * target died. Then the list of entries set starts anew. */
+void js_weak_sweep(JSRuntime *rt, bool full) {
+    struct JSWeakWrites *writes = &rt->weak_writes;
+    if (!full) {
+        for (size_t i = 0; i < writes->count; i++) {
+            struct JSWeakWrite w = writes->items[i];
+            if (!js_gc_is_marked(&w.table->cell)) continue;  /* dead: its entries go with it */
+            WeakTable *t = (WeakTable *)w.table;
+            if (js_is_empty(w.key)) {
+                sweep_entries(t);
+            } else {
+                WeakEntry *e = find(t, w.key);
+                if (e) sweep_entry(t, e);
+            }
+        }
+    }
+    for (size_t i = 0; i < writes->count; i++) {  /* dead tables too: they're finalized later */
+        WeakTable *t = (WeakTable *)writes->items[i].table;
+        t->writes = 0;
+        t->all_written = false;
+    }
+    writes->count = 0;
+
     struct JSWeakList *l = &rt->weak;
     size_t n = 0;
     for (size_t i = 0; i < l->count; i++) {
@@ -418,15 +499,7 @@ void js_weak_sweep(JSRuntime *rt) {
         l->items[n++] = o;
         const JSClass *cls = o->shape->cls;
         if (cls == &weak_map_class || cls == &weak_set_class) {
-            WeakTable *t = (WeakTable *)o;
-            for (uint32_t k = 0; k < t->cap; k++) {
-                WeakEntry *e = &t->entries[k];
-                if (js_is_cell(e->key) && !js_gc_is_marked(js_as_cell(e->key))) {
-                    e->key = TOMBSTONE;
-                    e->value = JS_UNDEFINED;
-                    t->count--;
-                }
-            }
+            if (full) sweep_entries((WeakTable *)o);
         } else if (cls == &weak_ref_class) {
             WeakRef *w = (WeakRef *)o;
             if (!is_live(w->target)) w->target = JS_UNDEFINED;
@@ -451,6 +524,7 @@ void js_weak_trace_roots(JSRuntime *rt, JSTracer *trc) {
 
 void js_weak_free(JSRuntime *rt) {
     free(rt->weak.items);
+    free(rt->weak_writes.items);
     free(rt->kept_alive.items);
 }
 

package/runtime/src/web.c

@@ -1,4 +1,4 @@
-/* Node's error shapes for the web-standard host layer (ADR 0012, layer 2), written in C for the
+/* Node's error shapes for the web-standard host layer, written in C for the
  * components that throw them (the prelude has the same in JS, node/prelude/internal/errors.js). */
 #include "js_web.h"
 
@@ -11,6 +11,7 @@
 #include "internal.h"
 #include "js_bigint.h"
 #include "js_console.h"
+#include "js_host.h"
 #include "js_symbol.h"
 #include "js_atoms.h"
 #include "js_convert.h"
@@ -70,8 +71,8 @@ void js_node_received(JSContext *ctx, JSValue v, char *buf, size_t cap) {
     } else if (js_is_function(v)) {
         JSValue n = js_get_value(ctx, v, JS_ATOM(name));
         if (js_is_exception(n)) js_discard(js_take_exception(ctx));
-        if (js_is_string(n) && js_string_length(n) != 0) to_utf8(ctx, n, s, sizeof s);
-        else strcpy(s, "<anonymous>");
+        if (js_is_string(n)) to_utf8(ctx, n, s, sizeof s);
+        else s[0] = '\0';  /* determineSpecificType: `function ${value.name}`, empty when anonymous */
         snprintf(buf, cap, " Received function %s", s);
     } else if (js_is_object(v)) {
         if (constructor_name(ctx, v, s, sizeof s)) snprintf(buf, cap, " Received an instance of %s", s);
@@ -212,3 +213,20 @@ JSValue js_decode_utf8_bytes(JSContext *ctx, const uint8_t *p, size_t n) {
     return s;
 }
 
+
+/* cloneClass(value): an object's internal class, as structuredClone (node/prelude/internal/
+ * structured_clone.js) sorts values: "Object" (an ordinary object, a class instance's too),
+ * "Array", "Date", "Map", "TypedArray", "Proxy", "Arguments", "Function", a primitive wrapper's
+ * type ("Number", "String", …), a web class's name ("URL", "Blob", …); undefined for a primitive. */
+JSValue js_host_clone_class(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target) {
+    UNUSED_ARGS;
+    JSValue v = ARG(0);
+    if (!js_is_object(v)) return JS_UNDEFINED;
+    if (js_is_function(v)) return js_new_string_cstr(ctx, "Function");
+    if (js_is_wrapper(v)) {
+        JSValue p = js_wrapped_value(v);
+        return js_new_string_cstr(ctx, js_is_string(p) ? "String" : js_is_number(p) ? "Number" : js_is_bool(p) ? "Boolean"
+                                       : js_is_bigint(p) ? "BigInt" : "Symbol");
+    }
+    return js_new_string_cstr(ctx, js_as_object(v)->shape->cls->name);
+}

package/runtime/src/writable.c

@@ -1,5 +1,5 @@
 /* WritableStream and TransformStream (WHATWG Streams §5, §6), and ReadableStream's pipeTo and
- * pipeThrough (§4.9.4), in the streams component (ADR 0012, layer 2), as Node has them. The
+ * pipeThrough (§4.9.4), in the streams component, as Node has them. The
  * algorithms are the standard's, named as it names them: a writable stream's queue holds the
  * chunks written and the close request (EMPTY), its controller hands them to the sink one at a
  * time, and backpressure follows the queue's size against the highWaterMark. A transform stream
@@ -165,7 +165,7 @@ static WController *controller_of(WStream *s) { return as_wcontroller(s->control
 static bool close_queued_or_in_flight(WStream *s) { return !js_is_undefined(s->close_request) || !js_is_undefined(s->in_flight_close); }
 static bool has_operation_in_flight(WStream *s) { return !js_is_undefined(s->in_flight_write) || !js_is_undefined(s->in_flight_close); }
 
-static void queue_push(WController *k, JSValue chunk, double size) {
+static void queue_push(JSContext *ctx, WController *k, JSValue chunk, double size) {
     if (k->head > 0 && k->n == k->cap) {
         memmove(k->queue, k->queue + k->head, (k->n - k->head) * sizeof *k->queue);
         k->n -= k->head;
@@ -178,8 +178,9 @@ static void queue_push(WController *k, JSValue chunk, double size) {
         k->queue = q;
         k->cap = cap;
     }
-    k->queue[k->n++] = chunk;
-    k->queue[k->n++] = js_number(size);
+    k->queue[k->n++] = chunk;  /* barrier: below */
+    js_write_barrier(ctx, &k->obj.cell, NULL, chunk);
+    k->queue[k->n++] = js_number(size);  /* barrier: not a cell */
     k->queue_size += size;
 }
 static bool queue_empty(const WController *k) { return k->head == k->n; }
@@ -426,7 +427,7 @@ static JSValue stream_close(JSContext *ctx, WStream *s) {
     Writer *w = as_writer(s->writer);
     if (w && s->backpressure && s->state == W_WRITABLE) resolve(ctx, w->ready, JS_UNDEFINED);
     WController *k = controller_of(s);
-    queue_push(k, JS_EMPTY, 0);
+    queue_push(ctx, k, JS_EMPTY, 0);
     advance_queue_if_needed(ctx, k);
     return promise;
 }
@@ -458,7 +459,7 @@ static JSValue writer_write(JSContext *ctx, Writer *w, JSValue chunk) {
         error_if_needed(ctx, k, js_new_error(ctx, JS_RANGE_ERROR, js_new_string_cstr(ctx, "Invalid size")));
         return promise;
     }
-    queue_push(k, chunk, size);
+    queue_push(ctx, k, chunk, size);
     if (!close_queued_or_in_flight(s) && s->state == W_WRITABLE) update_backpressure(ctx, s, desired_size(k) <= 0);
     advance_queue_if_needed(ctx, k);
     return promise;

package/runtime/third_party/ada-idna/README.md

@@ -1,15 +1,15 @@
 # ada-idna
 
 UTS #46 domain-to-ASCII from [Ada](https://github.com/ada-url/ada) by Yagiz Nizipli and Daniel
-Lemire, the URL library Node uses, ported to C: `URL` hosts come out exactly as Node's (ADR 0017).
+Lemire, the URL library Node uses, ported to C: `URL` hosts come out exactly as Node's.
 MIT license (`LICENSE-MIT`; Ada is also Apache-2.0).
 
-- **Upstream:** `src/ada_idna.cpp` of Ada **v2.9.2** (commit
-  `1cca580d8586ca3818d43e0bb11c7a47d77ca5ee`), the version Node v22 bundles
-  (`process.versions.ada`); IDNA 15.0.0.
-- **`idna_tables.h`** is generated by `convert.mjs` from that file: the mapping table (packed:
-  first code point, status and mapping length in 32 bits, the mapping's index apart), the bidi
-  classes, and the code point sets of the label rules as ranges.
+- **Upstream:** `src/ada_idna.cpp` of Ada **v4.0.0**, the version Node v24 bundles
+  (`process.versions.ada`); IDNA 17.0.0.
+- **`idna_tables.h`** is generated by `convert.mjs` from that file: Ada keeps its tables in a
+  raw-DEFLATE blob, which the script inflates and reads as Ada does, into the mapping table
+  (packed: first code point, status and mapping length in 32 bits, the mapping's index apart),
+  the bidi classes, and the code point sets of the label rules as ranges.
 - **`idna.c`** is the algorithm (mapping, punycode, label validity, to-ASCII), converted by hand
   from C++ to C step for step, Ada's quirks included (they are Node's behavior). Normalization to
   NFC uses QuickJS's libunicode (`third_party/quickjs-regexp`) instead of Ada's tables.