visaljs 0.0.9 → 0.0.10

package/node/include/js_node.h

@@ -31,6 +31,7 @@ JSValue js_host_fs_read(JSContext *ctx, JSValue callee, JSValue this_val, uint32
 int js_node_uv_error(int e);
 JSValue js_host_errno_name(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
 JSValue js_host_timer_unref(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
+JSValue js_host_loop_now(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
 JSValue js_host_timer_start(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
 JSValue js_host_timer_ref(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
 JSValue js_host_async_context_get(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);

package/node/prelude/http.js

@@ -7,6 +7,7 @@
 // upgrade (or CONNECT) hands the socket over with 'upgrade' ('connect'). Idle keep-alive
 // connections close after keepAliveTimeout; server.timeout and setTimeout are the sockets'.
 // Not yet: the client, headersTimeout and requestTimeout, trailers.
+import { hasInvalidHeaderChar, isHttpToken } from "./internal/http_chars.ts";
 import {
   httpAttach, httpBusy, httpDate, httpPending, httpWatchDrain, httpDetach, httpExpired, httpFedClose, httpFedOpen, httpFeed, httpFlush, httpParsers, httpWrite, timerUnref,
 } from "visaljs:host";
@@ -183,18 +184,16 @@ function addHeader(headers, name, value, join) {
 /* ---- OutgoingMessage: a response's (and a request's) headers ------------------------------------ */
 
 /* Node's checks: a header name is an HTTP token; a value has no control characters */
-const tokenRegExp = /^[\^_`a-zA-Z\-0-9!#$%&'*+.|~]+$/;
-const headerCharRegex = /[^\t\x20-\x7e\x80-\xff]/;
 
 export function validateHeaderName(name, label = "Header name") {
-  if (typeof name !== "string" || !name || !tokenRegExp.test(name)) {
+  if (typeof name !== "string" || !isHttpToken(name)) {
     throw codeError(TypeError, "ERR_INVALID_HTTP_TOKEN", label + " must be a valid HTTP token [\"" + name + "\"]");
   }
 }
 
 export function validateHeaderValue(name, value) {
   if (value === undefined) throw codeError(TypeError, "ERR_HTTP_INVALID_HEADER_VALUE", "Invalid value \"" + value + "\" for header \"" + name + "\"");
-  if (headerCharRegex.test(value)) throw codeError(TypeError, "ERR_INVALID_CHAR", "Invalid character in header content [\"" + name + "\"]");
+  if (hasInvalidHeaderChar(String(value))) throw codeError(TypeError, "ERR_INVALID_CHAR", "Invalid character in header content [\"" + name + "\"]");
 }
 
 const headersSent = (what) => codeError(Error, "ERR_HTTP_HEADERS_SENT", "Cannot " + what + " headers after they are sent to the client");
@@ -584,7 +583,7 @@ export class OutgoingMessage extends Stream {
       validateHeaderName(field, "Trailer name");
       const values = Array.isArray(value) && value.length > 1 ? value : [Array.isArray(value) ? value.join("; ") : value];
       for (const v of values) {
-        if (headerCharRegex.test(v)) throw codeError(TypeError, "ERR_INVALID_CHAR", "Invalid character in trailer content [\"" + field + "\"]");
+        if (hasInvalidHeaderChar(String(v))) throw codeError(TypeError, "ERR_INVALID_CHAR", "Invalid character in trailer content [\"" + field + "\"]");
         this._trailer += field + ": " + v + "\r\n";
       }
     }
@@ -1176,7 +1175,7 @@ class ServerClass extends NetServer {
     } else {
       state.res = res;
     }
-    res.once("finish", () => this._resOnFinish(state, req, res));
+    res.on("finish", () => this._resOnFinish(state, req, res));  /* Node's resOnFinish, an `on` listener too */
     if (this.requireHostHeader && major === 1 && minor === 1 && !req.headers.host) {  /* Node: a 400, and the connection ends */
       res.writeHead(400, ["Connection", "close"]);
       res.end();
@@ -1189,8 +1188,11 @@ class ServerClass extends NetServer {
   /* Node's resOnFinish: the request is done with; the next response's turn, or the idle keep-alive
    * timeout */
   _resOnFinish(state, req, res) {
-    const i = state.incoming.indexOf(req);
-    if (i !== -1) state.incoming.splice(i, 1);
+    if (state.incoming[0] === req) state.incoming.shift();
+    else {
+      const i = state.incoming.indexOf(req);
+      if (i !== -1) state.incoming.splice(i, 1);
+    }
     if (state.req === req && req.complete) state.req = null;
     if (state.res === res) state.res = null;
     if (res._last || !res._keepAlive) return;  /* the socket is ending */
@@ -1625,7 +1627,7 @@ export class ClientRequest extends OutgoingMessage {
     let method = options.method;
     if (method !== null && method !== undefined && typeof method !== "string") throw invalidArgType("options.method", "of type string", method);
     if (method) {
-      if (!tokenRegExp.test(method)) throw codeError(TypeError, "ERR_INVALID_HTTP_TOKEN", "Method must be a valid HTTP token [\"" + method + "\"]");
+      if (!isHttpToken(method)) throw codeError(TypeError, "ERR_INVALID_HTTP_TOKEN", "Method must be a valid HTTP token [\"" + method + "\"]");
       method = this.method = method.toUpperCase();
     } else {
       method = this.method = "GET";

package/node/prelude/internal/http_chars.ts

@@ -0,0 +1,22 @@
+"use static";
+// The characters HTTP allows in header names (a token, RFC 9110 §5.6.2) and values: Node's
+// tokenRegExp and headerCharRegex as loops, typed (setHeader checks both on every call).
+
+export function isHttpToken(s: string): boolean {
+  for (let i = 0; i < s.length; i++) {
+    const c = s.charCodeAt(i);
+    const alnum = (c >= 48 && c <= 57) || (c >= 65 && c <= 90) || (c >= 97 && c <= 122);
+    /* ! # $ % & ' * + - . ^ _ ` | ~ */
+    if (!alnum && c !== 33 && !(c >= 35 && c <= 39) && c !== 42 && c !== 43 && c !== 45 && c !== 46 && c !== 94 && c !== 95 && c !== 96 && c !== 124 && c !== 126) return false;
+  }
+  return s.length > 0;
+}
+
+/** A character outside tab, 0x20-0x7e and 0x80-0xff. */
+export function hasInvalidHeaderChar(s: string): boolean {
+  for (let i = 0; i < s.length; i++) {
+    const c = s.charCodeAt(i);
+    if ((c < 32 && c !== 9) || c === 127 || c > 255) return true;
+  }
+  return false;
+}

package/node/prelude/net.js

@@ -9,7 +9,7 @@
 // Ported from Node.js (Copyright Node.js contributors, MIT): node/third_party/nodejs/LICENSE.
 import {
   errnoMessage, errnoName, netAddress, netBind, netCallback, netChmod, netClose, netConnect, netGuessHandle, netKeepAlive, netListen,
-  netFd, netNoDelay, netOpen, netOpenFd, netReadStart, netReadStop, netRef, netReset, netShutdown, netWrite, timerUnref,
+  loopNow, netFd, netNoDelay, netOpen, netOpenFd, netReadStart, netReadStop, netRef, netReset, netShutdown, netWrite, timerUnref,
 } from "visaljs:host";
 import { ADDRCONFIG, lookup } from "./dns.js";
 import { EventEmitter } from "./events.js";
@@ -30,12 +30,6 @@ const UV_EOF = -4095;
 const UV_EINVAL = -22;
 const TIMEOUT_MAX = 2 ** 31 - 1;
 
-/* a monotonic clock in ms */
-const now = () => {
-  const [seconds, nanoseconds] = process.hrtime();
-  return seconds * 1e3 + nanoseconds / 1e6;
-};
-
 /* ---- Node's error shapes ------------------------------------------------------------------- */
 
 /** `read ECONNRESET` */
@@ -210,7 +204,8 @@ class SocketClass extends Duplex {
     this._keepAlive = options.keepAlive === true ? [true, ~~((options.keepAliveInitialDelay ?? 0) / 1000)] : null;
     this._unref = false;
     this._timer = null;         /* the timeout: an unref'd timer, re-armed for the idle time left when it fires */
-    this._timeoutMs = 0;
+    this._timerDue = 0;         /* when _timer fires (loopNow's clock) */
+    this._timeoutMs = 0;        /* 0: off; a pending _timer then finds nothing to do */
     this._lastActive = 0;
     this._onread = null;
     if (options.typeOfService !== undefined) feature("validateTypeOfService")(options.typeOfService);
@@ -468,16 +463,19 @@ class SocketClass extends Duplex {
     if (typeof msecs !== "number") throw invalidArgType("msecs", "of type number", msecs);
     if (!(msecs >= 0 && msecs !== Infinity)) throw outOfRange("msecs", "a non-negative finite number", msecs);
     if (msecs > TIMEOUT_MAX) msecs = TIMEOUT_MAX;
-    this._clearTimeout();
+    /* the pending timer stays when it fires no later than the new deadline: _onTimer re-arms it
+     * for the rest, so a keep-alive socket, off for each request and on after it, sets no timer */
     if (msecs === 0) {
+      this._timeoutMs = 0;
       if (callback !== undefined) {
         validateFunction(callback, "callback");
         this.removeListener("timeout", callback);
       }
     } else {
       this._timeoutMs = msecs;
-      this._lastActive = now();
-      this._armTimeout(msecs);
+      this._lastActive = loopNow();
+      if (this._timer !== null && this._timerDue > this._lastActive + msecs) this._stopTimer();
+      if (this._timer === null) this._armTimeout(msecs);
       if (callback !== undefined) {
         validateFunction(callback, "callback");
         this.once("timeout", callback);
@@ -487,26 +485,32 @@ class SocketClass extends Duplex {
   }
 
   _armTimeout(ms) {
+    this._timerDue = loopNow() + ms;
     this._timer = timerUnref(() => this._onTimer(), ms);
   }
 
   _onTimer() {
     this._timer = null;
-    const idle = now() - this._lastActive;
+    if (this._timeoutMs === 0) return;
+    const idle = loopNow() - this._lastActive;
     if (idle < this._timeoutMs - 1) this._armTimeout(this._timeoutMs - idle);
     else this.emit("timeout");
   }
 
-  _clearTimeout() {
+  _stopTimer() {
     if (this._timer !== null) clearTimeout(this._timer);
     this._timer = null;
+  }
+
+  _clearTimeout() {
+    this._stopTimer();
     this._timeoutMs = 0;
   }
 
   /* activity: the timeout counts from now (Node's timer.refresh(), which re-arms a fired one) */
   _unrefTimer() {
     if (this._timeoutMs) {
-      this._lastActive = now();
+      this._lastActive = loopNow();
       if (this._timer === null) this._armTimeout(this._timeoutMs);
     }
   }

package/node/src/host_sys.c

@@ -19,6 +19,7 @@
 #include "jscontext.h"
 #include "js_ops.h"
 #include "jsstring.h"
+#include "js_uv.h"
 
 /* Each error by its C errno and its libuv code: the same number on POSIX, but on Windows libuv
  * has codes of its own (UV_ECONNREFUSED is -4078) while the C library's errno has the C values. */
@@ -155,6 +156,14 @@ JSValue js_host_timer_unref(JSContext *ctx, JSValue callee, JSValue this_val, ui
     return js_int32((int32_t)js_add_timer(ctx, argv[0], js_as_number(argv[1]), true));
 }
 
+/* loopNow() → libuv's time in ms, as of the last poll (Node's getLibuvNow): what a socket's
+ * activity is measured with, without a clock read or an allocation per read and write */
+JSValue js_host_loop_now(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv,
+                         JSValue new_target) {
+    (void)callee, (void)this_val, (void)argc, (void)argv, (void)new_target;
+    return js_number((double)uv_now(js_uv_loop(ctx)));
+}
+
 /* the id a timer primitive takes: a positive int32, else 0 */
 static uint32_t timer_id(uint32_t argc, const JSValue *argv, uint32_t i) {
     return i < argc && js_is_int32(argv[i]) && js_as_int32(argv[i]) > 0 ? (uint32_t)js_as_int32(argv[i]) : 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "visaljs",
-  "version": "0.0.9",
+  "version": "0.0.10",
   "description": "Ahead-of-time JavaScript to C compiler: the command line",
   "license": "MIT",
   "repository": {

package/runtime/include/js_buffer.h

@@ -10,7 +10,9 @@
 #include <stdint.h>
 #include <string.h>
 
+#include "js_convert.h"
 #include "js_object.h"
+#include "js_ops.h"
 
 #define JS_BUFFER_RESIZABLE 0x01u
 #define JS_BUFFER_DETACHED  0x02u
@@ -76,4 +78,187 @@ int js_typed_array_type(JSValue v);
 /* A new, zeroed Uint8Array of `length` bytes; its bytes are js_buffer_source_bytes'. */
 JS_WARN_UNUSED JSValue js_new_uint8_array(JSContext *ctx, size_t length);
 
+/* ---- Generated code: a typed array's elements inline ------------------------------------------ */
+
+/* The bytes of element i of a typed array generated code may read or write inline: a view of a
+ * fixed-size buffer (it can't shrink below the view, so i < length is in bounds), not detached,
+ * not immutable (for a write). NULL for anything else, which takes js_get_elem / js_set_elem. */
+static JS_FAST_PATH uint8_t *js_ta_inline_elem(JSContext *ctx, JSValue obj, int32_t i, bool write) {
+    if (!js_is_object(obj) || js_as_object(obj)->shape->cls != ctx->rt->typed_array_class) return NULL;
+    const JSTypedArray *ta = (const JSTypedArray *)js_as_object(obj);
+    const JSArrayBuffer *b = js_as_array_buffer(ta->buffer);
+    uint32_t bad = JS_BUFFER_DETACHED | JS_BUFFER_RESIZABLE | (write ? JS_BUFFER_IMMUTABLE : 0);
+    if (ta->length_tracking || i < 0 || (size_t)i >= ta->length || (b->flags & bad)) return NULL;
+    return b->data + ta->byte_offset;
+}
+
+/* obj[i]: a dense array's element or a typed array's (Int8, Uint8, Int32, Float64) inline. */
+static JS_FAST_PATH JSValue js_get_index_ta(JSContext *ctx, JSValue obj, JSValue key) {
+    if (JS_LIKELY(js_is_int32(key)) && !js_is_array(obj)) {
+        int32_t i = js_as_int32(key);
+        const uint8_t *p = js_ta_inline_elem(ctx, obj, i, false);
+        if (p) switch (((const JSTypedArray *)js_as_object(obj))->type) {
+            case JS_TA_UINT8: case JS_TA_UINT8C: return js_int32(p[i]);
+            case JS_TA_INT8: return js_int32((int8_t)p[i]);
+            case JS_TA_INT32: { int32_t v; memcpy(&v, p + 4 * (size_t)i, 4); return js_int32(v); }
+            case JS_TA_FLOAT64: { double v; memcpy(&v, p + 8 * (size_t)i, 8); return js_number(v); }
+            default: break;
+        }
+    }
+    return js_get_index(ctx, obj, key);
+}
+
+/* obj[i] = v: the same, for a Number v (no ToNumber code to run). */
+static JS_FAST_PATH int js_set_index_ta(JSContext *ctx, JSValue obj, JSValue key, JSValue v, bool strict) {
+    if (JS_LIKELY(js_is_int32(key)) && js_is_number(v) && !js_is_array(obj)) {
+        int32_t i = js_as_int32(key);
+        uint8_t *p = js_ta_inline_elem(ctx, obj, i, true);
+        if (p) switch (((const JSTypedArray *)js_as_object(obj))->type) {
+            case JS_TA_UINT8: case JS_TA_INT8: p[i] = (uint8_t)(js_is_int32(v) ? js_as_int32(v) : js_double_to_int32(js_as_number(v))); return 1;
+            case JS_TA_INT32: { int32_t x = js_is_int32(v) ? js_as_int32(v) : js_double_to_int32(js_as_number(v)); memcpy(p + 4 * (size_t)i, &x, 4); return 1; }
+            case JS_TA_FLOAT64: { double x = js_as_number(v); memcpy(p + 8 * (size_t)i, &x, 8); return 1; }
+            default: break;
+        }
+    }
+    return js_set_index(ctx, obj, key, v, strict);
+}
+
+/* The same with a double key (an unboxed index): an integral one is the int32 key (-0 too: "0"). */
+static inline JSValue js_get_index_ta_f64(JSContext *ctx, JSValue obj, double key) {
+    int32_t i = (int32_t)key;
+    if (key >= -2147483648.0 && key <= 2147483647.0 && (double)i == key) return js_get_index_ta(ctx, obj, js_int32(i));
+    return js_get_index_f64(ctx, obj, key);
+}
+static inline int js_set_index_ta_f64(JSContext *ctx, JSValue obj, double key, JSValue v, bool strict) {
+    int32_t i = (int32_t)key;
+    if (key >= -2147483648.0 && key <= 2147483647.0 && (double)i == key) return js_set_index_ta(ctx, obj, js_int32(i), v, strict);
+    return js_set_index_f64(ctx, obj, key, v, strict);
+}
+
+/* A typed array's elements as generated code holds them (the typed-arrays pass): taken once,
+ * for an array nothing else can reach, so nothing detaches or resizes its buffer. Empty (length
+ * 0) when the value isn't a typed array of that type: every access then takes the generic path. */
+typedef struct JSTAView {
+    uint8_t *base;
+    size_t   length;
+    int      type;   /* the element type it's for: a slow path that may have run code takes it again */
+} JSTAView;
+
+static inline JSTAView js_ta_view(JSContext *ctx, JSValue obj, int type) {
+    JSTAView v = { NULL, 0, type };
+    if (!js_is_object(obj) || js_as_object(obj)->shape->cls != ctx->rt->typed_array_class) return v;
+    const JSTypedArray *ta = (const JSTypedArray *)js_as_object(obj);
+    const JSArrayBuffer *b = js_as_array_buffer(ta->buffer);
+    if (ta->type != type || ta->length_tracking || (b->flags & (JS_BUFFER_DETACHED | JS_BUFFER_RESIZABLE | JS_BUFFER_IMMUTABLE)) || !b->data) return v;
+    v.base = b->data + ta->byte_offset;
+    v.length = ta->length;
+    return v;
+}
+
+/* Whether v is a typed array of that element type (a typed function's typed array parameter). */
+static inline bool js_ta_is(JSContext *ctx, JSValue v, int type) {
+    return js_is_object(v) && js_as_object(v)->shape->cls == ctx->rt->typed_array_class && ((const JSTypedArray *)js_as_object(v))->type == type;
+}
+
+/* The index a key names when it's in the view, else false. */
+static JS_FAST_PATH bool js_tav_index(const JSTAView *v, JSValue key, size_t *i) {
+    if (!js_is_int32(key) || js_as_int32(key) < 0 || (size_t)js_as_int32(key) >= v->length) return false;
+    *i = (size_t)js_as_int32(key);
+    return true;
+}
+static JS_FAST_PATH bool js_tav_index_d(const JSTAView *v, double key, size_t *i) {
+    if (!(key >= 0 && key < (double)v->length) || (double)(size_t)key != key) return false;
+    *i = (size_t)key;
+    return true;
+}
+
+/* Each element type's read and write (a Number, converted as the spec's NumericToRawBytes). */
+#define JS_TAV_ACCESS(name, ctype, box, unbox)                                                          \
+    static JS_FAST_PATH JSValue js_tav_get_##name(JSContext *ctx, JSTAView *v, JSValue obj, JSValue key) { \
+        size_t i;                                                                                        \
+        if (JS_LIKELY(js_tav_index(v, key, &i))) { ctype x; memcpy(&x, v->base + i * sizeof x, sizeof x); return box(x); } \
+        JSValue r = js_get_elem(ctx, obj, key);                                                          \
+        *v = js_ta_view(ctx, obj, v->type);  /* a getter may have run */                                 \
+        return r;                                                                                        \
+    }                                                                                                    \
+    static JS_FAST_PATH JSValue js_tav_get_##name##_d(JSContext *ctx, JSTAView *v, JSValue obj, double key) { \
+        size_t i;                                                                                        \
+        if (JS_LIKELY(js_tav_index_d(v, key, &i))) { ctype x; memcpy(&x, v->base + i * sizeof x, sizeof x); return box(x); } \
+        JSValue r = js_get_elem(ctx, obj, js_number(key));                                               \
+        *v = js_ta_view(ctx, obj, v->type);                                                              \
+        return r;                                                                                        \
+    }                                                                                                    \
+    static JS_FAST_PATH JSValue js_tav_get_##name##_i(JSContext *ctx, JSTAView *v, JSValue obj, int32_t key) { \
+        if (JS_LIKELY((uint32_t)key < v->length)) { ctype x; memcpy(&x, v->base + (size_t)(uint32_t)key * sizeof x, sizeof x); return box(x); } \
+        JSValue r = js_get_elem(ctx, obj, js_int32(key));                                                \
+        *v = js_ta_view(ctx, obj, v->type);                                                              \
+        return r;                                                                                        \
+    }                                                                                                    \
+    static JS_FAST_PATH int js_tav_set_##name##_i(JSContext *ctx, JSTAView *v, JSValue obj, int32_t key, JSValue val, bool strict) { \
+        if (JS_LIKELY(js_is_number(val) && (uint32_t)key < v->length)) { ctype x = unbox(val); memcpy(v->base + (size_t)(uint32_t)key * sizeof x, &x, sizeof x); return 1; } \
+        int r = js_set_elem(ctx, obj, js_int32(key), val, strict);                                       \
+        *v = js_ta_view(ctx, obj, v->type);                                                              \
+        return r;                                                                                        \
+    }                                                                                                    \
+    static JS_FAST_PATH JSValue js_tav_get_##name##_l(JSContext *ctx, JSTAView *v, JSValue obj, int64_t key) { \
+        if (JS_LIKELY((uint64_t)key < v->length)) { ctype x; memcpy(&x, v->base + (size_t)key * sizeof x, sizeof x); return box(x); } \
+        JSValue r = js_get_elem(ctx, obj, js_number((double)key));                                       \
+        *v = js_ta_view(ctx, obj, v->type);                                                              \
+        return r;                                                                                        \
+    }                                                                                                    \
+    static JS_FAST_PATH int js_tav_set_##name##_l(JSContext *ctx, JSTAView *v, JSValue obj, int64_t key, JSValue val, bool strict) { \
+        if (JS_LIKELY(js_is_number(val) && (uint64_t)key < v->length)) { ctype x = unbox(val); memcpy(v->base + (size_t)key * sizeof x, &x, sizeof x); return 1; } \
+        int r = js_set_elem(ctx, obj, js_number((double)key), val, strict);                              \
+        *v = js_ta_view(ctx, obj, v->type);                                                              \
+        return r;                                                                                        \
+    }                                                                                                    \
+    static JS_FAST_PATH int js_tav_set_##name(JSContext *ctx, JSTAView *v, JSValue obj, JSValue key, JSValue val, bool strict) { \
+        size_t i;                                                                                        \
+        if (JS_LIKELY(js_is_number(val) && js_tav_index(v, key, &i))) { ctype x = unbox(val); memcpy(v->base + i * sizeof x, &x, sizeof x); return 1; } \
+        int r = js_set_elem(ctx, obj, key, val, strict);  /* valueOf, a setter: they may have run */    \
+        *v = js_ta_view(ctx, obj, v->type);                                                              \
+        return r;                                                                                        \
+    }                                                                                                    \
+    static JS_FAST_PATH int js_tav_set_##name##_d(JSContext *ctx, JSTAView *v, JSValue obj, double key, JSValue val, bool strict) { \
+        size_t i;                                                                                        \
+        if (JS_LIKELY(js_is_number(val) && js_tav_index_d(v, key, &i))) { ctype x = unbox(val); memcpy(v->base + i * sizeof x, &x, sizeof x); return 1; } \
+        int r = js_set_elem(ctx, obj, js_number(key), val, strict);                                      \
+        *v = js_ta_view(ctx, obj, v->type);                                                              \
+        return r;                                                                                        \
+    }
+static JS_FAST_PATH int32_t js_tav_to_int32(JSValue v) { return js_is_int32(v) ? js_as_int32(v) : js_double_to_int32(js_as_number(v)); }
+#define JS_TAV_INT(x) js_int32((int32_t)(x))
+JS_TAV_ACCESS(i8, int8_t, JS_TAV_INT, (int8_t)js_tav_to_int32)
+JS_TAV_ACCESS(u8, uint8_t, JS_TAV_INT, (uint8_t)js_tav_to_int32)
+JS_TAV_ACCESS(i32, int32_t, JS_TAV_INT, js_tav_to_int32)
+JS_TAV_ACCESS(f64, double, js_number, js_as_number)
+
+/* A Float64Array's element as a double, for typed code ("use static": its type is number):
+ * past the end, undefined as a number (NaN). False with an exception pending. And a store of a
+ * double, boxed only on the slow path. */
+static inline bool js_tav_num_slow(JSContext *ctx, JSTAView *v, JSValue obj, JSValue key, double *out) {
+    JSValue r = js_get_elem(ctx, obj, key);
+    *v = js_ta_view(ctx, obj, v->type);
+    if (js_is_exception(r)) return false;
+    if (js_is_number(r)) { *out = js_as_number(r); return true; }
+    return js_to_number(ctx, out, r) == 0;
+}
+#define JS_TAV_F64(suffix, ktype, in_view, boxed_key)                                                   \
+    static JS_FAST_PATH bool js_tav_num_f64##suffix(JSContext *ctx, JSTAView *v, JSValue obj, ktype key, double *out) { \
+        size_t i;                                                                                        \
+        if (JS_LIKELY(in_view)) { memcpy(out, v->base + i * 8, 8); return true; }                        \
+        return js_tav_num_slow(ctx, v, obj, boxed_key, out);                                            \
+    }                                                                                                    \
+    static JS_FAST_PATH int js_tav_put_f64##suffix(JSContext *ctx, JSTAView *v, JSValue obj, ktype key, double x, bool strict) { \
+        size_t i;                                                                                        \
+        if (JS_LIKELY(in_view)) { memcpy(v->base + i * 8, &x, 8); return 1; }                            \
+        int r = js_set_elem(ctx, obj, boxed_key, js_number(x), strict);                                  \
+        *v = js_ta_view(ctx, obj, v->type);                                                              \
+        return r;                                                                                        \
+    }
+JS_TAV_F64(, JSValue, js_tav_index(v, key, &i), key)
+JS_TAV_F64(_d, double, js_tav_index_d(v, key, &i), js_number(key))
+JS_TAV_F64(_i, int32_t, ((i = (size_t)(uint32_t)key) < v->length), js_int32(key))
+JS_TAV_F64(_l, int64_t, ((i = (size_t)(uint64_t)key) < v->length), js_number((double)key))
+
 #endif /* JS_BUFFER_H */

package/runtime/include/js_builtins.h

@@ -211,6 +211,59 @@ static inline JSValue js_call_char_code_at(JSContext *ctx, JSValue f, JSValue s,
     return js_call_site(ctx, f, s, 1, &i, site);
 }
 
+/* s.charCodeAt(i) in typed code ("use static"), which trusts the built-ins to be the standard
+ * ones (char_code_at): s is a string; its unit read inline, else (a rope, an index out of
+ * range) the built-in's answer. */
+static inline double js_string_char_code_at(JSContext *ctx, JSValue s, double i) {
+    JSStrView v;
+    if (JS_LIKELY(i >= 0 && i < 4294967295.0 && js_string_units(s, &v) && (uint32_t)i < v.length && (double)(uint32_t)i == i))
+        return (double)js_view_at(v, (uint32_t)i);
+    JSValue index = js_number(i);
+    return js_as_number(js_core_string_proto_char_code_at(ctx, JS_UNDEFINED, s, 1, &index, JS_UNDEFINED));
+}
+
+/* s.charCodeAt(i) in typed code for an index the optimizer proved in s: the unit, an int32 (a
+ * rope not yet flattened takes the built-in). */
+static inline int32_t js_string_unit_at(JSContext *ctx, JSValue s, uint32_t i) {
+    JSStrView v;
+    if (JS_LIKELY(js_string_units(s, &v))) return (int32_t)js_view_at(v, i);
+    return (int32_t)js_string_char_code_at(ctx, s, (double)i);
+}
+
+/* Function.prototype.apply and call: generated code tells them by their entry. */
+JSValue js_function_proto_apply(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
+JSValue js_function_proto_call(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
+
+/* f.apply(t, args), `m` the value of f.apply: when m is the built-in and f callable, f is called
+ * without the built-in in between, with a short dense array's elements copied to the stack (its
+ * elements are its own data properties: reading them runs no code; copied, as f may change the
+ * array). Anything else is the call of m. */
+static inline JSValue js_call_apply(JSContext *ctx, JSValue m, JSValue f, JSValue t, JSValue args, const char *site) {
+    if (JS_LIKELY(js_is_function(m) && js_as_function(m)->entry == js_function_proto_apply && js_is_callable(f))) {
+        if (js_is_nullish(args)) return js_call(ctx, f, t, 0, NULL);
+        if (js_is_array(args)) {
+            JSObject *a = js_as_object(args);
+            JSElements *e = a->elements;
+            uint32_t n = js_array_length(a);
+            JSValue copy[8];
+            if (e->kind == JS_ELEMENTS_DENSE && e->length == n && n <= 8) {
+                uint32_t i = 0;
+                while (i < n && !js_is_empty(e->data[i])) copy[i] = e->data[i], i++;
+                if (i == n) return js_call(ctx, f, t, n, copy);
+            }
+        }
+    }
+    return js_call_site(ctx, m, f, 2, (const JSValue[]){ t, args }, site);
+}
+
+/* f.call(t, …), `m` the value of f.call: f called directly when m is the built-in and f callable.
+ * argv: t, then the arguments. */
+static inline JSValue js_call_call(JSContext *ctx, JSValue m, JSValue f, uint32_t argc, const JSValue *argv, const char *site) {
+    if (JS_LIKELY(js_is_function(m) && js_as_function(m)->entry == js_function_proto_call && js_is_callable(f)))
+        return js_call(ctx, f, argc ? argv[0] : JS_UNDEFINED, argc ? argc - 1 : 0, argc ? argv + 1 : NULL);
+    return js_call_site(ctx, m, f, argc, argv, site);
+}
+
 /* String.fromCharCode(c): a unit up to 0xFF is a static one-unit string. */
 static inline JSValue js_call_from_char_code(JSContext *ctx, JSValue f, JSValue this_val, JSValue c, const char *site) {
     if (JS_LIKELY(js_is_function(f) && js_as_function(f)->entry == js_core_string_from_char_code && js_is_int32(c)

package/runtime/include/js_exception.h

@@ -28,6 +28,9 @@ JS_WARN_UNUSED JSValue js_throw_reference_error(JSContext *ctx, const char *fmt,
 JS_WARN_UNUSED JSValue js_throw_syntax_error(JSContext *ctx, const char *fmt, ...);
 JS_WARN_UNUSED JSValue js_throw_uri_error(JSContext *ctx, const char *fmt, ...);
 JS_WARN_UNUSED JSValue js_throw_stack_overflow(JSContext *ctx);  /* RangeError: Maximum call stack size exceeded */
+/* ERR_INVALID_ARG_TYPE: `The "dest" argument must be <expected>. Received …` (Node's wording
+ * of the value). Generated code calls it: a "use static" function's checked entry. */
+JS_WARN_UNUSED JSValue js_throw_invalid_arg_type(JSContext *ctx, const char *name, const char *expected, JSValue value);
 
 /* ---- Catching ---------------------------------------------------------- */
 

package/runtime/include/js_function.h

@@ -79,7 +79,7 @@ typedef struct JSFunction {       /* kind = FUNCTION */
     JSContext             *realm;        /* the realm the function was created in */
     uint32_t               flags;
     uint32_t               pad_;
-    struct JSShape        *instance_shape;  /* a class's instances' root shape, made at its first `new` (js_new_class_instance) */
+    struct JSShape        *instance_shape;  /* the root shape of the objects `new` makes with it as new.target: inline slots for all their constructors add */
 } JSFunction;
 
 extern const JSClass js_class_function;

package/runtime/include/js_object.h

@@ -296,10 +296,10 @@ JS_WARN_UNUSED JSValue js_own_keys(JSContext *ctx, JSObject *o);
 #define JS_IC_EMPTY  0
 #define JS_IC_OWN    1  /* get: an own data property; set: an own writable data property */
 #define JS_IC_PROTO  2  /* get: a data property of `holder`, `depth` prototypes up */
-#define JS_IC_ADD    3  /* set: adding the key takes the receiver from `shape` to `next` */
+#define JS_IC_ADD    3  /* set: adding the key takes the receiver from `shape` to `next`; `depth` prototypes up to null, or to one whose writable data property it shadows */
 #define JS_IC_GETTER 4  /* get: an accessor of `holder` (NULL: the receiver), `depth` prototypes up */
 #define JS_IC_ABSENT 5  /* get: no such property on the receiver or its `depth` prototypes (the last's proto is null) */
-#define JS_IC_MAX_DEPTH 4
+#define JS_IC_MAX_DEPTH 8  /* prototypes a cache can check: Node's sockets are 6 deep (Socket, Duplex, Readable, Stream, EventEmitter, Object) */
 
 /* One per property access site with a constant named key; a site is either a get or a
  * set. Monomorphic: a miss refills it. Never caches dictionary shapes (their layout
@@ -314,7 +314,7 @@ typedef struct JSPropCache {
     JSShape  *fast;                     /* OWN, inline slot: the receiver shape; else NULL */
     uint16_t  fast_off;                 /* with `fast`: the slot's byte offset in the object */
     uint8_t   kind;                     /* JS_IC_* */
-    uint8_t   depth;                    /* PROTO: hops to the holder; ADD: prototypes up to null */
+    uint8_t   depth;                    /* PROTO: hops to the holder; ADD: prototypes checked (JS_IC_ADD) */
     uint32_t  slot;                     /* OWN, PROTO: the slot */
     JSShape  *shape;                    /* receiver shape; NULL = empty */
     JSObject *holder;                   /* PROTO */
@@ -326,6 +326,8 @@ typedef struct JSPropCache {
 /* A module's caches, once at startup (the GC resets them weakly). */
 void js_register_prop_caches(JSRuntime *rt, JSPropCache *ics, size_t n);
 
+/* The slow paths of a named access: `ic` is the site's cache, or NULL for a computed key's access
+ * (the runtime's shared caches only). */
 JS_WARN_UNUSED JSValue js_get_prop_slow(JSContext *ctx, JSValue obj, JSValue key, JSPropCache *ic);
 JS_WARN_UNUSED int js_set_prop_slow(JSContext *ctx, JSValue obj, JSValue key, JSValue v, bool strict, JSPropCache *ic);
 
@@ -373,6 +375,22 @@ static inline int js_set_prop(JSContext *ctx, JSValue obj, JSValue key, JSValue
     return js_set_prop_slow(ctx, obj, key, v, strict, ic);
 }
 
+/* obj[key] and obj[key] = v at a site whose key is most likely always the same symbol or string
+ * (the optimizer's guess: a module binding stored once, as Node's kState). `site` holds the key
+ * the site's cache is for (EMPTY: none yet): while the key is that one, the access is a named
+ * access's, inline cache and all. Another key the slow path makes the site's, or, when it isn't
+ * a property key already (an index, a string not interned), accesses generically. */
+JS_WARN_UNUSED JSValue js_get_keyed_slow(JSContext *ctx, JSValue obj, JSValue key, JSValue *site, JSPropCache *ic);
+JS_WARN_UNUSED int js_set_keyed_slow(JSContext *ctx, JSValue obj, JSValue key, JSValue v, bool strict, JSValue *site, JSPropCache *ic);
+static inline JSValue js_get_keyed(JSContext *ctx, JSValue obj, JSValue key, JSValue *site, JSPropCache *ic) {
+    if (JS_LIKELY(js_same_bits(key, *site))) return js_get_prop(ctx, obj, key, ic);
+    return js_get_keyed_slow(ctx, obj, key, site, ic);
+}
+static inline int js_set_keyed(JSContext *ctx, JSValue obj, JSValue key, JSValue v, bool strict, JSValue *site, JSPropCache *ic) {
+    if (JS_LIKELY(js_same_bits(key, *site))) return js_set_prop(ctx, obj, key, v, strict, ic);
+    return js_set_keyed_slow(ctx, obj, key, v, strict, site, ic);
+}
+
 /* An object's new shape. When the object is a prototype, caches that checked the chain it's on
  * may be stale: the runtime's proto_epoch moves on. */
 static JS_FAST_PATH void js_object_set_shape(JSContext *ctx, JSObject *o, JSShape *s) {

package/runtime/include/js_ops.h

@@ -46,6 +46,33 @@ JS_WARN_UNUSED JSValue js_ge(JSContext *ctx, JSValue a, JSValue b);
 /* ===, !==: never throw (strings compare by content). */
 bool js_strict_equals(JSContext *ctx, JSValue a, JSValue b);
 static inline JSValue js_strict_eq(JSContext *ctx, JSValue a, JSValue b) { return js_bool(js_strict_equals(ctx, a, b)); }
+/* A Number as a typed file's ("use static") int, an int64_t: truncated toward zero and wrapped
+ * modulo 2^64, as ToInt32 is for 32 bits; NaN and the infinities 0 (a plain C conversion of those
+ * would be undefined behaviour). */
+static inline int64_t js_f64_to_i64(double d) {
+    if (d >= -9223372036854775808.0 && d < 9223372036854775808.0) return (int64_t)d;
+    if (d != d || d == INFINITY || d == -INFINITY) return 0;
+    double m = fmod(trunc(d), 18446744073709551616.0);  /* exact: d is an integer this large */
+    if (m < 0) m += 18446744073709551616.0;
+    return (int64_t)(uint64_t)m;
+}
+/* A Number value as an int; anything else (typed code's caller passed it unchecked) 0. */
+static inline int64_t js_value_to_i64(JSValue v) {
+    if (js_is_int32(v)) return js_as_int32(v);
+    return js_is_number(v) ? js_f64_to_i64(js_as_number(v)) : 0;
+}
+
+/* v === d, d a number literal (not NaN): v is a Number of that value (0 and -0 alike). */
+static inline bool js_strict_eq_num(JSValue v, double d) {
+    if (js_is_int32(v)) return (double)js_as_int32(v) == d;
+    return js_is_number(v) && js_as_number(v) == d;
+}
+
+/* a === s, s a string literal: an atom, so a string with its units is s itself unless it isn't
+ * interned */
+static inline bool js_strict_eq_atom(JSContext *ctx, JSValue a, JSValue s) {
+    return js_same_bits(a, s) || (js_is_string(a) && !js_is_atom(a) && js_string_equals(ctx, a, s));
+}
 static inline JSValue js_strict_ne(JSContext *ctx, JSValue a, JSValue b) { return js_bool(!js_strict_equals(ctx, a, b)); }
 
 /* A switch whose cases are all string literals: the index of the first case `v` is === to, or

package/runtime/include/js_runtime.h

@@ -17,6 +17,7 @@
 #include "js_console.h"
 #include "js_ops.h"
 #include "js_object.h"
+#include "js_buffer.h"
 #include "js_function.h"
 #include "js_error.h"
 #include "js_generator.h"

package/runtime/include/js_web.h

@@ -13,9 +13,6 @@
 JS_WARN_UNUSED JSValue js_throw_node_error(JSContext *ctx, JSErrorKind kind, const char *code, const char *fmt, ...);
 /* ERR_INVALID_THIS: `Value of "this" must be of type TextDecoder`. */
 JS_WARN_UNUSED JSValue js_throw_invalid_this(JSContext *ctx, const char *type);
-/* ERR_INVALID_ARG_TYPE: `The "dest" argument must be <expected>. Received …` (Node's wording
- * of the value). */
-JS_WARN_UNUSED JSValue js_throw_invalid_arg_type(JSContext *ctx, const char *name, const char *expected, JSValue value);
 /* Node's "Received …" tail for a value: " Received type number (1)", " Received an instance of
  * Array", " Received undefined". */
 void js_node_received(JSContext *ctx, JSValue v, char *buf, size_t cap);