visaljs 0.0.6 → 0.0.8

package/runtime/src/builtins.c

@@ -1,5 +1,4 @@
-/* The first built-ins (roadmap M3: what the test262 harness needs): Object,
- * Function.prototype, Array, String, Number and Boolean basics. */
+/* Core built-ins: Object, Function.prototype, Array, String, Number and Boolean basics. */
 #include <math.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -249,7 +248,7 @@ static JSValue define_properties(JSContext *ctx, JSValue o, JSValue props) {
         js_store(ctx, &descs->cell, &descs->values[4 * count + 1], ds[count].value);
         js_store(ctx, &descs->cell, &descs->values[4 * count + 2], ds[count].get);
         js_store(ctx, &descs->cell, &descs->values[4 * count + 3], ds[count].set);
-        keys->values[count] = keys->values[i];
+        keys->values[count] = keys->values[i];  /* barrier: same owner */
         count++;
     }
     for (uint32_t i = 0; i < count; i++)
@@ -860,12 +859,39 @@ BUILTIN(function_proto_to_string) {
     return js_concat(ctx, s, cstr(ctx, "() { [native code] }"));
 }
 
-/* Function(...) compiles source text at runtime: that needs eval, a non-goal (ADR 0009). */
+/* Function(...) compiles source text at runtime: that needs eval, a non-goal. */
 BUILTIN(function_ctor) {
     UNUSED_ARGS;
     return js_throw_type_error(ctx, "Function() constructor needs eval, which isn't supported");
 }
 
+/* %GeneratorFunction%, %AsyncFunction% and %AsyncGeneratorFunction% (§27.3.1, §27.7.1, §27.4.1): a
+ * kind of function's constructor, which compiles source text as Function() does, so throws as it
+ * does. Not globals: reached as a function's prototype's constructor, as `instanceof` needs. */
+#define FUNCTION_KIND_CTOR(fn, name)                                                                 \
+    BUILTIN(fn) {                                                                                    \
+        UNUSED_ARGS;                                                                                 \
+        return js_throw_type_error(ctx, name "() constructor needs eval, which isn't supported");    \
+    }
+FUNCTION_KIND_CTOR(generator_function_ctor, "GeneratorFunction")
+FUNCTION_KIND_CTOR(async_function_ctor, "AsyncFunction")
+FUNCTION_KIND_CTOR(async_generator_function_ctor, "AsyncGeneratorFunction")
+
+/* The constructor of a kind of function, its prototype `proto`: [[Prototype]] %Function%, its
+ * `prototype` fixed, proto's `constructor` it (not writable, configurable). */
+void js_define_function_kind_ctor(JSContext *ctx, JSValue proto, int kind) {
+    static const struct { const char *name; JSNativeFn fn; } KINDS[] = {
+        { "GeneratorFunction", generator_function_ctor },
+        { "AsyncFunction", async_function_ctor },
+        { "AsyncGeneratorFunction", async_generator_function_ctor },
+    };
+    JSValue ctor = js_new_native(ctx, KINDS[kind].fn, js_atom_from_cstr(ctx, KINDS[kind].name), 1, JS_FN_STRICT | JS_FN_CONSTRUCTOR);
+    JSValue function = js_get_value(ctx, ctx->intrinsics[JS_INTRINSIC_FUNCTION_PROTOTYPE], JS_ATOM(constructor));
+    if (js_is_object(function) && js_set_prototype_of(ctx, js_as_object(ctor), function) < 0) js_discard(js_take_exception(ctx));
+    js_define_data(ctx, js_as_object(ctor), JS_ATOM(prototype), proto, 0);
+    js_define_data(ctx, js_as_object(proto), JS_ATOM(constructor), ctor, JS_PROP_CONFIGURABLE);
+}
+
 /* eval (§19.2.1): a non-string comes back as is; source text would need compiling at run time.
  * Present so code can reference it (get-intrinsic lists %eval%). */
 CORE(global_eval) {

package/runtime/src/collections.c

@@ -1,4 +1,4 @@
-/* Map and Set (ECMAScript §24.1–24.2), an optional component (ADR 0014): with Map.groupBy,
+/* Map and Set (ECMAScript §24.1–24.2), an optional component: with Map.groupBy,
  * Map.prototype.getOrInsert / getOrInsertComputed, and the Set methods (union, …).
  *
  * Each Map or Set holds an ordered hash table (V8's OrderedHashTable): the entries in insertion
@@ -55,7 +55,19 @@ static void table_visit(JSCell *c, JSTracer *trc) {
     }
 }
 
-static const JSCellClass table_class = { "OrderedHashTable", table_visit, NULL };
+/* A young collection's visit of a big table's marked cards. */
+static void table_visit_range(JSCell *c, JSTracer *trc, size_t from, size_t to) {
+    Table *t = (Table *)c;
+    if (from < offsetof(Table, entries)) js_trace_value(trc, t->next);
+    size_t first = from < offsetof(Table, entries) ? 0 : (from - offsetof(Table, entries)) / sizeof(Entry);
+    size_t last = to <= offsetof(Table, entries) ? 0 : (to - offsetof(Table, entries) + sizeof(Entry) - 1) / sizeof(Entry);
+    for (size_t i = first; i < last && i < t->used; i++) {
+        js_trace_value(trc, t->entries[i].key);
+        js_trace_value(trc, t->entries[i].value);
+    }
+}
+
+static const JSCellClass table_class = { "OrderedHashTable", table_visit, NULL, table_visit_range };
 
 static Table *new_table(JSContext *ctx, uint32_t cap) {
     size_t size = sizeof(Table) + cap * sizeof(Entry) + (cap / 2) * sizeof(uint32_t);
@@ -97,7 +109,7 @@ static uint32_t table_find(JSContext *ctx, Table *t, JSValue key, uint32_t hash)
 
 static void table_append(Table *t, JSValue key, JSValue value, uint32_t hash) {
     uint32_t *b = &buckets_of(t)[hash & (t->cap / 2 - 1)];
-    t->entries[t->used] = (Entry){ key, value, *b, hash };
+    t->entries[t->used] = (Entry){ key, value, *b, hash };  /* barrier: collection_add's, after it */
     *b = t->used++;
     t->count++;
 }
@@ -135,6 +147,9 @@ static void collection_add(JSContext *ctx, Collection *c, JSValue key, JSValue v
         t = table_of(c);
     }
     table_append(t, key, value, hash);
+    Entry *e = &t->entries[t->used - 1];
+    js_write_barrier(ctx, &t->host.cell, &e->key, key);
+    js_write_barrier(ctx, &t->host.cell, &e->value, value);
 }
 
 /* Sets key's value (adding it at the end if new). */

package/runtime/src/components.c

@@ -1,4 +1,4 @@
-/* Every component (ADR 0014): the test host installs them all. Programs name only the ones
+/* Every component: the test host installs them all. Programs name only the ones
  * they reach, so nothing in a program's binary references this list. */
 #include "js_builtins.h"
 

package/runtime/src/console.c

@@ -1,4 +1,4 @@
-/* The global console (ADR 0012), natively: Node's methods and output, formatted by
+/* The global console, natively: Node's methods and output, formatted by
  * inspect.c. Also the test host's print and the uncaught-error report. */
 #include "js_console.h"
 
@@ -55,6 +55,10 @@ void js_write_output(JSContext *ctx, int fd, JSValue s) {
     if (buf != small) free(buf);
 }
 
+void js_write_bytes(int fd, const uint8_t *data, size_t length) {
+    fwrite(data, 1, length, stream(fd));
+}
+
 /* console.group's indentation, in spaces */
 static size_t group_indent;
 
@@ -244,13 +248,14 @@ static void format_time(char *out, size_t cap, double ms) {
 static JSValue print_time(JSContext *ctx, JSValue label, double start, uint32_t extra, const JSValue *data) {
     char t[96];
     format_time(t, sizeof t, js_os_now_ms_precise() - start);
+    JSValue fmt = js_new_string_cstr(ctx, "%s: %s");  /* on the stack: the next allocation may collect */
+    JSValue elapsed = js_new_string_cstr(ctx, t);
     JSValue *args = malloc((3 + extra) * sizeof *args);
     if (!args) js_fatal("out of memory");
-    args[0] = js_new_string_cstr(ctx, "%s: %s");
+    args[0] = fmt;
     args[1] = label;
-    args[2] = js_new_string_cstr(ctx, t);
+    args[2] = elapsed;
     for (uint32_t i = 0; i < extra; i++) args[3 + i] = data[i];
-    JSValue fmt = args[0], elapsed = args[2];
     JSValue r = js_is_exception(fmt) || js_is_exception(elapsed) ? JS_EXCEPTION : print_args(ctx, 1, 3 + extra, args);
     js_keep_alive(fmt);  /* args is malloc'd: the scan doesn't see it */
     js_keep_alive(elapsed);
@@ -329,7 +334,7 @@ NATIVE(console_time_end) {
     return JS_UNDEFINED;
 }
 
-/* Node adds the stack's frames, which visaljs doesn't record (plan/unsupported.md). */
+/* Node adds the stack's frames, which visaljs doesn't record. */
 NATIVE(console_trace) {
     UNUSED_ARGS;
     JSValue message = js_format(ctx, argc, argv);
@@ -344,6 +349,8 @@ NATIVE(console_trace) {
 
 /* ---- console.table (Node's internal/cli_table.js) --------------------------------------------- */
 
+/* Ported from Node.js (Copyright Node.js contributors, MIT): runtime/third_party/nodejs/LICENSE. */
+
 /* The table's strings live in malloc'd arrays: `keep`, a JS array on the stack, holds them
  * for the scan. */
 static JSValue kept(JSContext *ctx, JSValue keep, JSValue v) {
@@ -586,7 +593,7 @@ NATIVE(console_clear) {
 JSValue js_new_console(JSContext *ctx) {
     JSValue console = js_new_object(ctx);
     if (js_is_exception(console)) return console;
-    /* the methods the program names (js_core.def, in Node's order; ADR 0014) */
+    /* the methods the program names (js_core.def, in Node's order) */
     js_install_core_on(ctx, JS_CORE_CONSOLE, js_as_object(console));
     return console;
 }
@@ -605,7 +612,7 @@ JSValue js_print(JSContext *ctx, JSValue callee, JSValue this_val,
 
 void js_report_error(JSContext *ctx, const char *prefix, JSValue e) {
     fflush(stdout);
-    /* An error prints as "Name: message" (ADR 0004; no frames: plan/unsupported.md), other
+    /* An error prints as "Name: message" (no frames: visaljs records none), other
      * objects as their ToString, primitives as console.log prints them. */
     JSValue s = js_is_error(e) ? js_error_to_string(ctx, e) : js_is_object(e) ? js_to_string(ctx, e) : js_format(ctx, 1, &e);
     if (js_is_exception(s)) {

package/runtime/src/core_all.c

@@ -1,4 +1,4 @@
-/* Every core method (js_core.def), for the test hosts and --all-builtins (ADR 0014). Programs
+/* Every core method (js_core.def), for the test hosts and --all-builtins. Programs
  * name theirs in their own C file, so this table is only linked when something calls
  * js_use_all_core. */
 #include <math.h>

package/runtime/src/crypto.c

@@ -1,4 +1,4 @@
-/* Web Crypto (W3C Web Cryptography API), the crypto component (ADR 0018), as Node has it: the
+/* Web Crypto (W3C Web Cryptography API), the crypto component, as Node has it: the
  * `crypto` global (a Crypto: getRandomValues, randomUUID, subtle), SubtleCrypto
  * (crypto_subtle.c) and CryptoKey (crypto_key.c). Node's errors (ERR_INVALID_THIS,
  * ERR_MISSING_ARGS, the DOMExceptions) and its WebIDL attributes. */

package/runtime/src/crypto_asym.c

@@ -1,4 +1,4 @@
-/* Asymmetric operations (ADR 0018) on the key record: RSA signatures (PKCS#1 v1.5 and PSS
+/* Asymmetric operations on the key record: RSA signatures (PKCS#1 v1.5 and PSS
  * encodings of our own, so any hash works and a verifier can recover a PSS salt's length, over
  * BoringSSL's raw RSA), ECDSA (BoringSSL; DER or IEEE P1363 signatures), RSA encryption (OAEP's
  * and PKCS#1 v1.5's paddings ours), and key agreement (EC Diffie-Hellman and X25519), with point

package/runtime/src/crypto_bn.c

@@ -1,4 +1,4 @@
-/* Big-integer primitives (ADR 0018) on BoringSSL's BIGNUM: node:crypto's finite-field Diffie-Hellman
+/* Big-integer primitives on BoringSSL's BIGNUM: node:crypto's finite-field Diffie-Hellman
  * (modular exponentiation), generatePrime and checkPrime. Integers travel as big-endian bytes. */
 #include <stdlib.h>
 #include <string.h>

package/runtime/src/crypto_cipher.c

@@ -1,4 +1,4 @@
-/* The crypto primitives' ciphers (ADR 0018): one streaming context for every cipher node:crypto
+/* The crypto primitives' ciphers: one streaming context for every cipher node:crypto
  * offers (AES in ECB, CBC, CFB, CFB1, CFB8, OFB, CTR, GCM, CCM and key wrap; 2- and 3-key
  * DES-EDE; ChaCha20 and ChaCha20-Poly1305), with OpenSSL's padding, chunking and checks. Web
  * Crypto's AES runs on it too. BoringSSL gives the block functions (the fastest the CPU has:
@@ -636,12 +636,19 @@ int js_cipher_final(JSCipherCtx *c, JSBytesOut *out) {
         return 0;
     }
     case JS_CIPHER_CCM:
+        /* no update (Node 24, OpenSSL 3.5): encrypting, the tag of the empty message, unless another
+           length was promised; decrypting, nothing, the tag unchecked */
         if (c->encrypt) {
-            if (!updated) return JS_CIPHER_ERR_TAG_NOT_SET;
+            if (!updated) {
+                if (c->ccm_length_set && c->ccm_length != 0) return JS_CIPHER_ERR_AUTH;
+                int e = ccm_run(c, ZEROS, 0, out);
+                if (e) return e;
+            }
             c->tag_ready = true;
             return 0;
         }
-        return !updated || c->auth_failed ? JS_CIPHER_ERR_AUTH : 0;
+        if (!updated) return 0;
+        return c->auth_failed ? JS_CIPHER_ERR_AUTH : 0;
     case JS_CIPHER_CHACHA20_POLY1305: {
         uint8_t tag[16];
         chapoly_tag(c, tag);

package/runtime/src/crypto_hash.c

@@ -1,4 +1,4 @@
-/* The crypto primitives' hashes, HMAC and random bytes (ADR 0018): BoringSSL's MD5, SHA-1 and
+/* The crypto primitives' hashes, HMAC and random bytes: BoringSSL's MD5, SHA-1 and
  * SHA-2, SHA-512/224 and /256 on its SHA-512 with their own IVs, and SHA-3 and SHAKE on a
  * Keccak-f[1600] of our own (BoringSSL has none to offer). HMAC is generic over them; random
  * bytes are BoringSSL's. */

package/runtime/src/crypto_host.c

@@ -1,4 +1,4 @@
-/* node:crypto's host primitives (ADR 0018): the prelude (node/prelude/crypto.js) builds Node's
+/* node:crypto's host primitives: the prelude (node/prelude/crypto.js) builds Node's
  * API on these, and Web Crypto shares the C beneath them (crypto_internal.h). Bad arguments are
  * the prelude's to check; here they are only kept from crashing. Handles are objects of the
  * classes below (no prototype): the prelude keeps them in its objects. */

package/runtime/src/crypto_internal.h

@@ -1,4 +1,4 @@
-/* crypto_internal.h — the crypto primitives (ADR 0018), runtime-private: what Web Crypto (the
+/* crypto_internal.h — the crypto primitives, runtime-private: what Web Crypto (the
  * crypto component) and node:crypto's host primitives share. BoringSSL is reached only through
  * the crypto*.c files, behind these. */
 #ifndef JS_CRYPTO_INTERNAL_H

package/runtime/src/crypto_kdf.c

@@ -1,4 +1,4 @@
-/* The crypto primitives' key derivation (ADR 0018): PBKDF2 (RFC 8018) and HKDF (RFC 5869) over
+/* The crypto primitives' key derivation: PBKDF2 (RFC 8018) and HKDF (RFC 5869) over
  * crypto_hash.c's HMAC, so any of its hashes works; scrypt (RFC 7914) with its Salsa20/8 core. */
 #include <stdlib.h>
 #include <string.h>

package/runtime/src/crypto_key.c

@@ -1,4 +1,4 @@
-/* Keys (ADR 0018): the key material, a C record both Web Crypto's CryptoKey and node:crypto's
+/* Keys: the key material, a C record both Web Crypto's CryptoKey and node:crypto's
  * KeyObject hold (so converting between them shares it), and CryptoKey itself: Node's class,
  * its attributes (type, extractable, algorithm, usages: the same objects on every read) and
  * its inspection. */
@@ -76,8 +76,21 @@ JSCryptoKey *js_as_crypto_key(JSValue v) {
     return js_is_object(v) && js_as_object(v)->shape->cls == &crypto_key_class ? (JSCryptoKey *)js_as_object(v) : NULL;
 }
 
+/* A key's usages, as Node 24 lists them: once each, in KeyUsage's order, whatever order (and
+ * repeats) they were given in */
+static JSValue usages_of_mask(JSContext *ctx, uint16_t mask) {
+    static const char *const NAMES[] = { "encrypt", "decrypt", "sign", "verify", "deriveKey", "deriveBits", "wrapKey", "unwrapKey" };
+    JSValue a = js_new_array(ctx, 2);
+    for (int i = 0; i < 8; i++)
+        if (mask & (1u << i) && js_array_append(ctx, a, js_new_string_cstr(ctx, NAMES[i])) < 0) return JS_EXCEPTION;
+    return a;
+}
+
 JSValue js_new_crypto_key(JSContext *ctx, JSValue data, uint8_t alg, const JSHashAlg *hash, uint32_t length, JSValue algorithm,
                           JSValue usages, uint16_t mask, bool extractable) {
+    (void)usages;
+    usages = usages_of_mask(ctx, mask);
+    if (js_is_exception(usages)) return usages;
     JSCryptoKey *k = (JSCryptoKey *)js_alloc_object(ctx, JS_CELL_OBJECT,
                                                     js_shape_root(ctx, &crypto_key_class, ctx->intrinsics[JS_INTRINSIC_CRYPTO_KEY_PROTOTYPE], 0));
     js_init_slot(&k->data, data);

package/runtime/src/crypto_pkey.c

@@ -1,4 +1,4 @@
-/* Asymmetric keys (ADR 0018): RSA, RSA-PSS, EC (P-256, P-384, P-521) and X25519 keys in the key
+/* Asymmetric keys: RSA, RSA-PSS, EC (P-256, P-384, P-521) and X25519 keys in the key
  * record (crypto_internal.h), their DER encodings (SPKI, PKCS#8, PKCS#1, SEC1, and the public key
  * of an X.509 certificate) with a small DER reader and writer of our own, and their generation on
  * BoringSSL. node:crypto's KeyObject is built on the primitives at the end; Web Crypto's keys share