visaljs 0.0.5 → 0.0.6

package/node/include/js_node.h

@@ -12,15 +12,28 @@ JSValue js_host_fs_read_file(JSContext *ctx, JSValue callee, JSValue this_val, u
 JSValue js_host_fs_write_file(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
 JSValue js_host_fs_exists(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
 JSValue js_host_fs_unlink(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
+JSValue js_host_fs_stat(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
+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);
 
 /* host_sys.c */
 /* A C errno as the libuv error code Node reports (-ENOENT on POSIX; UV_ENOENT, -4058, on Windows). */
 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_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);
+JSValue js_host_async_context_set(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
+JSValue js_host_timer_clear(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
 JSValue js_host_tty_isatty(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
 JSValue js_host_errno_message(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
 
+/* host_signal.c: process's signal events and process.kill */
+JSValue js_host_signal_start(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
+JSValue js_host_signal_stop(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
+JSValue js_host_process_kill(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
+
 /* host_http.c: llhttp on node:net's sockets (node:http) */
 JSValue js_host_http_parsers(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
 JSValue js_host_http_attach(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
@@ -68,4 +81,27 @@ JSValue js_host_os_constants(JSContext *ctx, JSValue callee, JSValue this_val, u
  * with a TypeError pending. */
 char *js_host_path_arg(JSContext *ctx, uint32_t argc, const JSValue *argv, uint32_t i);
 
+/* host_zlib.c: Node's zlib binding over Chromium's zlib (node:zlib) */
+JSValue js_host_zlib_new(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
+JSValue js_host_zlib_init(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
+JSValue js_host_zlib_write(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
+JSValue js_host_zlib_params(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
+JSValue js_host_zlib_reset(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
+JSValue js_host_zlib_close(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
+JSValue js_host_zlib_crc32(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
+
+/* host_brotli.c: Node's Brotli binding (node:zlib) */
+JSValue js_host_brotli_new(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
+JSValue js_host_brotli_init(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
+JSValue js_host_brotli_write(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
+JSValue js_host_brotli_reset(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
+JSValue js_host_brotli_close(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
+
+/* host_zstd.c: Node's zstd binding (node:zlib) */
+JSValue js_host_zstd_new(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
+JSValue js_host_zstd_init(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
+JSValue js_host_zstd_write(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
+JSValue js_host_zstd_reset(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
+JSValue js_host_zstd_close(JSContext *ctx, JSValue callee, JSValue this_val, uint32_t argc, const JSValue *argv, JSValue new_target);
+
 #endif /* JS_NODE_H */

package/node/prelude/async_hooks.js

@@ -1,23 +1,26 @@
-// node:async_hooks (ADR 0012, layer 3): AsyncResource, which libraries use to keep a callback's
-// async context (on-finished, raw-body). visaljs keeps no async context: running "in" a resource
-// is calling the function, and hooks never fire. AsyncLocalStorage, which needs the context
-// carried through promises and timers, isn't provided yet.
-import { notSupported, validateFunction, validateString } from "./internal/errors.js";
+// node:async_hooks (ADR 0012, layer 3; ADR 0020): AsyncLocalStorage, its stores kept in the async
+// context the runtime carries through promises, jobs and timers, as Node's AsyncContextFrame
+// 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";
 
 let nextAsyncId = 2;  /* 1 is the main program's, as in Node */
 
 export class AsyncResource {
   #asyncId;
   #triggerAsyncId;
+  #context;
 
   constructor(type, opts = {}) {
     validateString(type, "type");
     this.#asyncId = nextAsyncId++;
     this.#triggerAsyncId = typeof opts === "number" ? opts : (opts.triggerAsyncId ?? 1);
+    this.#context = currentContext();
   }
 
   runInAsyncScope(fn, thisArg, ...args) {
-    return Reflect.apply(fn, thisArg, args);
+    return runInContext(this.#context, fn, thisArg, args);
   }
 
   emitDestroy() {
@@ -77,9 +80,61 @@ export function createHook() {
   };
 }
 
+/* A frame: each storage's store, the context's value. A new one replaces the current one; it
+ * isn't changed while current, but disable() (as Node's). */
+class AsyncContextFrame extends Map {
+  constructor(storage, store) {
+    super(currentContext());
+    this.set(storage, store);
+  }
+}
+
 export class AsyncLocalStorage {
-  constructor() {
-    throw notSupported("AsyncLocalStorage");
+  #defaultValue;
+  #name = "";
+
+  constructor(options = {}) {
+    if (options === null || typeof options !== "object") throw invalidArgType("options", "of type object", options);
+    this.#defaultValue = options.defaultValue;
+    if (options.name !== undefined) this.#name = `${options.name}`;
+  }
+
+  get name() {
+    return this.#name;
+  }
+
+  /** fn, run in the context current now, wherever it is called. */
+  static bind(fn) {
+    return AsyncResource.bind(fn);
+  }
+
+  /** (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);
+    };
+  }
+
+  disable() {
+    currentContext()?.delete(this);
+  }
+
+  enterWith(store) {
+    setContext(new AsyncContextFrame(this, store));
+  }
+
+  run(store, fn, ...args) {
+    return runInContext(new AsyncContextFrame(this, store), fn, null, args);
+  }
+
+  exit(fn, ...args) {
+    return this.run(undefined, fn, ...args);
+  }
+
+  getStore() {
+    const frame = currentContext();
+    return frame?.has(this) ? frame.get(this) : this.#defaultValue;
   }
 }
 

package/node/prelude/diagnostics_channel.js

@@ -0,0 +1,322 @@
+// node:diagnostics_channel (ADR 0012, layer 3): named channels a library publishes on and tools
+// subscribe to, and TracingChannel's start / end / asyncStart / asyncEnd / error around a call.
+// Node's algorithm: a channel with neither subscribers nor bound stores is inactive (publish does
+// nothing, hasSubscribers is false) and held weakly; subscribing swaps in ActiveChannel's
+// prototype. A subscriber's error doesn't stop the others: it is thrown on the next tick, as an
+// uncaught exception.
+import { invalidArgType, validateFunction } from "./internal/errors.js";
+
+/* name → channel: weakly held, except while it has subscribers or stores (Node's WeakRefMap) */
+class WeakRefMap {
+  #entries = new Map();
+
+  get(key) {
+    return this.#entries.get(key)?.ref.deref();
+  }
+
+  set(key, value) {
+    this.#entries.set(key, { ref: new WeakRef(value), strong: undefined, count: 0 });
+  }
+
+  incRef(key) {
+    const entry = this.#entries.get(key);
+    if (entry && entry.count++ === 0) entry.strong = entry.ref.deref();
+  }
+
+  decRef(key) {
+    const entry = this.#entries.get(key);
+    if (entry && --entry.count === 0) entry.strong = undefined;
+  }
+}
+
+const channels = new WeakRefMap();
+
+function uncaught(err) {
+  process.nextTick(() => {
+    throw err;
+  });
+}
+
+function markActive(channel) {
+  Object.setPrototypeOf(channel, ActiveChannel.prototype);
+  channel._subscribers = [];
+  channel._stores = new Map();
+}
+
+function maybeMarkInactive(channel) {
+  if (!channel._subscribers.length && !channel._stores.size) {
+    Object.setPrototypeOf(channel, Channel.prototype);
+    channel._subscribers = undefined;
+    channel._stores = undefined;
+  }
+}
+
+function defaultTransform(data) {
+  return data;
+}
+
+/* next() run in the store's context: store.run(transform(data), next) */
+function wrapStoreRun(store, data, next, transform = defaultTransform) {
+  return () => {
+    let context;
+    try {
+      context = transform(data);
+    } catch (err) {
+      uncaught(err);
+      return next();
+    }
+    return store.run(context, next);
+  };
+}
+
+class ActiveChannel {
+  subscribe(subscription) {
+    validateFunction(subscription, "subscription");
+    this._subscribers = [...this._subscribers, subscription];  /* a publish under way keeps its list */
+    channels.incRef(this.name);
+  }
+
+  unsubscribe(subscription) {
+    const index = this._subscribers.indexOf(subscription);
+    if (index === -1) return false;
+    this._subscribers = [...this._subscribers.slice(0, index), ...this._subscribers.slice(index + 1)];
+    channels.decRef(this.name);
+    maybeMarkInactive(this);
+    return true;
+  }
+
+  bindStore(store, transform) {
+    if (!this._stores.has(store)) channels.incRef(this.name);
+    this._stores.set(store, transform);
+  }
+
+  unbindStore(store) {
+    if (!this._stores.has(store)) return false;
+    this._stores.delete(store);
+    channels.decRef(this.name);
+    maybeMarkInactive(this);
+    return true;
+  }
+
+  get hasSubscribers() {
+    return true;
+  }
+
+  publish(data) {
+    const subscribers = this._subscribers;
+    for (let i = 0; i < (subscribers?.length || 0); i++) {
+      try {
+        const onMessage = subscribers[i];
+        onMessage(data, this.name);
+      } catch (err) {
+        uncaught(err);
+      }
+    }
+  }
+
+  runStores(data, fn, thisArg, ...args) {
+    let run = () => {
+      this.publish(data);
+      return Reflect.apply(fn, thisArg, args);
+    };
+    for (const [store, transform] of this._stores.entries()) run = wrapStoreRun(store, data, run, transform);
+    return run();
+  }
+}
+
+export class Channel {
+  constructor(name) {
+    this._subscribers = undefined;
+    this._stores = undefined;
+    this.name = name;
+    channels.set(name, this);
+  }
+
+  /* an active channel's prototype is ActiveChannel's: it is a Channel still */
+  static [Symbol.hasInstance](instance) {
+    if (instance === null || (typeof instance !== "object" && typeof instance !== "function")) return false;
+    const prototype = Object.getPrototypeOf(instance);
+    return prototype === Channel.prototype || prototype === ActiveChannel.prototype;
+  }
+
+  subscribe(subscription) {
+    markActive(this);
+    this.subscribe(subscription);
+  }
+
+  unsubscribe() {
+    return false;
+  }
+
+  bindStore(store, transform) {
+    markActive(this);
+    this.bindStore(store, transform);
+  }
+
+  unbindStore() {
+    return false;
+  }
+
+  get hasSubscribers() {
+    return false;
+  }
+
+  publish() {}
+
+  runStores(data, fn, thisArg, ...args) {
+    return Reflect.apply(fn, thisArg, args);
+  }
+}
+
+export function channel(name) {
+  const existing = channels.get(name);
+  if (existing) return existing;
+  if (typeof name !== "string" && typeof name !== "symbol") throw invalidArgType("channel", "one of type string or symbol", name);
+  return new Channel(name);
+}
+
+export function subscribe(name, subscription) {
+  channel(name).subscribe(subscription);
+}
+
+export function unsubscribe(name, subscription) {
+  return channel(name).unsubscribe(subscription);
+}
+
+export function hasSubscribers(name) {
+  const existing = channels.get(name);
+  return existing ? existing.hasSubscribers : false;
+}
+
+/* ---- TracingChannel ------------------------------------------------------------------ */
+
+const traceEvents = ["start", "end", "asyncStart", "asyncEnd", "error"];
+
+function tracingChannelFrom(nameOrChannels, name) {
+  if (typeof nameOrChannels === "string") return channel(`tracing:${nameOrChannels}:${name}`);
+  if (typeof nameOrChannels === "object" && nameOrChannels !== null) {
+    const found = nameOrChannels[name];
+    if (!(found instanceof Channel)) throw invalidArgType(`nameOrChannels.${name}`, "an instance of Channel", found);
+    return found;
+  }
+  throw invalidArgType("nameOrChannels", "of type string or an instance of TracingChannel or Object", nameOrChannels);
+}
+
+class TracingChannel {
+  constructor(nameOrChannels) {
+    for (const eventName of traceEvents) {
+      Object.defineProperty(this, eventName, { value: tracingChannelFrom(nameOrChannels, eventName) });
+    }
+  }
+
+  get hasSubscribers() {
+    return this.start.hasSubscribers || this.end.hasSubscribers || this.asyncStart.hasSubscribers ||
+      this.asyncEnd.hasSubscribers || this.error.hasSubscribers;
+  }
+
+  subscribe(handlers) {
+    for (const name of traceEvents) {
+      if (!handlers[name]) continue;
+      this[name]?.subscribe(handlers[name]);
+    }
+  }
+
+  unsubscribe(handlers) {
+    let done = true;
+    for (const name of traceEvents) {
+      if (!handlers[name]) continue;
+      if (!this[name]?.unsubscribe(handlers[name])) done = false;
+    }
+    return done;
+  }
+
+  traceSync(fn, context = {}, thisArg, ...args) {
+    if (!this.hasSubscribers) return Reflect.apply(fn, thisArg, args);
+    const { start, end, error } = this;
+    return start.runStores(context, () => {
+      try {
+        const result = Reflect.apply(fn, thisArg, args);
+        context.result = result;
+        return result;
+      } catch (err) {
+        context.error = err;
+        error.publish(context);
+        throw err;
+      } finally {
+        end.publish(context);
+      }
+    });
+  }
+
+  tracePromise(fn, context = {}, thisArg, ...args) {
+    if (!this.hasSubscribers) return Reflect.apply(fn, thisArg, args);
+    const { start, end, asyncStart, asyncEnd, error } = this;
+    function reject(err) {
+      context.error = err;
+      error.publish(context);
+      asyncStart.publish(context);
+      asyncEnd.publish(context);
+      return Promise.reject(err);
+    }
+    function resolve(result) {
+      context.result = result;
+      asyncStart.publish(context);
+      asyncEnd.publish(context);
+      return result;
+    }
+    return start.runStores(context, () => {
+      try {
+        let promise = Reflect.apply(fn, thisArg, args);
+        if (!(promise instanceof Promise)) promise = Promise.resolve(promise);  /* a thenable, a value */
+        return promise.then(resolve, reject);
+      } catch (err) {
+        context.error = err;
+        error.publish(context);
+        throw err;
+      } finally {
+        end.publish(context);
+      }
+    });
+  }
+
+  /* the callback at args[position] (-1: the last) reports the async half */
+  traceCallback(fn, position = -1, context = {}, thisArg, ...args) {
+    if (!this.hasSubscribers) return Reflect.apply(fn, thisArg, args);
+    const { start, end, asyncStart, asyncEnd, error } = this;
+    function wrappedCallback(err, res) {
+      if (err) {
+        context.error = err;
+        error.publish(context);
+      } else {
+        context.result = res;
+      }
+      asyncStart.runStores(context, () => {
+        try {
+          return Reflect.apply(callback, this, arguments);
+        } finally {
+          asyncEnd.publish(context);
+        }
+      });
+    }
+    const callback = args.at(position);
+    validateFunction(callback, "callback");
+    args.splice(position, 1, wrappedCallback);
+    return start.runStores(context, () => {
+      try {
+        return Reflect.apply(fn, thisArg, args);
+      } catch (err) {
+        context.error = err;
+        error.publish(context);
+        throw err;
+      } finally {
+        end.publish(context);
+      }
+    });
+  }
+}
+
+export function tracingChannel(nameOrChannels) {
+  return new TracingChannel(nameOrChannels);
+}
+
+export default { channel, hasSubscribers, subscribe, tracingChannel, unsubscribe, Channel };

package/node/prelude/dns.js

@@ -2,6 +2,7 @@
 // is (results in the system's order, Node's default "verbatim"). Not yet: the resolve* queries
 // (c-ares) and Resolver.
 import { dnsLookup, errnoName } from "visaljs:host";
+import { bindContext } from "./internal/async_context.js";
 import { codeError, invalidArgType } from "./internal/errors.js";
 import { isIP } from "./internal/net.js";
 
@@ -76,11 +77,11 @@ export function lookup(hostname, options, callback) {
     process.nextTick(() => (all ? callback(null, [{ address: hostname, family: matched }]) : callback(null, hostname, matched)));
     return {};
   }
-  const r = dnsLookup(hostname, family, (errno, code, list) => {
+  const r = dnsLookup(hostname, family, bindContext((errno, code, list) => {
     if (errno) callback(dnsException(errno, code, "getaddrinfo", hostname));
     else if (all) callback(null, list.map(([address, family]) => ({ address, family })));
     else callback(null, list[0][0], list[0][1]);
-  });
+  }));
   if (r < 0) process.nextTick(callback, dnsException(r, errnoName(r), "getaddrinfo", hostname));
   return {};
 }

package/node/prelude/events.js

@@ -173,13 +173,27 @@ EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
 EventEmitter.prototype.removeAllListeners = function (type) {
   const events = this._events;
   if (events === undefined) return this;
+  if (events.removeListener === undefined) {  /* nobody hears of it: drop them at once */
+    if (arguments.length === 0) {
+      this._events = Object.create(null);
+      this._eventsCount = 0;
+    } else if (events[type] !== undefined) {
+      if (--this._eventsCount === 0) this._events = Object.create(null);
+      else delete events[type];
+    }
+    return this;
+  }
+  /* one by one, last first, each a 'removeListener' (process stops watching a signal so) */
   if (arguments.length === 0) {
+    for (const key of Reflect.ownKeys(events)) if (key !== "removeListener") this.removeAllListeners(key);
+    this.removeAllListeners("removeListener");
     this._events = Object.create(null);
     this._eventsCount = 0;
-  } else if (events[type] !== undefined) {
-    if (--this._eventsCount === 0) this._events = Object.create(null);
-    else delete events[type];
+    return this;
   }
+  const listeners = events[type];
+  if (typeof listeners === "function") this.removeListener(type, listeners);
+  else if (listeners !== undefined) for (let i = listeners.length - 1; i >= 0; i--) this.removeListener(type, listeners[i]);
   return this;
 };