fix(runtime): parentPort once() detaches its own registration, relays ports, and a throwing stack accessor only drops the stack

A once() wrapper removed the first registration holding the same listener,
which with on() and once() sharing a function could detach the wrong one and
leave the once() wrapper firing forever; each registration is now its own
entry and removeListener() takes the most recent, as Node does. The relay
onto parentPort forwards event.ports. Reading `stack` off the error a
scope onerror threw runs under a TryCatch so a throwing accessor cannot
leave an exception pending past the rejection drain.

Author: edusperoni

NativeScript/runtime/NativeScriptException.mm

@@ -660,7 +660,10 @@ static bool GiveWorkerOnErrorAChance(Isolate* isolate, Local<Context> context, L
                   Local<Value> forwarded = thrown.IsEmpty() ? reason : thrown;
                   std::string forwardedStack = stack;
                   if (!thrown.IsEmpty()) {
+                    // `stack` may be an accessor that throws; that only costs
+                    // the stack, never the forward.
                     forwardedStack = "";
+                    TryCatch stackTc(isolate_);
                     Local<Value> thrownStack;
                     if (thrown->IsObject() &&
                         thrown.As<Object>()

NativeScript/runtime/js/node-worker-threads.js

@@ -254,32 +254,49 @@ class ParentPort extends EventTarget {
       throw new TypeError('The "listener" argument must be of type function');
     }
     const self = this;
-    const wrapper = function (event) {
+    const entry = { listener, wrapper: undefined };
+    // A once registration detaches its own entry, not whichever entry happens
+    // to hold the same listener: the same function may be on() and once() at
+    // the same time.
+    entry.wrapper = function (event) {
       if (once) {
-        self.#remove(type, listener);
+        self.#removeEntry(type, entry);
       }
       const arg = type === "message" || type === "messageerror" ? event.data : event;
       FunctionPrototypeCall(listener, self, arg);
     };
     const list = this.#wrappers[type] || (this.#wrappers[type] = []);
-    ArrayPrototypePush(list, { listener, wrapper });
-    FunctionPrototypeCall(addEventListener, this, type, wrapper);
+    ArrayPrototypePush(list, entry);
+    FunctionPrototypeCall(addEventListener, this, type, entry.wrapper);
     return this;
   }
 
+  // Node removes the most recently added registration of a listener.
   #remove(type, listener) {
     const list = this.#wrappers[type];
     if (list === undefined) {
       return;
     }
-    for (let i = 0; i < list.length; i++) {
+    for (let i = list.length - 1; i >= 0; i--) {
       if (list[i].listener === listener) {
-        FunctionPrototypeCall(removeEventListener, this, type, list[i].wrapper);
-        ArrayPrototypeSplice(list, i, 1);
+        this.#removeEntry(type, list[i]);
         return;
       }
     }
   }
+
+  #removeEntry(type, entry) {
+    const list = this.#wrappers[type];
+    if (list === undefined) {
+      return;
+    }
+    const index = ArrayPrototypeIndexOf(list, entry);
+    if (index === -1) {
+      return;
+    }
+    ArrayPrototypeSplice(list, index, 1);
+    FunctionPrototypeCall(removeEventListener, this, type, entry.wrapper);
+  }
 }
 
 defineEventHandler(ParentPort.prototype, "message");
@@ -298,7 +315,7 @@ if (!isMainThread) {
     FunctionPrototypeCall(
       dispatchEvent,
       parentPort,
-      new (getMessageEvent())(event.type, { data: event.data })
+      new (getMessageEvent())(event.type, { data: event.data, ports: event.ports })
     );
   };
   FunctionPrototypeCall(addEventListener, globalEventTarget, "message", relay);

TestRunner/app/tests/MessagingTests.js

@@ -150,6 +150,48 @@ describe("Messaging runtime edges", function () {
             worker.postMessage(2);
         });
 
+        it("lets the same listener be on() and once() at the same time", function (done) {
+            var worker = new wt.Worker("~/tests/messaging/parentPortOnceWorker.js");
+            var got = [];
+            worker.on("message", function (value) {
+                got.push(value);
+                if (got.length === 3) {
+                    setTimeout(function () {
+                        // Three messages: the once() registration fires only
+                        // for the first, the on() one for all three.
+                        expect(got).toEqual([1, 2, 3, 4]);
+                        worker.terminate();
+                        done();
+                    }, SETTLE);
+                }
+            });
+            worker.on("error", function (error) {
+                fail("worker error: " + error.message);
+                worker.terminate();
+                done();
+            });
+            worker.postMessage("a");
+            worker.postMessage("b");
+            worker.postMessage("c");
+        });
+
+        it("relays transferred ports to parentPort message events", function (done) {
+            var worker = new wt.Worker("~/tests/messaging/parentPortPortsWorker.js");
+            var channel = new MessageChannel();
+            worker.on("message", function (value) {
+                expect(value).toBe(1);
+                channel.port1.close();
+                worker.terminate();
+                done();
+            });
+            worker.on("error", function (error) {
+                fail("worker error: " + error.message);
+                worker.terminate();
+                done();
+            });
+            worker.postMessage(channel.port2, [channel.port2]);
+        });
+
         it("forwards the option bag to the runtime's Worker", function () {
             expect(function () {
                 new wt.Worker("~/tests/messaging/parentPortWorker.js", {

TestRunner/app/tests/messaging/parentPortOnceWorker.js

@@ -0,0 +1,8 @@
+var parentPort = require("node:worker_threads").parentPort;
+var count = 0;
+function listener() {
+    count++;
+    parentPort.postMessage(count);
+}
+parentPort.on("message", listener);
+parentPort.once("message", listener);

TestRunner/app/tests/messaging/parentPortPortsWorker.js

@@ -0,0 +1,4 @@
+var parentPort = require("node:worker_threads").parentPort;
+parentPort.addEventListener("message", function (event) {
+    parentPort.postMessage(event.ports.length);
+});