visaljs 0.0.6 → 0.0.8

package/runtime/src/os.c

@@ -1,4 +1,4 @@
-/* Memory and time from the operating system (ADR 0002, 0008). */
+/* Memory and time from the operating system. */
 #define _GNU_SOURCE  /* MAP_ANONYMOUS under -std=c11, pthread_getattr_np */
 #include "os.h"
 
@@ -6,6 +6,8 @@
 
 #ifdef _WIN32
 #include <windows.h>
+#include <malloc.h>
+#include <psapi.h>
 #include <stdlib.h>
 #include <time.h>
 
@@ -34,6 +36,71 @@ void js_os_unmap(void *p, size_t size) {
     VirtualFree(p, 0, MEM_RELEASE);
 }
 
+void js_os_decommit(void *p, size_t size) {
+    VirtualFree(p, size, MEM_DECOMMIT);
+}
+
+bool js_os_commit(void *p, size_t size) {
+    return VirtualAlloc(p, size, MEM_COMMIT, PAGE_READWRITE) != NULL;
+}
+
+void js_os_trim(void) {
+    _heapmin();
+}
+
+struct JSOsLock { SRWLOCK lock; };
+struct JSOsCond { CONDITION_VARIABLE cond; };
+struct JSOsThread { HANDLE handle; void (*fn)(void *); void *arg; };
+
+JSOsLock *js_os_lock_new(void) {
+    JSOsLock *l = calloc(1, sizeof *l);
+    if (l) InitializeSRWLock(&l->lock);
+    return l;
+}
+void js_os_lock_free(JSOsLock *l) { free(l); }
+void js_os_lock(JSOsLock *l) { AcquireSRWLockExclusive(&l->lock); }
+void js_os_unlock(JSOsLock *l) { ReleaseSRWLockExclusive(&l->lock); }
+JSOsCond *js_os_cond_new(void) {
+    JSOsCond *c = calloc(1, sizeof *c);
+    if (c) InitializeConditionVariable(&c->cond);
+    return c;
+}
+void js_os_cond_free(JSOsCond *c) { free(c); }
+void js_os_cond_wait(JSOsCond *c, JSOsLock *l) { SleepConditionVariableSRW(&c->cond, &l->lock, INFINITE, 0); }
+void js_os_cond_signal(JSOsCond *c) { WakeConditionVariable(&c->cond); }
+void js_os_cond_broadcast(JSOsCond *c) { WakeAllConditionVariable(&c->cond); }
+
+static DWORD WINAPI thread_main(LPVOID p) {
+    JSOsThread *t = p;
+    t->fn(t->arg);
+    return 0;
+}
+JSOsThread *js_os_thread_start(void (*fn)(void *), void *arg) {
+    JSOsThread *t = calloc(1, sizeof *t);
+    if (!t) return NULL;
+    t->fn = fn;
+    t->arg = arg;
+    t->handle = CreateThread(NULL, 0, thread_main, t, 0, NULL);
+    if (!t->handle) {
+        free(t);
+        return NULL;
+    }
+    return t;
+}
+void js_os_thread_join(JSOsThread *t) {
+    WaitForSingleObject(t->handle, INFINITE);
+    CloseHandle(t->handle);
+    free(t);
+}
+unsigned js_os_cpu_count(void) {
+    DWORD_PTR process, system;
+    if (!GetProcessAffinityMask(GetCurrentProcess(), &process, &system)) return 1;
+    unsigned n = 0;
+    for (; process; process &= process - 1) n++;
+    return n ? n : 1;
+}
+
+
 void js_os_stack_bounds(void **low, void **high) {
     ULONG_PTR lo, hi;
     GetCurrentThreadStackLimits(&lo, &hi);
@@ -84,15 +151,35 @@ const char *js_os_timezone_id(void) {
     return tz && *tz ? tz : "";  /* Windows zone names aren't IANA ids: the offset fallback */
 }
 
+
+double js_os_thread_cpu_ms(void) {
+    FILETIME created, exited, kernel, user;
+    if (!GetThreadTimes(GetCurrentThread(), &created, &exited, &kernel, &user)) return js_os_now_ms_precise();
+    uint64_t k = ((uint64_t)kernel.dwHighDateTime << 32) | kernel.dwLowDateTime;
+    uint64_t u = ((uint64_t)user.dwHighDateTime << 32) | user.dwLowDateTime;
+    return (double)(k + u) / 1e4;  /* 100 ns units */
+}
+
+size_t js_os_peak_rss(void) {
+    PROCESS_MEMORY_COUNTERS pmc;
+    return K32GetProcessMemoryInfo(GetCurrentProcess(), &pmc, sizeof pmc) ? pmc.PeakWorkingSetSize : 0;
+}
 #else
 #include <errno.h>
 #include <pthread.h>
+#include <sched.h>
 #include <time.h>
 #include <stdlib.h>
 #include <sys/mman.h>
+#include <sys/resource.h>
 #include <unistd.h>
 #include <stdio.h>
 #include <string.h>
+#if defined(__GLIBC__)
+#include <malloc.h>
+#elif defined(__APPLE__)
+#include <malloc/malloc.h>
+#endif
 
 size_t js_os_page_size(void) {
     return (size_t)sysconf(_SC_PAGESIZE);
@@ -118,6 +205,94 @@ void js_os_unmap(void *p, size_t size) {
     munmap(p, size);
 }
 
+void js_os_decommit(void *p, size_t size) {
+#ifdef __linux__
+    madvise(p, size, MADV_DONTNEED);  /* private anonymous pages: zero-filled when touched again */
+#else
+    /* a fresh mapping in place: MADV_DONTNEED doesn't promise zeros everywhere */
+    mmap(p, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_FIXED, -1, 0);
+#endif
+}
+
+bool js_os_commit(void *p, size_t size) {
+    (void)p, (void)size;  /* the pages come back when touched */
+    return true;
+}
+
+void js_os_trim(void) {
+#if defined(__GLIBC__)
+    malloc_trim(0);
+#elif defined(__APPLE__)
+    malloc_zone_pressure_relief(NULL, 0);
+#endif
+}
+
+struct JSOsLock { pthread_mutex_t mutex; };
+struct JSOsCond { pthread_cond_t cond; };
+struct JSOsThread { pthread_t thread; void (*fn)(void *); void *arg; };
+
+JSOsLock *js_os_lock_new(void) {
+    JSOsLock *l = calloc(1, sizeof *l);
+    if (l && pthread_mutex_init(&l->mutex, NULL) != 0) {
+        free(l);
+        return NULL;
+    }
+    return l;
+}
+void js_os_lock_free(JSOsLock *l) {
+    pthread_mutex_destroy(&l->mutex);
+    free(l);
+}
+void js_os_lock(JSOsLock *l) { pthread_mutex_lock(&l->mutex); }
+void js_os_unlock(JSOsLock *l) { pthread_mutex_unlock(&l->mutex); }
+JSOsCond *js_os_cond_new(void) {
+    JSOsCond *c = calloc(1, sizeof *c);
+    if (c && pthread_cond_init(&c->cond, NULL) != 0) {
+        free(c);
+        return NULL;
+    }
+    return c;
+}
+void js_os_cond_free(JSOsCond *c) {
+    pthread_cond_destroy(&c->cond);
+    free(c);
+}
+void js_os_cond_wait(JSOsCond *c, JSOsLock *l) { pthread_cond_wait(&c->cond, &l->mutex); }
+void js_os_cond_signal(JSOsCond *c) { pthread_cond_signal(&c->cond); }
+void js_os_cond_broadcast(JSOsCond *c) { pthread_cond_broadcast(&c->cond); }
+
+static void *thread_main(void *p) {
+    JSOsThread *t = p;
+    t->fn(t->arg);
+    return NULL;
+}
+JSOsThread *js_os_thread_start(void (*fn)(void *), void *arg) {
+    JSOsThread *t = calloc(1, sizeof *t);
+    if (!t) return NULL;
+    t->fn = fn;
+    t->arg = arg;
+    if (pthread_create(&t->thread, NULL, thread_main, t) != 0) {
+        free(t);
+        return NULL;
+    }
+    return t;
+}
+void js_os_thread_join(JSOsThread *t) {
+    pthread_join(t->thread, NULL);
+    free(t);
+}
+unsigned js_os_cpu_count(void) {
+#if defined(__linux__)
+    cpu_set_t set;
+    if (sched_getaffinity(0, sizeof set, &set) == 0) {
+        int n = CPU_COUNT(&set);
+        if (n > 0) return (unsigned)n;
+    }
+#endif
+    long n = sysconf(_SC_NPROCESSORS_ONLN);
+    return n > 0 ? (unsigned)n : 1;
+}
+
 void js_os_stack_bounds(void **low, void **high) {
 #ifdef __APPLE__
     pthread_t self = pthread_self();
@@ -193,4 +368,20 @@ const char *js_os_timezone_id(void) {
     snprintf(id, sizeof id, "%s", z ? z + 9 : path);
     return id;
 }
+
+double js_os_thread_cpu_ms(void) {
+    struct timespec ts;
+    if (clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts) != 0) return js_os_now_ms_precise();
+    return (double)ts.tv_sec * 1000.0 + (double)ts.tv_nsec / 1e6;
+}
+
+size_t js_os_peak_rss(void) {
+    struct rusage ru;
+    if (getrusage(RUSAGE_SELF, &ru) != 0) return 0;
+#ifdef __APPLE__
+    return (size_t)ru.ru_maxrss;           /* bytes */
+#else
+    return (size_t)ru.ru_maxrss * 1024;    /* KiB */
+#endif
+}
 #endif

package/runtime/src/os.h

@@ -1,4 +1,4 @@
-/* os.h — memory and time from the operating system (ADR 0002, 0008). Runtime-internal. */
+/* os.h — memory and time from the operating system. Runtime-internal. */
 #ifndef JS_OS_H
 #define JS_OS_H
 
@@ -11,13 +11,44 @@ void *js_os_map(size_t size);
 /* Mapping aligned to `align` (a power of two, a multiple of 64 KiB). */
 void *js_os_map_aligned(size_t size, size_t align);
 void js_os_unmap(void *p, size_t size);
+/* Gives a mapping's pages back to the OS, keeping the addresses: they read as zeros after
+ * js_os_commit, which they need before they're used again. */
+void js_os_decommit(void *p, size_t size);
+bool js_os_commit(void *p, size_t size);
+/* Gives malloc's free memory back to the OS, where the C library can. */
+void js_os_trim(void);
+
+/* Threads, for the collector's helpers: a runtime has one mutator
+ * thread; these mark alongside it in the pauses. A lock and a condition, allocated. */
+typedef struct JSOsLock JSOsLock;
+typedef struct JSOsCond JSOsCond;
+typedef struct JSOsThread JSOsThread;
+JSOsLock *js_os_lock_new(void);
+void js_os_lock_free(JSOsLock *l);
+void js_os_lock(JSOsLock *l);
+void js_os_unlock(JSOsLock *l);
+JSOsCond *js_os_cond_new(void);
+void js_os_cond_free(JSOsCond *c);
+void js_os_cond_wait(JSOsCond *c, JSOsLock *l);
+void js_os_cond_signal(JSOsCond *c);
+void js_os_cond_broadcast(JSOsCond *c);
+/* NULL when it can't */
+JSOsThread *js_os_thread_start(void (*fn)(void *), void *arg);
+void js_os_thread_join(JSOsThread *t);
+/* The processors this process may run on (at least 1). */
+unsigned js_os_cpu_count(void);
+
 size_t js_os_page_size(void);
 /* The calling thread's stack: [*low, *high). Stacks grow down, so *high is the base. */
 void js_os_stack_bounds(void **low, void **high);
-/* The event loop's clock (ADR 0008): monotonic milliseconds, and sleeping. */
+/* The event loop's clock: monotonic milliseconds, and sleeping. */
 uint64_t js_os_now_ms(void);
 double js_os_now_ms_precise(void);  /* the same clock, with its sub-millisecond part */
 void js_os_sleep_ms(uint64_t ms);
+/* The calling thread's CPU time (user and system) in milliseconds, for the GC's policy. */
+double js_os_thread_cpu_ms(void);
+/* The process's peak resident memory in bytes (0 if unknown), for the GC's statistics. */
+size_t js_os_peak_rss(void);
 
 /* Date (the date component): wall-clock milliseconds since the epoch; the local time zone's
  * offset from UTC, in seconds, at an instant (and whether daylight saving applies then); the

package/runtime/src/process.c

@@ -1,4 +1,4 @@
-/* The global process (ADR 0012), natively: the command line, the environment, the exit
+/* The global process, natively: the command line, the environment, the exit
  * status, standard output and error, and warnings. js_host_init installs it with console
  * and global before the program runs. Its events ('beforeExit', 'exit') go through its emit,
  * which it has once node/prelude/internal/process_events.js made it an EventEmitter. */
@@ -285,8 +285,16 @@ NATIVE(process_cwd) {
     return dir;
 }
 
+#ifndef _WIN32
+/* getuid, geteuid, getgid, getegid: the process's ids (POSIX; Node has none of them on Windows) */
+NATIVE(process_getuid) { UNUSED_ARGS; (void)ctx, (void)argc, (void)argv; return js_number((double)getuid()); }
+NATIVE(process_geteuid) { UNUSED_ARGS; (void)ctx, (void)argc, (void)argv; return js_number((double)geteuid()); }
+NATIVE(process_getgid) { UNUSED_ARGS; (void)ctx, (void)argc, (void)argv; return js_number((double)getgid()); }
+NATIVE(process_getegid) { UNUSED_ARGS; (void)ctx, (void)argc, (void)argv; return js_number((double)getegid()); }
+#endif
+
 /* nextTick(callback, ...args): Node runs these before promise jobs; visaljs queues them
- * with them (ADR 0012). */
+ * with them. */
 NATIVE(process_next_tick) {
     UNUSED_ARGS;
     if (!js_is_callable(ARG(0))) return invalid_arg_type(ctx, "callback", "of type function", ARG(0));
@@ -319,13 +327,29 @@ NATIVE(process_hrtime) {
     return js_new_array_from(ctx, items, 2);
 }
 
+/* process.hrtime.bigint(): the time in nanoseconds; a program that calls it has BigInt */
+NATIVE(process_hrtime_bigint) {
+    UNUSED_ARGS, (void)argc, (void)argv;
+    if (!ctx->rt->bigint) return js_throw_type_error(ctx, "BigInt is not available");
+    return ctx->rt->bigint->from_uint64(ctx, (uint64_t)(js_os_now_ms_precise() * 1e6));
+}
+
 void js_emit_warning(JSContext *ctx, JSValue message, const char *type, const char *code) {
+    const char *quiet = getenv("NODE_NO_WARNINGS");  /* as Node: "1" silences them */
+    if (quiet && strcmp(quiet, "1") == 0) return;
     char prefix[96];
     snprintf(prefix, sizeof prefix, "(node:%d) %s%s%s%s: ", (int)getpid(), code ? "[" : "", code ? code : "", code ? "] " : "", type);
     fflush(stdout);
     fputs(prefix, stderr);
     js_write_output(ctx, 2, message);
     fputc('\n', stderr);
+    /* after the first warning, Node's hint (it names node, whose flags it is) */
+    static bool hinted;
+    if (!hinted) {
+        hinted = true;
+        fprintf(stderr, "(Use `node %s ...` to show where the warning was created)\n",
+                strcmp(type, "DeprecationWarning") == 0 ? "--trace-deprecation" : "--trace-warnings");
+    }
 }
 
 /* emitWarning(warning, type | { type, code }, code): "(node:PID) Warning: …" on stderr. */
@@ -365,11 +389,18 @@ NATIVE(process_emit_warning) {
     return JS_UNDEFINED;
 }
 
-/* stdout.write / stderr.write(chunk, encoding, callback) */
+/* stdout.write / stderr.write(chunk, encoding, callback): a string as UTF-8, a typed array or a
+ * DataView as its bytes; anything else is Node's TypeError */
 static JSValue stream_write(JSContext *ctx, int fd, uint32_t argc, const JSValue *argv) {
-    JSValue s = js_to_string(ctx, ARG(0));
-    if (js_is_exception(s)) return s;
-    js_write_output(ctx, fd, s);
+    JSValue chunk = ARG(0);
+    uint8_t *data;
+    size_t length;
+    if (js_is_string(chunk)) js_write_output(ctx, fd, chunk);
+    else if (ctx->rt->view_bytes && ctx->rt->view_bytes(chunk, &data, &length)) js_write_bytes(fd, data, length);
+    else if (js_is_null(chunk)) {
+        JSValue m = js_new_string_cstr(ctx, "May not write null values to stream");
+        return js_is_exception(m) ? m : throw_with_code(ctx, JS_TYPE_ERROR, "ERR_STREAM_NULL_VALUES", m);
+    } else return invalid_arg_type(ctx, "chunk", "of type string or an instance of Buffer, TypedArray, or DataView", chunk);
     JSValue callback = js_is_callable(ARG(1)) ? ARG(1) : ARG(2);
     if (js_is_callable(callback)) {
         JSJob job = { JS_JOB_CALLBACK, NULL, callback, JS_UNDEFINED, JS_UNDEFINED, JS_UNDEFINED };
@@ -460,6 +491,7 @@ static JSValue new_process(JSContext *ctx) {
     }
     define(ctx, p, "argv", args);
     define(ctx, p, "argv0", js_new_string_cstr(ctx, argv0));
+    define(ctx, p, "execArgv", js_new_array(ctx, 0));  /* Node's own options: a compiled program has none */
     define(ctx, p, "execPath", exec);
 
     /* env: a snapshot (writes don't reach the C environment) */
@@ -477,14 +509,47 @@ static JSValue new_process(JSContext *ctx) {
     }
     define(ctx, p, "env", env);
     define(ctx, p, "pid", js_int32((int32_t)getpid()));
+    /* version and versions: the Node API implemented, and visaljs's own; read-only, as Node's,
+       and versions extensible (Electron's tooling adds to it) */
+    js_define_data(ctx, p, js_atom_from_cstr(ctx, "version"), js_new_string_cstr(ctx, "v" JS_NODE_VERSION), JS_PROP_ENUMERABLE | JS_PROP_CONFIGURABLE);
+    JSValue versions = js_new_object(ctx);
+    if (js_is_exception(versions)) return versions;
+    js_define_data(ctx, js_as_object(versions), js_atom_from_cstr(ctx, "node"), js_new_string_cstr(ctx, JS_NODE_VERSION), JS_PROP_ENUMERABLE | JS_PROP_CONFIGURABLE);
+    js_define_data(ctx, js_as_object(versions), js_atom_from_cstr(ctx, "visaljs"), js_new_string_cstr(ctx, JS_VISALJS_VERSION), JS_PROP_ENUMERABLE | JS_PROP_CONFIGURABLE);
+    js_define_data(ctx, p, js_atom_from_cstr(ctx, "versions"), versions, JS_PROP_ENUMERABLE | JS_PROP_CONFIGURABLE);
+    /* features: what this build has, in Node 24's names. No inspector, TLS from
+       BoringSSL without OCSP stapling, require() of ES modules, no QUIC, no type stripping */
+    static const struct { const char *name; bool on; } features[] = {
+        { "inspector", false }, { "debug", false }, { "uv", true }, { "ipv6", true },
+        { "tls_alpn", true }, { "tls_sni", true }, { "tls_ocsp", false }, { "tls", true },
+        { "openssl_is_boringssl", true }, { "cached_builtins", true }, { "require_module", true }, { "quic", false },
+        { "typescript", false },
+    };
+    JSValue feats = js_new_object(ctx);
+    if (js_is_exception(feats)) return feats;
+    for (size_t i = 0; i < sizeof features / sizeof features[0]; i++)
+        define(ctx, js_as_object(feats), features[i].name, js_bool(features[i].on));
+    define(ctx, p, "features", feats);
     define(ctx, p, "platform", js_new_string_cstr(ctx, platform()));
     define(ctx, p, "arch", js_new_string_cstr(ctx, arch()));
     define(ctx, p, "stdout", new_stream(ctx, 1, stdout_write));
     define(ctx, p, "stderr", new_stream(ctx, 2, stderr_write));
     define_fn(ctx, p, "cwd", process_cwd, 0);
+#ifndef _WIN32
+    define_fn(ctx, p, "getuid", process_getuid, 0);
+    define_fn(ctx, p, "geteuid", process_geteuid, 0);
+    define_fn(ctx, p, "getgid", process_getgid, 0);
+    define_fn(ctx, p, "getegid", process_getegid, 0);
+#endif
     define_fn(ctx, p, "exit", process_exit, 1);
     define_fn(ctx, p, "nextTick", process_next_tick, 1);
-    define_fn(ctx, p, "hrtime", process_hrtime, 1);
+    {
+        JSValue key = js_atom_from_cstr(ctx, "hrtime");
+        JSValue hrtime = js_new_native(ctx, process_hrtime, key, 1, JS_FN_STRICT);
+        if (js_is_exception(hrtime)) return JS_EXCEPTION;
+        define_fn(ctx, js_as_object(hrtime), "bigint", process_hrtime_bigint, 0);
+        js_define_data(ctx, p, key, hrtime, JS_PROP_DEFAULT);
+    }
     define_fn(ctx, p, "emitWarning", process_emit_warning, 3);
     /* exitCode: an accessor, as in Node (enumerable, not configurable) */
     JSValue get = js_new_native(ctx, exit_code_get, js_atom_from_cstr(ctx, "get exitCode"), 0, JS_FN_STRICT);
@@ -496,7 +561,7 @@ static JSValue new_process(JSContext *ctx) {
     return process;
 }
 
-/* Node's globals the runtime doesn't have: console, process and global (ADR 0012). */
+/* Node's globals the runtime doesn't have: console, process and global. */
 int js_host_init(JSContext *ctx, int argc, char **argv) {
     saved_argc = argc;
     saved_argv = argv;

package/runtime/src/promise.c

@@ -1,4 +1,4 @@
-/* Promises (ECMAScript §27.2; ADR 0008): the promise object, reactions and their jobs,
+/* Promises (ECMAScript §27.2): the promise object, reactions and their jobs,
  * the Promise constructor, its statics and Promise.prototype. */
 #include "js_promise.h"
 
@@ -74,7 +74,7 @@ typedef struct Reaction {
     JSValue    on_rejected;   /* a function, or EMPTY: the reason passes through */
     JSValue    capability;    /* the derived promise (settled directly), a Capability cell, or undefined */
     JSValue    next;          /* the next (older) reaction, or undefined */
-    JSValue    context;       /* the async context of its then() or await, which its job runs under (ADR 0020) */
+    JSValue    context;       /* the async context of its then() or await, which its job runs under */
 } Reaction;
 
 static void reaction_visit(JSCell *c, JSTracer *trc) {
@@ -85,7 +85,7 @@ static void reaction_visit(JSCell *c, JSTracer *trc) {
     js_trace_value(trc, r->next);
     js_trace_value(trc, r->context);
 }
-static const JSCellClass reaction_class = { "PromiseReaction", reaction_visit, NULL };
+static const JSCellClass reaction_class = { "PromiseReaction", reaction_visit, NULL, NULL };
 
 static void enqueue_reaction(JSContext *ctx, JSValue reaction, JSValue argument, int state) {
     JSJob job = { JS_JOB_PROMISE_REACTION, NULL, reaction, argument, js_int32(state), JS_UNDEFINED };
@@ -198,7 +198,7 @@ static void capability_visit(JSCell *c, JSTracer *trc) {
     js_trace_value(trc, k->resolve);
     js_trace_value(trc, k->reject);
 }
-static const JSCellClass capability_class = { "PromiseCapability", capability_visit, NULL };
+static const JSCellClass capability_class = { "PromiseCapability", capability_visit, NULL, NULL };
 
 /* As a value for a reaction: the promise itself when it is settled directly. */
 static JSValue cap_store(JSContext *ctx, const Cap *cap) {

package/runtime/src/proxy.c

@@ -1,4 +1,4 @@
-/* Proxy (ECMAScript §10.5, §28.2), an optional component (ADR 0014).
+/* Proxy (ECMAScript §10.5, §28.2), an optional component.
  *
  * A proxy's class overrides every internal method (JSClass.methods, and the get_own_property,
  * define_own_property and delete_property hooks): each calls the handler's trap, or the target's

package/runtime/src/reflect.c

@@ -1,4 +1,4 @@
-/* Reflect (ECMAScript §28.1), an optional component (ADR 0014): the object internal methods as
+/* Reflect (ECMAScript §28.1), an optional component: the object internal methods as
  * functions. Each checks its target is an object, then calls the internal method. */
 #include <stdio.h>
 

package/runtime/src/regexp.c

@@ -1,4 +1,4 @@
-/* RegExp (ECMAScript §22.2), the regexp component (ADR 0015).
+/* RegExp (ECMAScript §22.2), the regexp component.
  *
  * The engine is QuickJS's libregexp (third_party/quickjs-regexp): a pattern compiles to bytecode,
  * and lre_exec runs it straight on a string's Latin-1 or UTF-16 characters. Literals arrive
@@ -33,6 +33,9 @@ typedef struct RegExpObject {
     JSValue        source;    /* [[OriginalSource]]: a string */
     const uint8_t *bytecode;  /* [[RegExpMatcher]]; its flags are [[OriginalFlags]] */
     bool           owned;     /* malloc'd (compiled at run time): the finalizer frees it */
+    bool           one_class; /* the pattern is one character class: `units` (see find_class) */
+    bool           negated;   /* ...that matches every unit from U+0100 up */
+    uint32_t       units[8];  /* its units below U+0100, a bit each */
 } RegExpObject;
 
 static void regexp_visit(JSCell *c, JSTracer *trc) { js_trace_value(trc, ((RegExpObject *)c)->source); }
@@ -232,6 +235,7 @@ static JSValue regexp_new(JSContext *ctx, JSValue proto) {
     re->source = js_empty_string();
     re->bytecode = NULL;
     re->owned = false;
+    re->one_class = false;
     js_define_data(ctx, &re->obj, JS_ATOM(lastIndex), JS_UNDEFINED, JS_PROP_WRITABLE);
     return js_object_value(&re->obj);
 }
@@ -242,11 +246,137 @@ static JSValue regexp_alloc(JSContext *ctx, JSValue new_target) {
     return js_is_exception(proto) ? proto : regexp_new(ctx, proto);
 }
 
+/* ---- One character class, matched without the engine ---------------------------------------
+ *
+ * A pattern that is a single character, or a single class of characters below U+0100, matches
+ * one code unit: builtin_exec scans for it in place of lre_exec (React's and escape-html's
+ * /["'&<>]/, a split on /[,;]/). Without i, u or v only: case folding and code points change what
+ * a character matches. The source is parsed conservatively: anything else keeps the engine. */
+
+typedef struct {
+    JSStrView v;
+    uint32_t  at;
+} Source;
+
+static int peek(const Source *s) { return s->at < s->v.length ? (int)js_view_at(s->v, s->at) : -1; }
+
+static void add_range(uint32_t units[8], int lo, int hi) {
+    for (int c = lo; c <= hi; c++) units[c >> 5] |= 1u << (c & 31);
+}
+
+enum { NOT_ONE = -1, DIGITS = -2, WORD = -3 };
+
+static int hex_digit(int c) {
+    return c >= '0' && c <= '9' ? c - '0' : c >= 'a' && c <= 'f' ? c - 'a' + 10 : c >= 'A' && c <= 'F' ? c - 'A' + 10 : -1;
+}
+
+/* The unit an escape stands for (after its backslash), DIGITS or WORD for \d and \w, or NOT_ONE. */
+static int escape_unit(Source *s, bool in_class) {
+    int c = peek(s);
+    if (c < 0) return NOT_ONE;
+    s->at++;
+    switch (c) {
+    case 'n': return '\n';
+    case 'r': return '\r';
+    case 't': return '\t';
+    case 'f': return '\f';
+    case 'v': return '\v';
+    case 'd': return DIGITS;
+    case 'w': return WORD;
+    case 'b': return in_class ? '\b' : NOT_ONE;
+    case '0': {
+        int d = peek(s);
+        return d >= '0' && d <= '9' ? NOT_ONE : 0;
+    }
+    case 'x': {
+        int h = s->at + 1 < s->v.length ? hex_digit(peek(s)) : -1;
+        int l = h >= 0 ? hex_digit((int)js_view_at(s->v, s->at + 1)) : -1;
+        if (l < 0) return NOT_ONE;
+        s->at += 2;
+        return h * 16 + l;
+    }
+    }
+    return c < 0x80 && strchr("^$\\.*+?()[]{}|/-", c) ? c : NOT_ONE;  /* a syntax character, escaped */
+}
+
+/* A class's unit (after reading it), or DIGITS / WORD (added to `units`), or NOT_ONE. */
+static int class_unit(Source *s, uint32_t units[8]) {
+    int c = peek(s);
+    s->at++;
+    if (c != '\\') return c;
+    c = escape_unit(s, true);
+    if (c == DIGITS) add_range(units, '0', '9');
+    if (c == WORD) add_range(units, '0', '9'), add_range(units, 'A', 'Z'), add_range(units, 'a', 'z'), add_range(units, '_', '_');
+    return c;
+}
+
+static void find_class(JSContext *ctx, RegExpObject *re) {
+    re->one_class = false;
+    if (lre_get_flags(re->bytecode) & (LRE_FLAG_IGNORECASE | LRE_FLAG_UNICODE | LRE_FLAG_UNICODE_SETS | LRE_FLAG_NAMED_GROUPS)) return;
+    Source s = { js_string_view(ctx, re->source), 0 };
+    uint32_t units[8] = { 0 };
+    bool negated = false;
+    int c = peek(&s);
+    if (c < 0) return;
+    s.at++;
+    if (c == '[') {
+        negated = peek(&s) == '^';
+        if (negated) s.at++;
+        for (;;) {
+            c = peek(&s);
+            if (c < 0) return;
+            if (c == ']') break;
+            int lo = class_unit(&s, units);
+            if (lo == NOT_ONE || lo >= 0x100) return;
+            if (peek(&s) == '-' && s.at + 1 < s.v.length && js_view_at(s.v, s.at + 1) != ']') {
+                s.at++;
+                int hi = class_unit(&s, units);
+                if (lo < 0 || hi < lo || hi >= 0x100) return;  /* a class escape in a range: Annex B's */
+                add_range(units, lo, hi);
+            } else if (lo >= 0) {
+                add_range(units, lo, lo);
+            }
+        }
+        s.at++;
+        if (negated)
+            for (int i = 0; i < 8; i++) units[i] = ~units[i];
+    } else if (c == '\\') {
+        Source t = { s.v, s.at - 1 };  /* from the backslash */
+        c = class_unit(&t, units);
+        s.at = t.at;
+        if (c == NOT_ONE || c == '\b' || c >= 0x100) return;  /* \b outside a class: a word boundary */
+        if (c >= 0) add_range(units, c, c);
+    } else {
+        if (c >= 0x100 || (c < 0x80 && strchr("^$.*+?()[]{}|/", c))) return;
+        add_range(units, c, c);
+    }
+    if (s.at != s.v.length) return;  /* more than the one class */
+    memcpy(re->units, units, sizeof units);
+    re->negated = negated;
+    re->one_class = true;
+}
+
+/* The first unit from `from` (only there, sticky) in the class: 1 with capture 0 set, as lre_exec. */
+static int scan_class(const RegExpObject *re, const uint8_t *buf, int shift, uint32_t from, uint32_t length, bool sticky,
+                      uint8_t **capture) {
+    uint32_t end = sticky && from < length ? from + 1 : length;
+    for (uint32_t i = from; i < end; i++) {
+        uint32_t c = shift ? ((const uint16_t *)buf)[i] : buf[i];
+        if (c < 0x100 ? (re->units[c >> 5] >> (c & 31)) & 1 : re->negated) {
+            capture[0] = (uint8_t *)buf + ((size_t)i << shift);
+            capture[1] = capture[0] + ((size_t)1 << shift);
+            return 1;
+        }
+    }
+    return 0;
+}
+
 static void set_matcher(JSContext *ctx, RegExpObject *re, JSValue source, const uint8_t *bytecode, bool owned) {
     if (re->owned) free((void *)re->bytecode);
     js_store(ctx, &re->obj.cell, &re->source, source);
     re->bytecode = bytecode;
     re->owned = owned;
+    find_class(ctx, re);
 }
 
 /* RegExpInitialize (§22.2.3.3) */
@@ -544,7 +674,9 @@ static JSValue builtin_exec(JSContext *ctx, JSValue rx, JSValue s) {
     if (!capture) js_fatal("out of memory matching a regular expression");
     int shift = v.latin1 ? 0 : 1;
     const uint8_t *buf = v.chars;
-    int rc = last_index > v.length ? 2 : lre_exec(capture, bc, buf, (int)last_index, (int)v.length, shift, ctx);
+    int rc = last_index > v.length ? 2
+           : re->one_class ? scan_class(re, buf, shift, (uint32_t)last_index, v.length, (flags & LRE_FLAG_STICKY) != 0, capture)
+           : lre_exec(capture, bc, buf, (int)last_index, (int)v.length, shift, ctx);
     JSValue result = JS_NULL;
     if (rc < 0) {
         result = throw_exec_failure(ctx, rc);

package/runtime/src/regexp_anchor.h

@@ -1,4 +1,4 @@
-/* regexp_anchor.h — a start-anchored regular expression tries one position (ADR 0015), shared
+/* regexp_anchor.h — a start-anchored regular expression tries one position, shared
  * by the runtime (new RegExp) and the compiler's regexp-compile tool (literals).
  *
  * libregexp starts a non-sticky program with a loop that tries every position:

package/runtime/src/regexp_message.h

@@ -1,4 +1,4 @@
-/* regexp_message.h — libregexp's error messages in V8's words (ADR 0015), shared by the runtime
+/* regexp_message.h — libregexp's error messages in V8's words, shared by the runtime
  * (new RegExp) and the compiler's regexp-compile tool (literals), so both report alike. */
 #ifndef JS_REGEXP_MESSAGE_H
 #define JS_REGEXP_MESSAGE_H