visaljs 0.0.6 → 0.0.8

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,7 +59,7 @@ 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 */
 } WeakTable;
 
@@ -83,10 +83,10 @@ 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) {
+static void table_set(JSContext *ctx, WeakTable *t, JSValue key, JSValue value) {
     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 +99,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 +119,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 +202,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 +211,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 +335,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 +350,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 +366,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 +374,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;

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.

package/runtime/third_party/ada-idna/convert.mjs

@@ -1,21 +1,97 @@
 // Generates idna_tables.h from Ada's ada_idna.cpp (the single-file IDNA of ada-url/ada, the
 // version Node bundles): the UTS #46 mapping table and the label-validity data, packed for C.
+// Ada 4 keeps its tables in a raw-DEFLATE blob, read here as Ada reads it: a two-level table
+// (64 code points a block) of statuses and UTF-8 mappings, bidi ranges and combining ranges.
 //
 //   node runtime/third_party/ada-idna/convert.mjs <ada>/src/ada_idna.cpp
+import { Buffer } from "node:buffer";
 import { readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import process from "node:process";
+import { inflateRawSync } from "node:zlib";
 
 const source = readFileSync(process.argv[2], "utf8");
 const version = /\/\/ IDNA\s+([\d.]+)/.exec(source)[1];
 
+/** A `constexpr` number of the source, by name. */
+function constant(name) {
+  const m = new RegExp(`constexpr\\s+(?:size_t|uint32_t|uint16_t)\\s+${name}\\s*=\\s*(0x[0-9a-fA-F]+|\\d+)u?;`).exec(source);
+  if (!m) throw new Error(`no constant ${name}`);
+  return Number(m[1]);
+}
+
 /** The numbers of the C++ array `name` (comments dropped). */
 function array(name) {
-  const m = new RegExp(`\\b${name}\\[[^\\]]*\\](?:\\[[^\\]]*\\])?\\s*=\\s*\\{([\\s\\S]*?)\\};`).exec(source);
+  const m = new RegExp(`\\b${name}\\[[^\\]]*\\]\\s*=\\s*\\{([\\s\\S]*?)\\};`).exec(source);
   if (!m) throw new Error(`no array ${name}`);
   return m[1].replace(/\/\/.*$/gm, "").match(/0x[0-9a-fA-F]+|\d+/g).map(Number);
 }
 
+/* the blob: inflated, little-endian sections at the offsets Ada names */
+const blob = inflateRawSync(Buffer.from(array("compressed")));
+if (blob.length !== constant("uncompressed_size")) throw new Error("the inflated tables aren't Ada's size");
+const section = (name, size) => {
+  const at = constant(`off_${name}`), count = constant(`count_${name}`);
+  const read = { 1: (i) => blob[at + i], 2: (i) => blob.readUInt16LE(at + 2 * i), 4: (i) => blob.readUInt32LE(at + 4 * i),
+    8: (i) => blob.readBigUInt64LE(at + 8 * i) }[size];
+  return Array.from({ length: count }, (_, i) => read(i));
+};
+
+/* ---- the mapping: each code point's status, and its mapping when mapped ---------------------- */
+
+const VALID = 0xffff, DISALLOWED = 0xfffe, IGNORED = 0, BOOL_FLAG = 0x8000;
+const stage1 = section("idna_stage1", 2);
+const stage2 = section("idna_stage2", 2);
+const boolBlocks = section("idna_bool_blocks", 8);
+const utf8 = section("idna_utf8_mappings", 1);
+const LOW_END = constant("IDNA_LOW_RANGE_END");
+const HIGH_IGNORED_START = constant("IDNA_HIGH_IGNORED_START");
+const HIGH_IGNORED_END = constant("IDNA_HIGH_IGNORED_END");
+
+/** Ada's idna_lookup: VALID, DISALLOWED, IGNORED, or an offset into the UTF-8 mappings. */
+function lookup(cp) {
+  if (cp < LOW_END) {
+    const ref = stage1[cp >> 6];
+    if (ref & BOOL_FLAG) {
+      const bit = (ref & ~BOOL_FLAG) * 64 + (cp & 63);
+      return (boolBlocks[bit >> 6] >> BigInt(bit & 63)) & 1n ? VALID : DISALLOWED;
+    }
+    return stage2[ref + (cp & 63)];
+  }
+  return cp >= HIGH_IGNORED_START && cp < HIGH_IGNORED_END ? IGNORED : DISALLOWED;
+}
+
+/** The code points of the NUL-terminated UTF-8 mapping at `at`. */
+function mappingAt(at) {
+  let end = at;
+  while (utf8[end] !== 0) end++;
+  return [...Buffer.from(utf8.slice(at, end)).toString("utf8")].map((c) => c.codePointAt(0));
+}
+
+/* ranges of equal status (and, mapped, equal mapping), as idna.c reads them: status 0 ignored,
+   1 valid, 2 disallowed, 3 mapped */
+const entries = [];
+for (let cp = 0; cp <= 0x10ffff; cp++) {
+  const v = lookup(cp);
+  const status = v === VALID ? 1 : v === DISALLOWED ? 2 : v === IGNORED ? 0 : 3;
+  const mapping = status === 3 ? mappingAt(v) : null;
+  const last = entries[entries.length - 1];
+  if (last && last.status === status && (status !== 3 || last.mapping.join() === mapping.join())) continue;
+  entries.push({ first: cp, status, mapping });
+}
+const mappings = [];
+const keys = [];
+const indices = [];
+for (const { first, status, mapping } of entries) {
+  if (first >= 1 << 21 || (mapping && mapping.length >= 32)) throw new Error("table entry out of range");
+  keys.push((first | (status << 21) | ((mapping ? mapping.length : 0) << 23)) >>> 0);
+  indices.push(mapping ? mappings.length : 0);
+  if (mapping) mappings.push(...mapping);
+}
+if (mappings.length > 0xffff) throw new Error("mappings past a 16-bit index");
+
+/* ---- label validity ----------------------------------------------------------------------- */
+
 /** Sorted code points as [first, last] ranges. */
 function ranges(points) {
   const out = [];
@@ -34,28 +110,14 @@ function rows(values, perLine, hex = true) {
   return lines.join("\n");
 }
 
-/* table[i] = { first code point, descriptor }: code (0 ignored, 1 valid, 2 disallowed, 3 mapped)
- * in the low byte; for a mapping, its index in `mappings` (bits 8-23) and length (bits 24-31).
- * Packed: first | code << 21 | length << 23, and the index apart. */
-const table = array("table");
-const keys = [];
-const indices = [];
-for (let i = 0; i < table.length; i += 2) {
-  const [first, d] = [table[i], table[i + 1]];
-  const code = d & 0xff;
-  const mapped = code > 2;
-  if (first >= 1 << 21 || (mapped && d >>> 24 >= 32)) throw new Error("table entry out of range");
-  keys.push((first | ((mapped ? 3 : code) << 21) | ((mapped ? d >>> 24 : 0) << 23)) >>> 0);
-  indices.push(mapped ? (d >>> 8) & 0xffff : 0);
-}
-const mappings = array("mappings");
-
-/* the bidi classes, in Ada's enum order */
-const DIRECTIONS = ["NONE", "BN", "CS", "ES", "ON", "EN", "L", "R", "NSM", "AL", "AN", "ET", "WS", "RLO", "LRO", "PDF", "RLE", "RLI", "FSI", "PDI", "LRI", "B", "S", "LRE"];
-const dirSource = /dir_table\[\]\s*=\s*\{([\s\S]*?)\};/.exec(source)[1];
-const dirs = [...dirSource.matchAll(/\{(0x[0-9a-f]+),\s*(0x[0-9a-f]+),\s*direction::(\w+)\}/g)].map((m) => [Number(m[1]), Number(m[2]), DIRECTIONS.indexOf(m[3])]);
-
-const sets = Object.fromEntries(["combining", "virama", "R", "L", "D"].map((n) => [n, ranges(array(`static uint32_t ${n}`))]));
+/* the bidi classes: Ada's ranges, in its enum's order (idna.c's enum idna_direction) */
+const dirFirst = section("dir_start", 4);
+const dirLast = section("dir_final", 4);
+const dirClass = section("dir_value", 1);
+const combiningFlat = section("combining_flat", 4);
+const combining = [];
+for (let i = 0; i < combiningFlat.length; i += 2) combining.push([combiningFlat[i], combiningFlat[i + 1]]);
+const sets = { combining, ...Object.fromEntries(["virama", "R", "L", "D"].map((n) => [n, ranges(array(`constexpr static uint32_t ${n}`))])) };
 
 const out = [];
 out.push(`/* Generated by runtime/third_party/ada-idna/convert.mjs from Ada's ada_idna.cpp (IDNA ${version}). Do not edit.`);
@@ -70,10 +132,10 @@ out.push(`static const uint16_t idna_table_index[${indices.length}] = {\n${rows(
 out.push(`static const uint32_t idna_mappings[${mappings.length}] = {\n${rows(mappings, 10)}\n};`);
 out.push("");
 out.push("/* Bidi classes (RFC 5893), as Ada's ranges: first, last, class (enum idna_direction). */");
-out.push(`#define IDNA_DIR_COUNT ${dirs.length}`);
-out.push(`static const uint32_t idna_dir_first[${dirs.length}] = {\n${rows(dirs.map((d) => d[0]), 10)}\n};`);
-out.push(`static const uint32_t idna_dir_last[${dirs.length}] = {\n${rows(dirs.map((d) => d[1]), 10)}\n};`);
-out.push(`static const uint8_t idna_dir_class[${dirs.length}] = {\n${rows(dirs.map((d) => d[2]), 24, false)}\n};`);
+out.push(`#define IDNA_DIR_COUNT ${dirFirst.length}`);
+out.push(`static const uint32_t idna_dir_first[${dirFirst.length}] = {\n${rows(dirFirst, 10)}\n};`);
+out.push(`static const uint32_t idna_dir_last[${dirLast.length}] = {\n${rows(dirLast, 10)}\n};`);
+out.push(`static const uint8_t idna_dir_class[${dirClass.length}] = {\n${rows(dirClass, 24, false)}\n};`);
 out.push("");
 out.push("/* Code point sets of the label-validity rules, as sorted [first, last] ranges. */");
 for (const [name, rs] of Object.entries(sets)) {