visaljs 0.0.9 → 0.0.11

package/node/include/js_node.h

@@ -16,6 +16,7 @@ JSValue js_host_fs_stat(JSContext *ctx, JSValue callee, JSValue this_val, uint32
 JSValue js_host_fs_readdir(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
 JSValue js_host_fs_read_at(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
 JSValue js_host_process_memory(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
+JSValue js_host_preview_entries(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
 JSValue js_host_fs_realpath(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
 JSValue js_host_fs_mkdir(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
 JSValue js_host_fs_utimes(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
@@ -31,6 +32,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);
@@ -86,12 +88,21 @@ JSValue js_host_net_keep_alive(JSContext *ctx, JSValue callee, JSValue this_val,
 JSValue js_host_tty_open(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
 JSValue js_host_tty_set_raw_mode(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
 JSValue js_host_dns_lookup(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
+JSValue js_host_dns_lookup_service(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
+JSValue js_host_dns_channel(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
+JSValue js_host_dns_query(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
+JSValue js_host_dns_reverse(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
+JSValue js_host_dns_cancel(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
+JSValue js_host_dns_get_servers(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
+JSValue js_host_dns_set_servers(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
+JSValue js_host_dns_set_local_address(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
+JSValue js_host_dns_strerror(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
+JSValue js_host_dns_parse(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
 
 /* host_os.c: node:os through libuv */
 JSValue js_host_os_uname(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
 JSValue js_host_os_hostname(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
 JSValue js_host_os_homedir(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
-JSValue js_host_os_tmpdir(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
 JSValue js_host_os_memory(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
 JSValue js_host_os_uptime(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
 JSValue js_host_os_loadavg(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);

package/node/prelude/_http_common.js

@@ -0,0 +1,29 @@
+// node:_http_common: Node's module behind node:http, as its tests reach it: the header checks and
+// the method list. Node's HTTPParser isn't here: llhttp runs in C (node/src/host_http.c).
+import { hasInvalidHeaderChar, isHttpToken } from "./internal/http_chars.ts";
+import { METHODS } from "./http.js";
+
+/* Node's lenientHeaderCharRegex (httpValidation "relaxed"): only NUL, CR, LF and past 0xff */
+function hasLenientInvalidChar(s) {
+  for (let i = 0; i < s.length; i++) {
+    const c = s.charCodeAt(i);
+    if (c === 0 || c === 10 || c === 13 || c > 255) return true;
+  }
+  return false;
+}
+
+export function _checkInvalidHeaderChar(val, lenient = false) {
+  const s = String(val);
+  return lenient ? hasLenientInvalidChar(s) : hasInvalidHeaderChar(s);
+}
+
+export function _checkIsHttpToken(val) {
+  return typeof val === "string" && isHttpToken(val);
+}
+
+export const methods = METHODS.slice().sort();
+export const CRLF = "\r\n";
+export const continueExpression = /(?:^|\W)100-continue(?:$|\W)/i;
+export const chunkExpression = /(?:^|\W)chunked(?:$|\W)/i;
+
+export default { _checkInvalidHeaderChar, _checkIsHttpToken, methods, CRLF, continueExpression, chunkExpression };

package/node/prelude/async_hooks.js

@@ -3,9 +3,17 @@
 // does; AsyncResource, which keeps the context it was created in for a callback (on-finished,
 // raw-body). Hooks never fire: visaljs has no async resources to report.
 import { currentContext, runInContext, setContext } from "./internal/async_context.js";
-import { invalidArgType, validateFunction, validateString } from "./internal/errors.js";
+import { codeError, invalidArgType, invalidArgValue, validateFunction, validateString } from "./internal/errors.js";
 
 let nextAsyncId = 2;  /* 1 is the main program's, as in Node */
+let currentAsyncId = 1;
+let currentTriggerAsyncId = 0;
+/* enabled hooks with an init: Node checks a resource's type only then, when init would be told it */
+let initHooks = 0;
+
+function invalidAsyncId(name, id) {
+  return codeError(RangeError, "ERR_INVALID_ASYNC_ID", `Invalid ${name} value: ${id}`);
+}
 
 export class AsyncResource {
   #asyncId;
@@ -14,13 +22,24 @@ export class AsyncResource {
 
   constructor(type, opts = {}) {
     validateString(type, "type");
+    const triggerAsyncId = typeof opts === "number" ? opts : (opts.triggerAsyncId ?? currentAsyncId);
+    if (!Number.isSafeInteger(triggerAsyncId) || triggerAsyncId < -1) throw invalidAsyncId("triggerAsyncId", triggerAsyncId);
+    if (initHooks > 0 && type.length === 0) throw codeError(TypeError, "ERR_ASYNC_TYPE", `Invalid name for async "type": ${type}`);
     this.#asyncId = nextAsyncId++;
-    this.#triggerAsyncId = typeof opts === "number" ? opts : (opts.triggerAsyncId ?? 1);
+    this.#triggerAsyncId = triggerAsyncId;
     this.#context = currentContext();
   }
 
   runInAsyncScope(fn, thisArg, ...args) {
-    return runInContext(this.#context, fn, thisArg, args);
+    const asyncId = currentAsyncId, triggerId = currentTriggerAsyncId;
+    currentAsyncId = this.#asyncId;
+    currentTriggerAsyncId = this.#triggerAsyncId;
+    try {
+      return runInContext(this.#context, fn, thisArg, args);
+    } finally {
+      currentAsyncId = asyncId;
+      currentTriggerAsyncId = triggerId;
+    }
   }
 
   emitDestroy() {
@@ -57,24 +76,39 @@ export class AsyncResource {
 }
 
 export function executionAsyncId() {
-  return 1;
+  return currentAsyncId;
 }
 
 export function triggerAsyncId() {
-  return 0;
+  return currentTriggerAsyncId;
 }
 
 export function executionAsyncResource() {
   return {};
 }
 
+const hookNames = ["init", "before", "after", "destroy", "promiseResolve"];
+
 /** A hook that never fires: visaljs has no async resources to report. */
-export function createHook() {
+export function createHook(hooks) {
+  for (const name of hookNames) {
+    if (hooks[name] !== undefined && typeof hooks[name] !== "function") throw codeError(TypeError, "ERR_ASYNC_CALLBACK", `hook.${name} must be a function`);
+  }
+  if (hooks.trackPromises !== undefined && typeof hooks.trackPromises !== "boolean") throw invalidArgType("trackPromises", "of type boolean", hooks.trackPromises);
+  if (hooks.trackPromises === false && hooks.promiseResolve) {
+    throw invalidArgValue("trackPromises", "must not be false when promiseResolve is enabled", false);
+  }
+  const hasInit = hooks.init !== undefined;
+  let enabled = false;
   return {
     enable() {
+      if (!enabled && hasInit) initHooks++;
+      enabled = true;
       return this;
     },
     disable() {
+      if (enabled && hasInit) initHooks--;
+      enabled = false;
       return this;
     },
   };
@@ -110,10 +144,7 @@ export class AsyncLocalStorage {
 
   /** (fn, ...args) => fn(...args) in the context current now. */
   static snapshot() {
-    const resource = new AsyncResource("AsyncLocalStorageSnapshot");
-    return function runInAsyncScope(fn, ...args) {
-      return resource.runInAsyncScope(fn, this, ...args);
-    };
+    return AsyncLocalStorage.bind((cb, ...args) => cb(...args));
   }
 
   disable() {
@@ -124,8 +155,16 @@ export class AsyncLocalStorage {
     setContext(new AsyncContextFrame(this, store));
   }
 
+  /* as Node's: only this storage's store is put back after, so another's enterWith in fn outlasts it */
   run(store, fn, ...args) {
-    return runInContext(new AsyncContextFrame(this, store), fn, null, args);
+    const prior = this.getStore();
+    if (Object.is(prior, store)) return Reflect.apply(fn, null, args);
+    this.enterWith(store);
+    try {
+      return Reflect.apply(fn, null, args);
+    } finally {
+      this.enterWith(prior);
+    }
   }
 
   exit(fn, ...args) {

package/node/prelude/child_process.js

@@ -27,7 +27,7 @@
 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 import {
-  errnoName, netOpen, osConstants, processClose, processKillChild, processRef, processSpawn, processSpawnSync,
+  errnoName, netOpen, netReadStop, osConstants, processClose, processKillChild, processRef, processSpawn, processSpawnSync,
   utilInspect as inspect,
 } from "visaljs:host";
 import { Buffer } from "./buffer.js";
@@ -218,7 +218,7 @@ function getValidStdio(stdio, sync) {
       acc.push({ type: "fd", fd: typeof stdio === "number" ? stdio : stdio.fd });
     } else if (socketHandle(stdio) !== undefined || socketHandle(stdio.handle) !== undefined || socketHandle(stdio._handle) !== undefined) {
       const socket = socketHandle(stdio) !== undefined ? stdio : socketHandle(stdio.handle) !== undefined ? stdio.handle : stdio._handle;
-      acc.push({ type: "wrap", handle: socket._handle, socket, _stdio: stdio });
+      acc.push({ type: "wrap", handle: socket._handle, wrapped: socket, _stdio: stdio });  /* not the child's own stream: stdin… stay null, as Node's */
     } else if (isArrayBufferView(stdio) || typeof stdio === "string") {
       if (!sync) {
         cleanup();
@@ -393,6 +393,10 @@ ChildProcess.prototype.spawn = function spawn(options) {
     // otherwise we might attempt to read from the stream when at the same time
     // the child process does.
     if (stream.type === "wrap") {
+      if (stream.wrapped._handle !== null) {
+        stream.wrapped._reading = false;
+        netReadStop(stream.wrapped._handle);
+      }
       stream._stdio.pause();
       stream._stdio.readableFlowing = false;
       stream._stdio._readableState.reading = false;
@@ -496,8 +500,31 @@ function maybeClose(subprocess) {
 // ---- The module (lib/child_process.js) ----------------------------------------------------
 
 /** Node's fork(): a Node running a module, with a channel to it. */
-export function fork() {
-  throw notSupported("child_process.fork() (it starts a Node, which a compiled program doesn't have)");
+/* Node's fork, as far as its checks: the arguments are validated as Node's (a bad one is the same
+ * error), then it can't start the Node it needs. Its body starts with the throw so that
+ * tests/compat/node.ts counts it a stub. */
+export function fork(modulePath, args = [], options) {
+  throw notSupported(validateFork(modulePath, args, options));
+}
+
+function validateFork(modulePath, args, options) {
+  modulePath = getValidatedPath(modulePath, "modulePath");
+  if (args == null) {
+    args = [];
+  } else if (typeof args === "object" && !Array.isArray(args)) {
+    options = args;
+    args = [];
+  } else {
+    validateArray(args, "args");
+  }
+  if (options != null) validateObject(options, "options");
+  options = { __proto__: null, ...options, shell: false };
+  options.execPath ||= process.execPath;
+  validateArgumentNullCheck(options.execPath, "options.execPath");
+  const execArgv = options.execArgv || process.execArgv;
+  validateArgumentsNullCheck(execArgv, "options.execArgv");
+  normalizeSpawnArguments(options.execPath, [...execArgv, modulePath, ...args], options);
+  return "child_process.fork() (it starts a Node, which a compiled program doesn't have)";
 }
 
 export function _forkChild() {