@nubjs/nub-linux-arm64 0.0.5 → 0.0.8

package/runtime/version.mjs

@@ -0,0 +1,12 @@
+// Single source of truth for the nub version that salts the transpile-cache key.
+//
+// `make version` rewrites the NUB_VERSION line below in lockstep with every npm
+// package + Cargo.toml, and `make version-check` fails the release build if it
+// drifts. Keeping it in its own side-effect-free module lets every transpile
+// surface — runtime/transform-core.mjs (the shared core), runtime/preload.mjs
+// (fast path), and the compat-tier loader worker — import the SAME value, so the
+// fast and compat tiers produce byte-identical cache entries under one key. (It
+// previously lived as a literal inside preload.mjs, which `make version` patched,
+// while the worker carried a hand-maintained "…-compat" copy that `make version`
+// never touched — a latent staleness bug this module closes.)
+export const NUB_VERSION = "0.0.8";

package/runtime/worker-polyfill.mjs

@@ -5,6 +5,26 @@
 import { Worker as NodeWorker, parentPort, isMainThread } from "node:worker_threads";
 import { fileURLToPath } from "node:url";
 
+// `ErrorEvent` only became a global in Node 26. On the 22/24 floor it is
+// undefined, so `new ErrorEvent(...)` below would throw a ReferenceError inside
+// the worker's "error" handler — crashing the PARENT thread on every worker
+// that throws. Resolve the constructor once at load: use the native global when
+// present, otherwise a minimal Event subclass carrying the standard ErrorEvent
+// fields (message/error/filename/lineno/colno). See wiki/research/worker-polyfill.md.
+const ErrorEventCtor =
+  typeof globalThis.ErrorEvent === "function"
+    ? globalThis.ErrorEvent
+    : class ErrorEvent extends Event {
+        constructor(type, init = {}) {
+          super(type, init);
+          this.message = init.message ?? "";
+          this.error = init.error ?? null;
+          this.filename = init.filename ?? "";
+          this.lineno = init.lineno ?? 0;
+          this.colno = init.colno ?? 0;
+        }
+      };
+
 if (typeof globalThis.Worker === "undefined") {
   class Worker extends EventTarget {
     #worker;
@@ -25,7 +45,12 @@ if (typeof globalThis.Worker === "undefined") {
         throw new TypeError("Worker constructor: url must be a string or URL");
       }
 
-      const type = options.type || "module";
+      // `type: "module" | "classic"` is accepted for web compatibility but not
+      // enforced: Node decides module-vs-CJS for the worker entry by file
+      // extension + nearest package.json "type" (the same rule nub applies to
+      // the main entry), and there is no classic/importScripts mode. Passing
+      // `type` through to NodeWorker is harmless — it ignores unknown options.
+      // See wiki/research/worker-polyfill.md.
       this.#worker = new NodeWorker(workerPath, {
         ...options,
         eval: false,
@@ -41,7 +66,7 @@ if (typeof globalThis.Worker === "undefined") {
       });
 
       this.#worker.on("error", (err) => {
-        this.dispatchEvent(new ErrorEvent("error", { error: err, message: err.message }));
+        this.dispatchEvent(new ErrorEventCtor("error", { error: err, message: err.message }));
       });
 
       this.#worker.on("exit", (code) => {
@@ -72,20 +97,133 @@ if (typeof globalThis.Worker === "undefined") {
       this.#onerrorHandler = fn;
       if (fn) this.addEventListener("error", fn);
     }
+
+    #onmessageerrorHandler = null;
+    get onmessageerror() { return this.#onmessageerrorHandler; }
+    set onmessageerror(fn) {
+      if (this.#onmessageerrorHandler) this.removeEventListener("messageerror", this.#onmessageerrorHandler);
+      this.#onmessageerrorHandler = fn;
+      if (fn) this.addEventListener("messageerror", fn);
+    }
   }
 
   globalThis.Worker = Worker;
 }
 
-// Worker-side bootstrap: set up self, postMessage, close.
+// Worker-side bootstrap: emulate the DedicatedWorkerGlobalScope on top of
+// node:worker_threads — `self`, `postMessage`, `close`, AND inbound message
+// events. Node's worker global is not an EventTarget and exposes none of these
+// (verified), so the polyfill provides the whole surface. Without the inbound
+// wiring, `self.onmessage` / `self.addEventListener("message", …)` never fire
+// and a parent→worker round-trip hangs — see wiki/research/worker-polyfill.md.
 if (!isMainThread && parentPort) {
-  if (typeof globalThis.self === "undefined") {
-    globalThis.self = globalThis;
+  const scope = globalThis;
+  scope.self = scope;
+
+  // `message`/`messageerror` are DELEGATED straight onto the native `parentPort`
+  // (a real Node MessagePort) so Node's own C++ event-loop ref-counting governs
+  // worker lifetime: a worker that never listens leaves parentPort with no
+  // listeners → Node unrefs it → the worker exits naturally (matching
+  // `node:worker_threads` and Bun); a worker listening via `self.onmessage` /
+  // `addEventListener("message", …)` refs it → stays alive. Node reflects
+  // `{once}`/`{signal}`/last-listener removal in the loop ref-count in C++,
+  // which no userland counter can observe. (Earlier this block eagerly held a
+  // `parentPort.on("message")` forwarder, which kept EVERY worker's event loop
+  // alive → pure `parentPort` workers that should exit hung forever. See
+  // wiki/research/worker-polyfill.md §4.) All OTHER event types go to a private
+  // EventTarget (additive; no globalThis prototype re-parenting — `event.target`
+  // is that private target, the documented minor divergence).
+  const other = new EventTarget();
+  const otherAdd =
+    typeof scope.addEventListener === "function"
+      ? scope.addEventListener.bind(scope)
+      : other.addEventListener.bind(other);
+  const otherRemove =
+    typeof scope.removeEventListener === "function"
+      ? scope.removeEventListener.bind(scope)
+      : other.removeEventListener.bind(other);
+  const otherDispatch =
+    typeof scope.dispatchEvent === "function"
+      ? scope.dispatchEvent.bind(scope)
+      : other.dispatchEvent.bind(other);
+
+  const DELEGATED = new Set(["message", "messageerror"]);
+  // user listener → its parentPort wrapper (per delegated event), so
+  // removeEventListener detaches the exact wrapper Node registered.
+  const wrappers = { message: new Map(), messageerror: new Map() };
+
+  function addDelegated(evt, listener, opts) {
+    const cb =
+      typeof listener === "function"
+        ? listener
+        : listener && typeof listener.handleEvent === "function"
+          ? (e) => listener.handleEvent(e)
+          : null;
+    if (!cb) return;
+    const map = wrappers[evt];
+    if (map.has(listener)) return; // EventTarget dedups identical (type, listener)
+    const o = opts && typeof opts === "object" ? opts : {};
+    if (o.signal && o.signal.aborted) return;
+    const fire = (data) => cb.call(scope, new MessageEvent(evt, { data }));
+    let wrapper;
+    if (o.once) {
+      wrapper = (data) => {
+        map.delete(listener);
+        fire(data);
+      };
+      parentPort.once(evt, wrapper);
+    } else {
+      wrapper = fire;
+      parentPort.on(evt, wrapper);
+    }
+    map.set(listener, wrapper);
+    if (o.signal) {
+      o.signal.addEventListener("abort", () => removeDelegated(evt, listener), {
+        once: true,
+      });
+    }
+  }
+  function removeDelegated(evt, listener) {
+    const wrapper = wrappers[evt].get(listener);
+    if (wrapper) {
+      parentPort.off(evt, wrapper);
+      wrappers[evt].delete(listener);
+    }
   }
-  if (typeof globalThis.postMessage === "undefined") {
-    globalThis.postMessage = (data, transfer) => parentPort.postMessage(data, transfer);
+
+  scope.addEventListener = (type, listener, opts) =>
+    DELEGATED.has(type)
+      ? addDelegated(type, listener, opts)
+      : otherAdd(type, listener, opts);
+  scope.removeEventListener = (type, listener, opts) =>
+    DELEGATED.has(type)
+      ? removeDelegated(type, listener)
+      : otherRemove(type, listener, opts);
+  scope.dispatchEvent = (ev) => otherDispatch(ev);
+
+  // `onmessage` / `onmessageerror` register via the delegating add/remove above,
+  // mirroring the web API and the main-side Worker. Assigning `null` removes the
+  // last listener → parentPort unrefs → the worker can exit (Bun parity).
+  for (const evt of ["message", "messageerror"]) {
+    let handler = null;
+    Object.defineProperty(scope, "on" + evt, {
+      configurable: true,
+      get() {
+        return handler;
+      },
+      set(fn) {
+        if (handler) scope.removeEventListener(evt, handler);
+        handler = typeof fn === "function" ? fn : null;
+        if (handler) scope.addEventListener(evt, handler);
+      },
+    });
+  }
+
+  // Outbound + lifecycle.
+  if (typeof scope.postMessage !== "function") {
+    scope.postMessage = (data, transfer) => parentPort.postMessage(data, transfer);
   }
-  if (typeof globalThis.close === "undefined") {
-    globalThis.close = () => process.exit(0);
+  if (typeof scope.close !== "function") {
+    scope.close = () => process.exit(0);
   }
 }