fix(runtime): deliver a posted undefined as undefined, not null

test-app/app/src/main/assets/app/tests/messaging/describeDataWorker.js

@@ -0,0 +1,10 @@
+// Reports what `event.data` was before echoing it, so the parent can tell a
+// value lost on the way in from one lost on the way back.
+function describe(value) {
+    return value === undefined ? "undefined" : value === null ? "null" : typeof value;
+}
+
+onmessage = function (event) {
+    postMessage({ received: describe(event.data) });
+    postMessage(event.data);
+};

test-app/app/src/main/assets/app/tests/messaging/parentPortDescribeWorker.js

@@ -0,0 +1,4 @@
+var parentPort = require("node:worker_threads").parentPort;
+parentPort.on("message", function (value) {
+    parentPort.postMessage({ received: value === undefined ? "undefined" : typeof value });
+});

test-app/app/src/main/assets/app/tests/testMessaging.js

@@ -204,6 +204,98 @@ describe("Messaging runtime edges", function () {
         });
     });
 
+    // The MessageEvent constructor defaults an undefined `data` to null, as Web
+    // IDL requires of its init dictionary. A delivered message is not built
+    // from a dictionary: it carries whatever the payload deserialized to.
+    describe("undefined payloads", function () {
+        var payloads = [undefined, null, false, 0, ""];
+        // Closed after every spec, so one that failed or timed out leaves no
+        // worker or channel behind. terminate() and close() are idempotent.
+        var cleanups = [];
+        afterEach(function () {
+            cleanups.forEach(function (cleanup) { cleanup(); });
+            cleanups = [];
+        });
+
+        function failOnWorkerError(done) {
+            return function (error) {
+                fail("worker error: " + error.message);
+                done();
+            };
+        }
+
+        function expectPayloads(events) {
+            expect(events.map(function (event) { return event.data; })).toEqual(payloads);
+            expect(events[0].data).toBeUndefined();
+            expect("data" in events[0]).toBe(true);
+        }
+
+        it("arrive unchanged on a MessagePort", function (done) {
+            var channel = new MessageChannel();
+            // The receiver first: closing only the sender queues the close
+            // behind the messages, which would still be delivered.
+            cleanups.push(function () { channel.port2.close(); channel.port1.close(); });
+            var events = [];
+            channel.port2.onmessage = function (event) {
+                events.push(event);
+                if (events.length === payloads.length) {
+                    expectPayloads(events);
+                    done();
+                }
+            };
+            payloads.forEach(function (payload) { channel.port1.postMessage(payload); });
+        });
+
+        it("arrive unchanged on a BroadcastChannel", function (done) {
+            var sender = new BroadcastChannel("undefined-payloads");
+            var receiver = new BroadcastChannel("undefined-payloads");
+            cleanups.push(function () { sender.close(); receiver.close(); });
+            var events = [];
+            receiver.onmessage = function (event) {
+                events.push(event);
+                if (events.length === payloads.length) {
+                    expectPayloads(events);
+                    done();
+                }
+            };
+            payloads.forEach(function (payload) { sender.postMessage(payload); });
+        });
+
+        it("arrive unchanged in a worker and back on its Worker object", function (done) {
+            var worker = new Worker("./messaging/describeDataWorker.js");
+            cleanups.push(function () { worker.terminate(); });
+            var events = [];
+            worker.onmessage = function (event) {
+                events.push(event);
+                if (events.length === 2) {
+                    expect(events[0].data).toEqual({ received: "undefined" });
+                    expect(events[1].data).toBeUndefined();
+                    expect("data" in events[1]).toBe(true);
+                    done();
+                }
+            };
+            worker.onerror = failOnWorkerError(done);
+            worker.postMessage(undefined);
+        });
+
+        it("arrive unchanged on a node:worker_threads parentPort", function (done) {
+            var wt = require("node:worker_threads");
+            var worker = new wt.Worker("~/tests/messaging/parentPortDescribeWorker.js");
+            cleanups.push(function () { worker.terminate(); });
+            worker.on("message", function (value) {
+                expect(value).toEqual({ received: "undefined" });
+                done();
+            });
+            worker.on("error", failOnWorkerError(done));
+            worker.postMessage(undefined);
+        });
+
+        it("still default to null in a constructed MessageEvent", function () {
+            expect(new MessageEvent("message").data).toBeNull();
+            expect(new MessageEvent("message", { data: undefined }).data).toBeNull();
+        });
+    });
+
     describe("worker error reporting", function () {
         // A worker boots on its own thread, so the first error arrives whenever
         // the runner gets to it; specs wait for it and only then settle for

test-app/runtime/src/main/cpp/Messaging.cpp

@@ -682,7 +682,13 @@ void NativeMessagePort::Drain() {
                 if (tc.HasTerminated() || !tc.CanContinue()) {
                     return;
                 }
-                payload = tc.HasCaught() ? tc.Exception() : v8::Undefined(isolate).As<Value>();
+                // Null rather than undefined when there is nothing to carry, which
+                // includes a thrown undefined: delivery stores the payload as given,
+                // and an event's `data` defaults to null.
+                payload = tc.HasCaught() ? tc.Exception() : Local<Value>();
+                if (payload.IsEmpty() || payload->IsUndefined()) {
+                    payload = v8::Null(isolate);
+                }
                 tc.Reset();
             }
         }

test-app/runtime/src/main/cpp/WorkerEvents.cpp

@@ -82,9 +82,16 @@ void WorkerEvents::EmitMessage(Isolate* isolate, Local<Object> receiver,
                 return;
             }
             // HTML: a message that cannot be read still reaches its target, as
-            // a `messageerror` event carrying nothing.
+            // a `messageerror` event. Its `data` is the failure, the same as a
+            // port's (NativeMessagePort::Drain) and as what Node hands
+            // `worker.on("messageerror")`; null when nothing was thrown, since
+            // delivery stores the payload as given and a bare undefined would
+            // surface as such.
+            data = tc.HasCaught() ? tc.Exception() : Local<Value>();
+            if (data.IsEmpty() || data->IsUndefined()) {
+                data = v8::Null(isolate);
+            }
             tc.Reset();
-            data = v8::Undefined(isolate);
             ports = Local<Value>();
             type = "messageerror";
         }

test-app/runtime/src/main/cpp/WorkerEvents.h

@@ -30,7 +30,7 @@ class WorkerEvents {
      * Builds a MessageEvent out of `message` and dispatches it on `receiver` -
      * the Worker object for worker-to-parent traffic, the global scope's
      * EventTarget for parent-to-worker. A message that cannot be read arrives
-     * as a `messageerror` event carrying nothing. A handler that throws leaves
+     * as a `messageerror` event instead. A handler that throws leaves
      * the exception pending for the caller's TryCatch, which owns the worker's
      * error chain. No-op before Init has run.
      */

test-app/runtime/src/main/cpp/js/broadcast-channel.js

@@ -24,12 +24,12 @@ const { adoptPort } = require("internal/message-channel");
 const addEventListener = EventTarget.prototype.addEventListener;
 const dispatchEvent = EventTarget.prototype.dispatchEvent;
 
-let MessageEvent;
-function getMessageEvent() {
-  if (MessageEvent === undefined) {
-    ({ MessageEvent } = require("internal/message-event"));
+let createMessageEvent;
+function getCreateMessageEvent() {
+  if (createMessageEvent === undefined) {
+    ({ createMessageEvent } = require("internal/message-event"));
   }
-  return MessageEvent;
+  return createMessageEvent;
 }
 
 let DOMException;
@@ -64,7 +64,7 @@ class BroadcastChannel extends EventTarget {
       FunctionPrototypeCall(
         dispatchEvent,
         channel,
-        new (getMessageEvent())(event.type, { data: event.data })
+        getCreateMessageEvent()(event.type, event.data)
       );
     };
     FunctionPrototypeCall(addEventListener, port, "message", relay);

test-app/runtime/src/main/cpp/js/message-channel.js

@@ -53,12 +53,12 @@ const {
 const addEventListener = EventTarget.prototype.addEventListener;
 const dispatchEvent = EventTarget.prototype.dispatchEvent;
 
-let MessageEvent;
-function getMessageEvent() {
-  if (MessageEvent === undefined) {
-    ({ MessageEvent } = require("internal/message-event"));
+let createMessageEvent;
+function getCreateMessageEvent() {
+  if (createMessageEvent === undefined) {
+    ({ createMessageEvent } = require("internal/message-event"));
   }
-  return MessageEvent;
+  return createMessageEvent;
 }
 
 // WebIDL sequence<object>. Entries are handed to the native transfer-list
@@ -253,11 +253,10 @@ function emitMessage(data, ports, type) {
       ArrayPrototypePush(list, adoptPort(ports[i]));
     }
   }
-  const MessageEventCtor = getMessageEvent();
   FunctionPrototypeCall(
     dispatchEvent,
     this,
-    new MessageEventCtor(type, { data, ports: list })
+    getCreateMessageEvent()(type, data, list)
   );
 }
 

test-app/runtime/src/main/cpp/js/message-event.js

@@ -53,6 +53,12 @@ function toPortSequence(value) {
   return list;
 }
 
+// Builds the event a delivered message dispatches. The constructor cannot
+// serve delivery: per Web IDL its init dictionary treats `data: undefined` as
+// absent and defaults it to null, whereas a message that deserialized to
+// undefined has to arrive as undefined.
+let createMessageEvent;
+
 class MessageEvent extends Event {
   #data;
   #origin;
@@ -134,6 +140,17 @@ class MessageEvent extends Event {
     this.#source = source;
     this.#ports = ports === null ? [] : toPortSequence(ports);
   }
+
+  static {
+    createMessageEvent = (type, data, ports) => {
+      // Null-prototype init: the constructor reads every dictionary member,
+      // and one this object lacks would otherwise be looked up on
+      // Object.prototype, which app code can change.
+      const event = new MessageEvent(type, { __proto__: null, ports });
+      event.#data = data;
+      return event;
+    };
+  }
 }
 
 // Class members are non-enumerable; the IDL attributes and operations are not.
@@ -150,4 +167,4 @@ ObjectDefineProperty(MessageEvent.prototype, SymbolToStringTag, {
   configurable: true,
 });
 
-module.exports = { MessageEvent };
+module.exports = { MessageEvent, createMessageEvent };

test-app/runtime/src/main/cpp/js/node-worker-threads.js

@@ -48,12 +48,12 @@ const {
   globalEventTarget,
 } = require("internal/events");
 
-let MessageEvent;
-function getMessageEvent() {
-  if (MessageEvent === undefined) {
-    ({ MessageEvent } = require("internal/message-event"));
+let createMessageEvent;
+function getCreateMessageEvent() {
+  if (createMessageEvent === undefined) {
+    ({ createMessageEvent } = require("internal/message-event"));
   }
-  return MessageEvent;
+  return createMessageEvent;
 }
 
 const g = globalThis;
@@ -348,7 +348,7 @@ if (!isMainThread) {
     FunctionPrototypeCall(
       dispatchEvent,
       parentPort,
-      new (getMessageEvent())(event.type, { data: event.data, ports: event.ports })
+      getCreateMessageEvent()(event.type, event.data, event.ports)
     );
   };
   FunctionPrototypeCall(addEventListener, globalEventTarget, "message", relay);

test-app/runtime/src/main/cpp/js/worker-events.js

@@ -21,12 +21,12 @@ const {
 
 const g = globalThis;
 
-let MessageEvent;
-function getMessageEvent() {
-  if (MessageEvent === undefined) {
-    ({ MessageEvent } = require("internal/message-event"));
+let createMessageEvent;
+function getCreateMessageEvent() {
+  if (createMessageEvent === undefined) {
+    ({ createMessageEvent } = require("internal/message-event"));
   }
-  return MessageEvent;
+  return createMessageEvent;
 }
 
 // ErrorEvent is installed by the error-events builtin, which
@@ -49,8 +49,7 @@ function getErrorEvent() {
 // is what feeds the worker's onerror chain — the worker scope's handler
 // first, then the parent's — which the cross-runtime worker suite asserts.
 function emitMessage(data, ports, type) {
-  const MessageEventCtor = getMessageEvent();
-  dispatchEventRethrowing(this, new MessageEventCtor(type, { data, ports }));
+  dispatchEventRethrowing(this, getCreateMessageEvent()(type, data, ports));
 }
 
 // The parent-side error delivery callout, invoked by native with the Worker