visaljs 0.0.9 → 0.0.11

package/runtime/src/os.h

@@ -56,5 +56,7 @@ size_t js_os_peak_rss(void);
 double js_os_time_ms(void);
 int32_t js_os_local_offset(int64_t seconds, bool *dst);
 const char *js_os_timezone_id(void);
+/* TZ changed (process.env.TZ): local time and the zone's id are looked up again. */
+void js_os_timezone_changed(void);
 
 #endif /* JS_OS_H */

package/runtime/src/process.c

@@ -197,7 +197,7 @@ static JSValue specific_type(JSContext *ctx, JSValue v) {
         JSValue s = js_concat(ctx, prefix, quoted);
         return js_is_exception(s) ? s : js_concat(ctx, s, suffix);
     }
-    const char *type = js_is_number(v) ? "number" : js_is_bool(v) ? "boolean" : "symbol";
+    const char *type = js_is_number(v) ? "number" : js_is_bool(v) ? "boolean" : js_is_symbol(v) ? "symbol" : "bigint";
     JSValue shown = js_is_symbol(v) ? js_symbol_descriptive_string(ctx, v) : js_inspect(ctx, v);
     if (js_is_exception(shown)) return shown;
     snprintf(buf, sizeof buf, "type %s (", type);
@@ -293,8 +293,7 @@ NATIVE(process_getgid) { UNUSED_ARGS; (void)ctx, (void)argc, (void)argv; return
 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. */
+/* nextTick(callback, ...args): on the tick queue, which runs before the promise jobs */
 NATIVE(process_next_tick) {
     UNUSED_ARGS;
     if (!js_is_callable(ARG(0))) return invalid_arg_type(ctx, "callback", "of type function", ARG(0));
@@ -304,7 +303,7 @@ NATIVE(process_next_tick) {
         if (js_is_exception(args)) return args;
     }
     JSJob job = { JS_JOB_CALLBACK, NULL, argv[0], args, JS_UNDEFINED, JS_UNDEFINED };
-    js_enqueue_microtask(ctx, &job);
+    js_enqueue_tick(ctx, &job);
     return JS_UNDEFINED;
 }
 
@@ -467,6 +466,88 @@ static const char *arch(void) {
 #endif
 }
 
+/* ---- process.env ------------------------------------------------------------------------------ */
+
+/* Node's process.env interceptors (src/node_env_var.cc): a value is stored as a string and set in
+ * the C environment, a delete unsets it, and only plain data properties are accepted. Reads are
+ * ordinary (no get_own_property hook), so they stay as fast as a plain object's; writes aren't
+ * cached, so each reaches env_define. */
+static bool env_populating;  /* new_process copying environ in: nothing to set */
+
+static char *env_utf8(JSContext *ctx, JSValue s) {
+    JSStrView v = js_string_view(ctx, s);
+    size_t n = js_view_to_utf8(v, NULL, 0);
+    char *out = malloc(n + 1);
+    if (!out) js_fatal("out of memory in process.env");
+    js_view_to_utf8(v, out, n + 1);
+    out[n] = '\0';
+    return out;
+}
+
+static void env_apply(JSContext *ctx, JSValue key, JSValue value) {
+    char *k = env_utf8(ctx, key);
+    if (js_is_undefined(value)) {
+#ifdef _WIN32
+        _putenv_s(k, "");
+#else
+        unsetenv(k);
+#endif
+    } else {
+        char *v = env_utf8(ctx, value);
+#ifdef _WIN32
+        _putenv_s(k, v);
+#else
+        setenv(k, v, 1);
+#endif
+        free(v);
+    }
+    if (strcmp(k, "TZ") == 0) js_os_timezone_changed();
+    free(k);
+}
+
+static int env_define(JSContext *ctx, JSObject *o, JSValue key, const JSPropertyDescriptor *desc, bool throw_on_fail) {
+    (void)throw_on_fail;
+    if (env_populating) return JS_ORDINARY;
+    if (js_is_symbol(key)) {
+        js_discard(js_throw_type_error(ctx, "Cannot convert a Symbol value to a string"));
+        return -1;
+    }
+    if (desc->has & (JS_DESC_GET | JS_DESC_SET)) {
+        js_discard(throw_with_code(ctx, JS_TYPE_ERROR, "ERR_INVALID_OBJECT_DEFINE_PROPERTY",
+                                   js_new_string_cstr(ctx, "'process.env' does not accept an accessor(getter/setter) descriptor")));
+        return -1;
+    }
+    const uint8_t all = JS_DESC_WRITABLE | JS_DESC_ENUMERABLE | JS_DESC_CONFIGURABLE;
+    bool full = (desc->has & JS_DESC_VALUE) && (desc->has & all) == all && (desc->attrs & JS_PROP_DEFAULT) == JS_PROP_DEFAULT;
+    /* an assignment to a variable already set: [[Set]] redefines it with the value alone */
+    JSPropertyDescriptor existing;
+    bool assign = (desc->has & JS_DESC_VALUE) && !(desc->has & all) && js_ordinary_get_own_property(ctx, o, key, &existing) == 1;
+    if (!full && !assign) {
+        js_discard(throw_with_code(ctx, JS_TYPE_ERROR, "ERR_INVALID_OBJECT_DEFINE_PROPERTY",
+                                   js_new_string_cstr(ctx, "'process.env' only accepts a configurable, writable, and enumerable data descriptor")));
+        return -1;
+    }
+    JSValue value = js_to_string(ctx, desc->value);
+    if (js_is_exception(value)) return -1;
+    JSValue name = js_to_string(ctx, key);
+    if (js_is_exception(name)) return -1;
+    if (js_string_length(name) == 0) return 1;  /* as Node's: setenv refuses an empty name, nothing is stored */
+    env_apply(ctx, name, value);
+    JSPropertyDescriptor d = js_data_descriptor(value, JS_PROP_DEFAULT);
+    return js_ordinary_define_own_property(ctx, o, key, &d, true);
+}
+
+static int env_delete(JSContext *ctx, JSObject *o, JSValue key, bool throw_on_fail) {
+    (void)o, (void)throw_on_fail;
+    if (env_populating || js_is_symbol(key)) return JS_ORDINARY;
+    JSValue name = js_to_string(ctx, key);
+    if (js_is_exception(name)) return -1;
+    env_apply(ctx, name, JS_UNDEFINED);
+    return JS_ORDINARY;
+}
+
+static const JSClass env_class = { "Object", sizeof(JSObject), NULL, env_define, env_delete, NULL, NULL, NULL, NULL };
+
 static JSValue new_process(JSContext *ctx) {
     JSValue process = js_new_object(ctx);
     if (js_is_exception(process)) return process;
@@ -494,9 +575,11 @@ static JSValue new_process(JSContext *ctx) {
     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) */
-    JSValue env = js_new_object(ctx);
-    if (js_is_exception(env)) return env;
+    /* env: the environment as it was at startup, in an object whose writes and deletes reach the C
+     * environment (env_class) */
+    JSValue env = js_object_value(js_alloc_object(ctx, JS_CELL_OBJECT, js_shape_root(ctx, &env_class,
+                                                  ctx->intrinsics[JS_INTRINSIC_OBJECT_PROTOTYPE], JS_DEFAULT_INLINE_SLOTS)));
+    env_populating = true;
     for (size_t i = 0; environ && environ[i]; i++) {
         const char *eq = strchr(environ[i] + 1, '=');
         if (!eq) continue;
@@ -507,6 +590,7 @@ static JSValue new_process(JSContext *ctx) {
         if (js_is_exception(key)) return key;
         js_define_data(ctx, js_as_object(env), key, value, JS_PROP_DEFAULT);
     }
+    env_populating = false;
     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,
@@ -516,13 +600,16 @@ static JSValue new_process(JSContext *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);
+    /* Node 24.21's OpenSSL: crypto is BoringSSL, but behaves as Node's (its errors and limits), so programs
+       and Node's tests see the Node they expect. Node's own check for crypto is Boolean(process.versions.openssl). */
+    js_define_data(ctx, js_as_object(versions), js_atom_from_cstr(ctx, "openssl"), js_new_string_cstr(ctx, "3.5.5"), 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 */
+    /* features: what this build has, in Node 24's names. No inspector, TLS without OCSP stapling, require()
+       of ES modules, no QUIC, no type stripping; openssl_is_boringssl false, as crypto behaves as OpenSSL's */
     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 },
+        { "openssl_is_boringssl", false }, { "cached_builtins", true }, { "require_module", true }, { "quic", false },
         { "typescript", false },
     };
     JSValue feats = js_new_object(ctx);

package/runtime/src/typedarray.c

@@ -1234,6 +1234,26 @@ static double hook_typed_array_length(JSValue v) {
     return out_of_bounds(as_ta(v)) ? -1 : (double)ta_length(as_ta(v));
 }
 
+/* An element the core may read or write inline: of a typed array, a valid index (§10.4.5.15
+ * IsValidIntegerIndex), a Number element. Its own data property: no prototype, no code runs. */
+static bool inline_elem(JSValue v, int32_t i) {
+    if (!is_ta(v) || i < 0) return false;
+    const JSTypedArray *ta = as_ta(v);
+    return !is_bigint_type(ta->type) && (size_t)i < ta_length(ta);
+}
+
+static bool hook_typed_array_get(JSValue v, int32_t i, JSValue *out) {
+    if (!inline_elem(v, i)) return false;
+    *out = js_number(load_number(as_ta(v), (size_t)i));
+    return true;
+}
+
+static bool hook_typed_array_set(JSValue v, int32_t i, double d) {
+    if (!inline_elem(v, i) || immutable(as_ta(v))) return false;
+    store(as_ta(v), (size_t)i, d);
+    return true;
+}
+
 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);
 }
@@ -1330,6 +1350,9 @@ 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;
+    ctx->rt->typed_array_get = hook_typed_array_get;
+    ctx->rt->typed_array_class = &ta_class;
+    ctx->rt->typed_array_set = hook_typed_array_set;
 }
 
 const JSComponent js_component_typedarray = { "typedarray", install_typedarray };