@gjsify/worker_threads 0.1.0

package/src/index.spec.ts

@@ -0,0 +1,1591 @@
+// Ported from refs/node-test/parallel/test-worker-message-*.js,
+//   test-worker-broadcastchannel.js, test-worker-environmentdata.js,
+//   test-worker-message-port-close.js, test-worker-message-port-receive-message.js
+// Ported from refs/bun/test/js/node/worker_threads/worker_threads.test.ts
+// Original: MIT license, Node.js contributors / Oven (oven-sh)
+
+import { describe, it, expect } from '@gjsify/unit';
+import {
+  isMainThread,
+  parentPort,
+  workerData,
+  threadId,
+  resourceLimits,
+  SHARE_ENV,
+  Worker,
+  MessageChannel,
+  MessagePort,
+  BroadcastChannel,
+  receiveMessageOnPort,
+  getEnvironmentData,
+  setEnvironmentData,
+  markAsUntransferable,
+  moveMessagePortToContext,
+} from 'node:worker_threads';
+
+export default async () => {
+  // --- Module exports ---
+
+  await describe('worker_threads exports', async () => {
+    await it('should export isMainThread as true', async () => {
+      expect(isMainThread).toBe(true);
+    });
+
+    await it('should export parentPort as null', async () => {
+      expect(parentPort).toBeNull();
+    });
+
+    await it('should export workerData as null or undefined', async () => {
+      // Node.js returns undefined, our impl returns null — both are falsy
+      expect(workerData == null).toBe(true);
+    });
+
+    await it('should export threadId as 0', async () => {
+      expect(threadId).toBe(0);
+    });
+
+    await it('should export threadId as a number', async () => {
+      expect(typeof threadId).toBe('number');
+    });
+
+    await it('should export SHARE_ENV as a symbol', async () => {
+      expect(typeof SHARE_ENV).toBe('symbol');
+    });
+
+    await it('should export resourceLimits as an object', async () => {
+      expect(typeof resourceLimits).toBe('object');
+    });
+
+    await it('should export resourceLimits as non-null', async () => {
+      expect(resourceLimits).toBeDefined();
+    });
+
+    await it('should export all expected classes and functions', async () => {
+      expect(typeof Worker).toBe('function');
+      expect(typeof MessageChannel).toBe('function');
+      expect(typeof MessagePort).toBe('function');
+      expect(typeof BroadcastChannel).toBe('function');
+      expect(typeof receiveMessageOnPort).toBe('function');
+      expect(typeof getEnvironmentData).toBe('function');
+      expect(typeof setEnvironmentData).toBe('function');
+      expect(typeof markAsUntransferable).toBe('function');
+      expect(typeof moveMessagePortToContext).toBe('function');
+    });
+
+    await it('isMainThread should be a boolean', async () => {
+      expect(typeof isMainThread).toBe('boolean');
+    });
+
+    await it('SHARE_ENV should have a description', async () => {
+      // The symbol should have a meaningful description
+      expect(SHARE_ENV.toString().includes('SHARE_ENV')).toBe(true);
+    });
+  });
+
+  // --- MessageChannel ---
+
+  await describe('MessageChannel', async () => {
+    await it('should create port1 and port2 as MessagePort instances', async () => {
+      const channel = new MessageChannel();
+      expect(channel.port1).toBeDefined();
+      expect(channel.port2).toBeDefined();
+      expect(channel.port1 instanceof MessagePort).toBe(true);
+      expect(channel.port2 instanceof MessagePort).toBe(true);
+    });
+
+    await it('should create distinct ports', async () => {
+      const channel = new MessageChannel();
+      expect(channel.port1 !== channel.port2).toBe(true);
+      channel.port1.close();
+      channel.port2.close();
+    });
+
+    await it('should deliver string messages from port1 to port2', async () => {
+      const channel = new MessageChannel();
+      const received = await new Promise<unknown>((resolve) => {
+        channel.port2.on('message', resolve);
+        channel.port1.postMessage('hello');
+      });
+      expect(received).toBe('hello');
+      channel.port1.close();
+      channel.port2.close();
+    });
+
+    await it('should deliver messages from port2 to port1', async () => {
+      const channel = new MessageChannel();
+      const received = await new Promise<unknown>((resolve) => {
+        channel.port1.on('message', resolve);
+        channel.port2.postMessage('world');
+      });
+      expect(received).toBe('world');
+      channel.port1.close();
+      channel.port2.close();
+    });
+
+    await it('should clone object messages (not pass by reference)', async () => {
+      const channel = new MessageChannel();
+      const original = { key: 'value', nested: { a: 1 } };
+      const received = await new Promise<unknown>((resolve) => {
+        channel.port2.on('message', resolve);
+        channel.port1.postMessage(original);
+      });
+      expect(JSON.stringify(received)).toBe(JSON.stringify(original));
+      // Verify it's a clone, not the same reference
+      expect(received !== original).toBe(true);
+      channel.port1.close();
+      channel.port2.close();
+    });
+
+    await it('should deliver multiple messages in order', async () => {
+      const channel = new MessageChannel();
+      const messages: unknown[] = [];
+      const done = new Promise<void>((resolve) => {
+        channel.port2.on('message', (msg) => {
+          messages.push(msg);
+          if (messages.length === 3) resolve();
+        });
+      });
+      channel.port1.postMessage(1);
+      channel.port1.postMessage(2);
+      channel.port1.postMessage(3);
+      await done;
+      expect(messages.length).toBe(3);
+      expect(messages[0]).toBe(1);
+      expect(messages[1]).toBe(2);
+      expect(messages[2]).toBe(3);
+      channel.port1.close();
+      channel.port2.close();
+    });
+
+    await it('should handle various data types', async () => {
+      const channel = new MessageChannel();
+      const values = [42, true, null, [1, 2, 3], { a: 'b' }];
+      const received: unknown[] = [];
+      const done = new Promise<void>((resolve) => {
+        channel.port2.on('message', (msg) => {
+          received.push(msg);
+          if (received.length === values.length) resolve();
+        });
+      });
+      for (const val of values) {
+        channel.port1.postMessage(val);
+      }
+      await done;
+      expect(received.length).toBe(values.length);
+      expect(received[0]).toBe(42);
+      expect(received[1]).toBe(true);
+      expect(received[2]).toBeNull();
+      expect(JSON.stringify(received[3])).toBe(JSON.stringify([1, 2, 3]));
+      expect(JSON.stringify(received[4])).toBe(JSON.stringify({ a: 'b' }));
+      channel.port1.close();
+      channel.port2.close();
+    });
+
+    await it('should silently ignore messages after port is closed', async () => {
+      const channel = new MessageChannel();
+      let messageReceived = false;
+      channel.port2.on('message', () => { messageReceived = true; });
+      channel.port2.close();
+      channel.port1.postMessage('should not arrive');
+      await new Promise(resolve => setTimeout(resolve, 50));
+      expect(messageReceived).toBe(false);
+    });
+
+    await it('should deliver empty string', async () => {
+      const channel = new MessageChannel();
+      const received = await new Promise<unknown>((resolve) => {
+        channel.port2.on('message', resolve);
+        channel.port1.postMessage('');
+      });
+      expect(received).toBe('');
+      channel.port1.close();
+      channel.port2.close();
+    });
+
+    await it('should deliver undefined', async () => {
+      const channel = new MessageChannel();
+      const received = await new Promise<unknown>((resolve) => {
+        channel.port2.on('message', resolve);
+        channel.port1.postMessage(undefined);
+      });
+      expect(received).toBeUndefined();
+      channel.port1.close();
+      channel.port2.close();
+    });
+
+    await it('should deliver zero', async () => {
+      const channel = new MessageChannel();
+      const received = await new Promise<unknown>((resolve) => {
+        channel.port2.on('message', resolve);
+        channel.port1.postMessage(0);
+      });
+      expect(received).toBe(0);
+      channel.port1.close();
+      channel.port2.close();
+    });
+
+    await it('should deliver false', async () => {
+      const channel = new MessageChannel();
+      const received = await new Promise<unknown>((resolve) => {
+        channel.port2.on('message', resolve);
+        channel.port1.postMessage(false);
+      });
+      expect(received).toBe(false);
+      channel.port1.close();
+      channel.port2.close();
+    });
+
+    await it('should deliver deeply nested objects', async () => {
+      const channel = new MessageChannel();
+      const obj = { a: { b: { c: { d: { e: 42 } } } } };
+      const received = await new Promise<unknown>((resolve) => {
+        channel.port2.on('message', resolve);
+        channel.port1.postMessage(obj);
+      });
+      expect((received as any).a.b.c.d.e).toBe(42);
+      channel.port1.close();
+      channel.port2.close();
+    });
+
+    await it('should deliver large arrays', async () => {
+      const channel = new MessageChannel();
+      const arr = Array.from({ length: 1000 }, (_, i) => i);
+      const received = await new Promise<unknown>((resolve) => {
+        channel.port2.on('message', resolve);
+        channel.port1.postMessage(arr);
+      });
+      expect((received as number[]).length).toBe(1000);
+      expect((received as number[])[0]).toBe(0);
+      expect((received as number[])[999]).toBe(999);
+      channel.port1.close();
+      channel.port2.close();
+    });
+
+    await it('should support bidirectional communication', async () => {
+      const channel = new MessageChannel();
+      // port2 echoes back doubled value
+      channel.port2.on('message', (msg) => {
+        channel.port2.postMessage((msg as number) * 2);
+      });
+      const received = await new Promise<unknown>((resolve) => {
+        channel.port1.on('message', resolve);
+        channel.port1.postMessage(21);
+      });
+      expect(received).toBe(42);
+      channel.port1.close();
+      channel.port2.close();
+    });
+
+    await it('should create independent channels that do not interfere', async () => {
+      const ch1 = new MessageChannel();
+      const ch2 = new MessageChannel();
+      const results: unknown[] = [];
+      const done = new Promise<void>((resolve) => {
+        ch1.port2.on('message', (msg) => {
+          results.push({ ch: 1, msg });
+          if (results.length === 2) resolve();
+        });
+        ch2.port2.on('message', (msg) => {
+          results.push({ ch: 2, msg });
+          if (results.length === 2) resolve();
+        });
+      });
+      ch1.port1.postMessage('from-ch1');
+      ch2.port1.postMessage('from-ch2');
+      await done;
+      expect(results.length).toBe(2);
+      const ch1Msg = results.find((r: any) => r.ch === 1) as any;
+      const ch2Msg = results.find((r: any) => r.ch === 2) as any;
+      expect(ch1Msg.msg).toBe('from-ch1');
+      expect(ch2Msg.msg).toBe('from-ch2');
+      ch1.port1.close();
+      ch2.port1.close();
+    });
+  });
+
+  // --- MessagePort ---
+
+  await describe('MessagePort', async () => {
+    await it('should auto-start when on("message") is called', async () => {
+      const channel = new MessageChannel();
+      // Post before adding listener — message gets queued
+      channel.port1.postMessage('queued');
+      // Adding listener should auto-start and deliver queued message
+      const received = await new Promise<unknown>((resolve) => {
+        channel.port2.on('message', resolve);
+      });
+      expect(received).toBe('queued');
+      channel.port1.close();
+      channel.port2.close();
+    });
+
+    await it('should auto-start when addListener("message") is called', async () => {
+      const channel = new MessageChannel();
+      channel.port1.postMessage('queued-addlistener');
+      const received = await new Promise<unknown>((resolve) => {
+        channel.port2.addListener('message', resolve);
+      });
+      expect(received).toBe('queued-addlistener');
+      channel.port1.close();
+      channel.port2.close();
+    });
+
+    await it('should auto-start when once("message") is called', async () => {
+      const channel = new MessageChannel();
+      channel.port1.postMessage('queued-once');
+      const received = await new Promise<unknown>((resolve) => {
+        channel.port2.once('message', resolve);
+      });
+      expect(received).toBe('queued-once');
+      channel.port1.close();
+      channel.port2.close();
+    });
+
+    await it('should not auto-start for non-message events', async () => {
+      const channel = new MessageChannel();
+      channel.port1.postMessage('will-be-queued');
+      // Listening for 'close' should NOT auto-start the port
+      channel.port2.on('close', () => { /* no-op */ });
+      // The message should remain in the queue
+      const result = receiveMessageOnPort(channel.port2);
+      expect(result).toBeDefined();
+      expect((result as { message: unknown }).message).toBe('will-be-queued');
+      channel.port1.close();
+      channel.port2.close();
+    });
+
+    await it('should emit close event when closed', async () => {
+      const channel = new MessageChannel();
+      const closed = new Promise<void>((resolve) => {
+        channel.port1.on('close', resolve);
+      });
+      channel.port1.close();
+      await closed;
+    });
+
+    await it('should emit close event on port2 when port2 is closed', async () => {
+      const channel = new MessageChannel();
+      const closed = new Promise<void>((resolve) => {
+        channel.port2.on('close', resolve);
+      });
+      channel.port2.close();
+      await closed;
+    });
+
+    await it('ref() and unref() should not throw', async () => {
+      const channel = new MessageChannel();
+      const port = channel.port1;
+      // Native Node.js ref/unref return undefined; our impl returns this
+      // Just verify they don't throw
+      port.ref();
+      port.unref();
+      channel.port1.close();
+      channel.port2.close();
+    });
+
+    await it('ref() should not throw', async () => {
+      const channel = new MessageChannel();
+      channel.port1.ref();
+      channel.port1.close();
+      channel.port2.close();
+    });
+
+    await it('unref() should not throw', async () => {
+      const channel = new MessageChannel();
+      channel.port1.unref();
+      channel.port1.close();
+      channel.port2.close();
+    });
+
+    await it('should support once() for single message', async () => {
+      const channel = new MessageChannel();
+      const first = await new Promise<unknown>((resolve) => {
+        channel.port2.once('message', resolve);
+        channel.port1.postMessage('only-once');
+      });
+      expect(first).toBe('only-once');
+      channel.port1.close();
+      channel.port2.close();
+    });
+
+    await it('once() should only receive one message', async () => {
+      const channel = new MessageChannel();
+      let count = 0;
+      channel.port2.once('message', () => { count++; });
+      channel.port1.postMessage('msg1');
+      channel.port1.postMessage('msg2');
+      await new Promise(resolve => setTimeout(resolve, 50));
+      expect(count).toBe(1);
+      channel.port1.close();
+      channel.port2.close();
+    });
+
+    await it('close() should be idempotent', async () => {
+      const channel = new MessageChannel();
+      channel.port1.close();
+      // Second close should not throw
+      channel.port1.close();
+      channel.port1.close();
+    });
+
+    await it('should support start() explicitly', async () => {
+      const channel = new MessageChannel();
+      // Use addEventListener which does NOT auto-start
+      let received: unknown = null;
+      (channel.port2 as any).addEventListener('message', (event: any) => {
+        received = event.data;
+      });
+      channel.port1.postMessage('explicit-start');
+      // Not started yet — message should be queued
+      await new Promise(resolve => setTimeout(resolve, 20));
+      // Now start
+      channel.port2.start();
+      await new Promise(resolve => setTimeout(resolve, 50));
+      expect(received).toBe('explicit-start');
+      channel.port1.close();
+      channel.port2.close();
+    });
+
+    await it('start() should be idempotent', async () => {
+      const channel = new MessageChannel();
+      channel.port1.start();
+      channel.port1.start();
+      channel.port1.start();
+      channel.port1.close();
+      channel.port2.close();
+    });
+
+    await it('start() on closed port should not throw', async () => {
+      const channel = new MessageChannel();
+      channel.port1.close();
+      // Should not throw
+      channel.port1.start();
+    });
+
+    await it('postMessage on closed sender should be silently ignored', async () => {
+      const channel = new MessageChannel();
+      let received = false;
+      channel.port2.on('message', () => { received = true; });
+      channel.port1.close();
+      // postMessage after close should not throw, just be ignored
+      channel.port1.postMessage('after-close');
+      await new Promise(resolve => setTimeout(resolve, 50));
+      expect(received).toBe(false);
+    });
+
+    await it('should not deliver messages after close', async () => {
+      const channel = new MessageChannel();
+      let count = 0;
+      channel.port1.on('message', () => { count++; });
+      channel.port1.close();
+      // Messages should not be delivered after close
+      channel.port2.postMessage('after-close');
+      await new Promise(resolve => setTimeout(resolve, 50));
+      expect(count).toBe(0);
+    });
+
+    await it('should deliver queued messages posted before listener is attached', async () => {
+      const channel = new MessageChannel();
+      // Post messages before any listener
+      channel.port1.postMessage('a');
+      channel.port1.postMessage('b');
+      channel.port1.postMessage('c');
+      // Attach listener later
+      const messages: unknown[] = [];
+      const done = new Promise<void>((resolve) => {
+        channel.port2.on('message', (msg) => {
+          messages.push(msg);
+          if (messages.length === 3) resolve();
+        });
+      });
+      await done;
+      expect(messages[0]).toBe('a');
+      expect(messages[1]).toBe('b');
+      expect(messages[2]).toBe('c');
+      channel.port1.close();
+      channel.port2.close();
+    });
+  });
+
+  // --- receiveMessageOnPort ---
+
+  await describe('receiveMessageOnPort', async () => {
+    await it('should return undefined when no messages queued', async () => {
+      const channel = new MessageChannel();
+      const result = receiveMessageOnPort(channel.port2);
+      expect(result).toBeUndefined();
+      channel.port1.close();
+      channel.port2.close();
+    });
+
+    await it('should return queued message synchronously', async () => {
+      const channel = new MessageChannel();
+      // Post a message — it gets queued because port2 hasn't started
+      channel.port1.postMessage('sync-msg');
+      const result = receiveMessageOnPort(channel.port2);
+      expect(result).toBeDefined();
+      expect((result as { message: unknown }).message).toBe('sync-msg');
+      channel.port1.close();
+      channel.port2.close();
+    });
+
+    await it('should dequeue messages one at a time in order', async () => {
+      const channel = new MessageChannel();
+      channel.port1.postMessage('first');
+      channel.port1.postMessage('second');
+      channel.port1.postMessage('third');
+
+      const r1 = receiveMessageOnPort(channel.port2);
+      expect((r1 as { message: unknown }).message).toBe('first');
+
+      const r2 = receiveMessageOnPort(channel.port2);
+      expect((r2 as { message: unknown }).message).toBe('second');
+
+      const r3 = receiveMessageOnPort(channel.port2);
+      expect((r3 as { message: unknown }).message).toBe('third');
+
+      const r4 = receiveMessageOnPort(channel.port2);
+      expect(r4).toBeUndefined();
+
+      channel.port1.close();
+      channel.port2.close();
+    });
+
+    await it('should return undefined after all messages consumed', async () => {
+      const channel = new MessageChannel();
+      channel.port1.postMessage('only');
+      const r1 = receiveMessageOnPort(channel.port2);
+      expect((r1 as { message: unknown }).message).toBe('only');
+      // Second call should return undefined
+      const r2 = receiveMessageOnPort(channel.port2);
+      expect(r2).toBeUndefined();
+      // Third call should also return undefined
+      const r3 = receiveMessageOnPort(channel.port2);
+      expect(r3).toBeUndefined();
+      channel.port1.close();
+      channel.port2.close();
+    });
+
+    await it('should receive object messages with correct wrapping', async () => {
+      const channel = new MessageChannel();
+      const message = { hello: 'world', count: 42 };
+      channel.port1.postMessage(message);
+      const result = receiveMessageOnPort(channel.port2);
+      expect(result).toBeDefined();
+      const received = (result as { message: unknown }).message as any;
+      expect(received.hello).toBe('world');
+      expect(received.count).toBe(42);
+      channel.port1.close();
+      channel.port2.close();
+    });
+
+    await it('should receive null message', async () => {
+      const channel = new MessageChannel();
+      channel.port1.postMessage(null);
+      const result = receiveMessageOnPort(channel.port2);
+      expect(result).toBeDefined();
+      expect((result as { message: unknown }).message).toBeNull();
+      channel.port1.close();
+      channel.port2.close();
+    });
+
+    await it('should receive boolean messages', async () => {
+      const channel = new MessageChannel();
+      channel.port1.postMessage(true);
+      channel.port1.postMessage(false);
+      const r1 = receiveMessageOnPort(channel.port2);
+      expect((r1 as { message: unknown }).message).toBe(true);
+      const r2 = receiveMessageOnPort(channel.port2);
+      expect((r2 as { message: unknown }).message).toBe(false);
+      channel.port1.close();
+      channel.port2.close();
+    });
+
+    await it('should work on port1 side too', async () => {
+      const channel = new MessageChannel();
+      channel.port2.postMessage('from-port2');
+      const result = receiveMessageOnPort(channel.port1);
+      expect(result).toBeDefined();
+      expect((result as { message: unknown }).message).toBe('from-port2');
+      channel.port1.close();
+      channel.port2.close();
+    });
+  });
+
+  // --- BroadcastChannel ---
+
+  await describe('BroadcastChannel', async () => {
+    await it('should create a channel with a name', async () => {
+      const bc = new BroadcastChannel('test-name');
+      expect(bc.name).toBe('test-name');
+      bc.close();
+    });
+
+    await it('should coerce name to string', async () => {
+      const bc = new BroadcastChannel(42 as unknown as string);
+      expect(bc.name).toBe('42');
+      bc.close();
+    });
+
+    await it('should coerce null name to string', async () => {
+      const bc = new BroadcastChannel(null as unknown as string);
+      expect(bc.name).toBe('null');
+      bc.close();
+    });
+
+    await it('should coerce undefined name to string', async () => {
+      const bc = new BroadcastChannel(undefined as unknown as string);
+      expect(bc.name).toBe('undefined');
+      bc.close();
+    });
+
+    await it('should coerce boolean name to string', async () => {
+      const bc = new BroadcastChannel(false as unknown as string);
+      expect(bc.name).toBe('false');
+      bc.close();
+    });
+
+    await it('should coerce Infinity name to string', async () => {
+      const bc = new BroadcastChannel(Infinity as unknown as string);
+      expect(bc.name).toBe('Infinity');
+      bc.close();
+    });
+
+    await it('should deliver messages to other channels with same name', async () => {
+      const bc1 = new BroadcastChannel('bc-deliver');
+      const bc2 = new BroadcastChannel('bc-deliver');
+
+      const received = await new Promise<unknown>((resolve) => {
+        (bc2 as any).onmessage = (event: any) => resolve(event.data);
+        bc1.postMessage('broadcast-hello');
+      });
+
+      expect(received).toBe('broadcast-hello');
+      bc1.close();
+      bc2.close();
+    });
+
+    await it('should not deliver messages to self', async () => {
+      const bc = new BroadcastChannel('bc-self');
+      let received = false;
+      (bc as any).onmessage = () => { received = true; };
+      bc.postMessage('self');
+      await new Promise(resolve => setTimeout(resolve, 50));
+      expect(received).toBe(false);
+      bc.close();
+    });
+
+    await it('should not deliver to channels with different name', async () => {
+      const bc1 = new BroadcastChannel('bc-name-a');
+      const bc2 = new BroadcastChannel('bc-name-b');
+      let received = false;
+      (bc2 as any).onmessage = () => { received = true; };
+      bc1.postMessage('wrong-channel');
+      await new Promise(resolve => setTimeout(resolve, 50));
+      expect(received).toBe(false);
+      bc1.close();
+      bc2.close();
+    });
+
+    await it('should throw when posting to a closed channel', async () => {
+      const bc = new BroadcastChannel('bc-closed');
+      bc.close();
+      let threw = false;
+      try {
+        bc.postMessage('should-fail');
+      } catch {
+        threw = true;
+      }
+      expect(threw).toBe(true);
+    });
+
+    await it('should not deliver to closed receivers', async () => {
+      const bc1 = new BroadcastChannel('bc-closed-recv');
+      const bc2 = new BroadcastChannel('bc-closed-recv');
+      let received = false;
+      (bc2 as any).onmessage = () => { received = true; };
+      bc2.close();
+      bc1.postMessage('after-close');
+      await new Promise(resolve => setTimeout(resolve, 50));
+      expect(received).toBe(false);
+      bc1.close();
+    });
+
+    await it('should deliver to multiple receivers', async () => {
+      const bc1 = new BroadcastChannel('bc-multi');
+      const bc2 = new BroadcastChannel('bc-multi');
+      const bc3 = new BroadcastChannel('bc-multi');
+
+      let count = 0;
+      const done = new Promise<void>((resolve) => {
+        const handler = () => { count++; if (count === 2) resolve(); };
+        (bc2 as any).onmessage = handler;
+        (bc3 as any).onmessage = handler;
+      });
+
+      bc1.postMessage('to-all');
+      await done;
+      expect(count).toBe(2);
+
+      bc1.close();
+      bc2.close();
+      bc3.close();
+    });
+
+    await it('close() should be idempotent', async () => {
+      const bc = new BroadcastChannel('bc-idempotent-close');
+      bc.close();
+      // Second close should not throw
+      bc.close();
+      bc.close();
+    });
+
+    await it('should deliver cloned data, not references', async () => {
+      const bc1 = new BroadcastChannel('bc-clone');
+      const bc2 = new BroadcastChannel('bc-clone');
+      const original = { key: 'value', items: [1, 2, 3] };
+
+      const received = await new Promise<unknown>((resolve) => {
+        (bc2 as any).onmessage = (event: any) => resolve(event.data);
+        bc1.postMessage(original);
+      });
+
+      expect(JSON.stringify(received)).toBe(JSON.stringify(original));
+      // Should be a clone, not the same reference
+      expect(received !== original).toBe(true);
+      bc1.close();
+      bc2.close();
+    });
+
+    await it('should deliver numeric messages', async () => {
+      const bc1 = new BroadcastChannel('bc-numeric');
+      const bc2 = new BroadcastChannel('bc-numeric');
+
+      const received = await new Promise<unknown>((resolve) => {
+        (bc2 as any).onmessage = (event: any) => resolve(event.data);
+        bc1.postMessage(42);
+      });
+
+      expect(received).toBe(42);
+      bc1.close();
+      bc2.close();
+    });
+
+    await it('should deliver null message', async () => {
+      const bc1 = new BroadcastChannel('bc-null');
+      const bc2 = new BroadcastChannel('bc-null');
+
+      const received = await new Promise<unknown>((resolve) => {
+        (bc2 as any).onmessage = (event: any) => resolve(event.data);
+        bc1.postMessage(null);
+      });
+
+      expect(received).toBeNull();
+      bc1.close();
+      bc2.close();
+    });
+
+    await it('should deliver multiple messages in order', async () => {
+      const bc1 = new BroadcastChannel('bc-order');
+      const bc2 = new BroadcastChannel('bc-order');
+      const messages: unknown[] = [];
+
+      const done = new Promise<void>((resolve) => {
+        (bc2 as any).onmessage = (event: any) => {
+          messages.push(event.data);
+          if (messages.length === 3) resolve();
+        };
+      });
+
+      bc1.postMessage('first');
+      bc1.postMessage('second');
+      bc1.postMessage('third');
+
+      await done;
+      expect(messages[0]).toBe('first');
+      expect(messages[1]).toBe('second');
+      expect(messages[2]).toBe('third');
+      bc1.close();
+      bc2.close();
+    });
+
+    await it('should not deliver after close', async () => {
+      const bc1 = new BroadcastChannel('bc-no-deliver-after-close');
+      const bc2 = new BroadcastChannel('bc-no-deliver-after-close');
+      let received = false;
+      (bc2 as any).onmessage = () => { received = true; };
+      bc2.close();
+      bc1.postMessage('should-not-arrive');
+      await new Promise(resolve => setTimeout(resolve, 50));
+      expect(received).toBe(false);
+      bc1.close();
+    });
+  });
+
+  // --- Environment Data ---
+
+  await describe('environmentData', async () => {
+    await it('should store and retrieve data', async () => {
+      setEnvironmentData('testKey', 'testValue');
+      expect(getEnvironmentData('testKey')).toBe('testValue');
+    });
+
+    await it('should return undefined for missing keys', async () => {
+      expect(getEnvironmentData('nonexistent-key-12345')).toBeUndefined();
+    });
+
+    await it('should delete data when value is undefined', async () => {
+      setEnvironmentData('toDelete', 'value');
+      expect(getEnvironmentData('toDelete')).toBe('value');
+      setEnvironmentData('toDelete', undefined);
+      expect(getEnvironmentData('toDelete')).toBeUndefined();
+    });
+
+    await it('should overwrite existing data', async () => {
+      setEnvironmentData('overwrite-key', 'first');
+      expect(getEnvironmentData('overwrite-key')).toBe('first');
+      setEnvironmentData('overwrite-key', 'second');
+      expect(getEnvironmentData('overwrite-key')).toBe('second');
+    });
+
+    await it('should store numeric values', async () => {
+      setEnvironmentData('num-key', 42);
+      expect(getEnvironmentData('num-key')).toBe(42);
+    });
+
+    await it('should store object values', async () => {
+      const obj = { hello: 'world' };
+      setEnvironmentData('obj-key', obj);
+      expect((getEnvironmentData('obj-key') as any).hello).toBe('world');
+    });
+
+    await it('should store boolean values', async () => {
+      setEnvironmentData('bool-true', true);
+      setEnvironmentData('bool-false', false);
+      expect(getEnvironmentData('bool-true')).toBe(true);
+      expect(getEnvironmentData('bool-false')).toBe(false);
+    });
+
+    await it('should store null value', async () => {
+      setEnvironmentData('null-key', null as unknown as string);
+      expect(getEnvironmentData('null-key')).toBeNull();
+    });
+
+    await it('should store empty string', async () => {
+      setEnvironmentData('empty-str', '');
+      expect(getEnvironmentData('empty-str')).toBe('');
+    });
+
+    await it('should handle multiple keys independently', async () => {
+      setEnvironmentData('multi-a', 'alpha');
+      setEnvironmentData('multi-b', 'beta');
+      setEnvironmentData('multi-c', 'gamma');
+      expect(getEnvironmentData('multi-a')).toBe('alpha');
+      expect(getEnvironmentData('multi-b')).toBe('beta');
+      expect(getEnvironmentData('multi-c')).toBe('gamma');
+      // Deleting one should not affect others
+      setEnvironmentData('multi-b', undefined);
+      expect(getEnvironmentData('multi-a')).toBe('alpha');
+      expect(getEnvironmentData('multi-b')).toBeUndefined();
+      expect(getEnvironmentData('multi-c')).toBe('gamma');
+    });
+  });
+
+  // --- Utility functions ---
+
+  await describe('utility functions', async () => {
+    await it('markAsUntransferable should not throw', async () => {
+      markAsUntransferable({});
+      markAsUntransferable(new ArrayBuffer(8));
+    });
+
+    await it('markAsUntransferable should accept various objects', async () => {
+      markAsUntransferable(new Uint8Array(4));
+      markAsUntransferable([1, 2, 3]);
+      markAsUntransferable({ key: 'value' });
+    });
+
+    await it('moveMessagePortToContext should be a function', async () => {
+      // Native Node.js requires a vm.Context — just verify it's exported
+      expect(typeof moveMessagePortToContext).toBe('function');
+    });
+
+    await it('moveMessagePortToContext should be callable', async () => {
+      // Native Node.js requires a vm.Context — just verify it's exported and callable
+      expect(typeof moveMessagePortToContext).toBe('function');
+    });
+  });
+
+  // --- BroadcastChannel.addEventListener ---
+  // Ported from refs/node-test/parallel/test-worker-broadcastchannel.js
+
+  await describe('BroadcastChannel.addEventListener', async () => {
+    await it('should receive messages via addEventListener', async () => {
+      const bc1 = new BroadcastChannel('bc-ae');
+      const bc2 = new BroadcastChannel('bc-ae');
+
+      const received = await new Promise<unknown>((resolve) => {
+        bc1.addEventListener('message', (event) => resolve((event as unknown as { data: unknown }).data));
+        bc2.postMessage('addEventListener-hello');
+      });
+
+      expect(received).toBe('addEventListener-hello');
+      bc1.close();
+      bc2.close();
+    });
+
+    await it('should support removeEventListener to stop receiving', async () => {
+      const bc1 = new BroadcastChannel('bc-ael-remove');
+      const bc2 = new BroadcastChannel('bc-ael-remove');
+
+      let count = 0;
+      const handler = () => { count++; };
+      bc1.addEventListener('message', handler);
+      bc2.postMessage('msg1');
+      await new Promise(resolve => setTimeout(resolve, 50));
+      bc1.removeEventListener('message', handler);
+      bc2.postMessage('msg2');
+      await new Promise(resolve => setTimeout(resolve, 50));
+
+      expect(count).toBe(1);
+      bc1.close();
+      bc2.close();
+    });
+
+    await it('multiple channels with same name via addEventListener', async () => {
+      const bc1 = new BroadcastChannel('bc-multi-ae');
+      const bc2 = new BroadcastChannel('bc-multi-ae');
+      const bc3 = new BroadcastChannel('bc-multi-ae');
+
+      let count = 0;
+      const done = new Promise<void>((resolve) => {
+        const handler = () => { count++; if (count === 2) resolve(); };
+        bc2.addEventListener('message', handler);
+        bc3.addEventListener('message', handler);
+      });
+
+      bc1.postMessage('multi-ae');
+      await done;
+      expect(count).toBe(2);
+      bc1.close();
+      bc2.close();
+      bc3.close();
+    });
+
+    await it('removeEventListener with null should not throw', async () => {
+      const bc = new BroadcastChannel('bc-ae-null');
+      (bc as any).removeEventListener('message', null);
+      bc.close();
+    });
+
+    await it('addEventListener with null should not throw', async () => {
+      const bc = new BroadcastChannel('bc-ae-null-add');
+      (bc as any).addEventListener('message', null);
+      bc.close();
+    });
+  });
+
+  // --- MessagePort.addEventListener ---
+
+  await describe('MessagePort.addEventListener', async () => {
+    await it('should receive messages via addEventListener', async () => {
+      const channel = new MessageChannel();
+
+      const received = await new Promise<unknown>((resolve) => {
+        (channel.port2 as any).addEventListener('message', (event: unknown) => {
+          resolve((event as { data: unknown }).data);
+        });
+        channel.port2.start(); // must call start() when using addEventListener
+        channel.port1.postMessage('ae-message');
+      });
+
+      expect(received).toBe('ae-message');
+      channel.port1.close();
+      channel.port2.close();
+    });
+
+    await it('should support removeEventListener on MessagePort', async () => {
+      const channel = new MessageChannel();
+      let count = 0;
+      const handler = (_event: unknown) => { count++; };
+
+      (channel.port2 as any).addEventListener('message', handler);
+      channel.port2.start();
+      channel.port1.postMessage('first');
+      await new Promise(resolve => setTimeout(resolve, 50));
+      (channel.port2 as any).removeEventListener('message', handler);
+      channel.port1.postMessage('second');
+      await new Promise(resolve => setTimeout(resolve, 50));
+
+      expect(count).toBe(1);
+      channel.port1.close();
+      channel.port2.close();
+    });
+
+    await it('addEventListener should wrap message in event-like object', async () => {
+      const channel = new MessageChannel();
+      const event = await new Promise<unknown>((resolve) => {
+        (channel.port2 as any).addEventListener('message', resolve);
+        channel.port2.start();
+        channel.port1.postMessage('wrapped');
+      });
+      const ev = event as { data: unknown; type: string };
+      expect(ev.data).toBe('wrapped');
+      expect(ev.type).toBe('message');
+      channel.port1.close();
+      channel.port2.close();
+    });
+
+    await it('removeEventListener with null should not throw', async () => {
+      const channel = new MessageChannel();
+      (channel.port1 as any).removeEventListener('message', null);
+      channel.port1.close();
+      channel.port2.close();
+    });
+
+    await it('addEventListener with null should not throw', async () => {
+      const channel = new MessageChannel();
+      (channel.port1 as any).addEventListener('message', null);
+      channel.port1.close();
+      channel.port2.close();
+    });
+
+    await it('should support addEventListener for non-message events', async () => {
+      const channel = new MessageChannel();
+      const closed = new Promise<void>((resolve) => {
+        (channel.port1 as any).addEventListener('close', resolve);
+      });
+      channel.port1.close();
+      await closed;
+      channel.port2.close();
+    });
+  });
+
+  // --- MessageChannel structured clone edge cases ---
+
+  await describe('MessageChannel clone edge cases', async () => {
+    await it('should clone -0 as -0', async () => {
+      const channel = new MessageChannel();
+      const received = await new Promise<unknown>((resolve) => {
+        channel.port2.on('message', resolve);
+        channel.port1.postMessage(-0);
+      });
+      expect(Object.is(received, -0)).toBe(true);
+      channel.port1.close();
+    });
+
+    await it('should clone NaN', async () => {
+      const channel = new MessageChannel();
+      const received = await new Promise<unknown>((resolve) => {
+        channel.port2.on('message', resolve);
+        channel.port1.postMessage(NaN);
+      });
+      expect(Number.isNaN(received)).toBe(true);
+      channel.port1.close();
+    });
+
+    await it('should clone Infinity', async () => {
+      const channel = new MessageChannel();
+      const received = await new Promise<unknown>((resolve) => {
+        channel.port2.on('message', resolve);
+        channel.port1.postMessage(Infinity);
+      });
+      expect(received).toBe(Infinity);
+      channel.port1.close();
+    });
+
+    await it('should clone -Infinity', async () => {
+      const channel = new MessageChannel();
+      const received = await new Promise<unknown>((resolve) => {
+        channel.port2.on('message', resolve);
+        channel.port1.postMessage(-Infinity);
+      });
+      expect(received).toBe(-Infinity);
+      channel.port1.close();
+    });
+
+    await it('should clone BigInt', async () => {
+      const channel = new MessageChannel();
+      const received = await new Promise<unknown>((resolve) => {
+        channel.port2.on('message', resolve);
+        channel.port1.postMessage(9007199254740993n);
+      });
+      expect(received).toBe(9007199254740993n);
+      channel.port1.close();
+    });
+
+    await it('should clone BigInt zero', async () => {
+      const channel = new MessageChannel();
+      const received = await new Promise<unknown>((resolve) => {
+        channel.port2.on('message', resolve);
+        channel.port1.postMessage(0n);
+      });
+      expect(received).toBe(0n);
+      channel.port1.close();
+    });
+
+    await it('should clone negative BigInt', async () => {
+      const channel = new MessageChannel();
+      const received = await new Promise<unknown>((resolve) => {
+        channel.port2.on('message', resolve);
+        channel.port1.postMessage(-42n);
+      });
+      expect(received).toBe(-42n);
+      channel.port1.close();
+    });
+
+    await it('should clone Int32Array', async () => {
+      const channel = new MessageChannel();
+      const arr = new Int32Array([100, 200, 300]);
+      const received = await new Promise<unknown>((resolve) => {
+        channel.port2.on('message', resolve);
+        channel.port1.postMessage(arr);
+      });
+      expect(received instanceof Int32Array).toBe(true);
+      expect((received as Int32Array)[0]).toBe(100);
+      expect((received as Int32Array)[2]).toBe(300);
+      channel.port1.close();
+    });
+
+    await it('should clone Float64Array', async () => {
+      const channel = new MessageChannel();
+      const arr = new Float64Array([1.1, 2.2, 3.3]);
+      const received = await new Promise<unknown>((resolve) => {
+        channel.port2.on('message', resolve);
+        channel.port1.postMessage(arr);
+      });
+      expect(received instanceof Float64Array).toBe(true);
+      expect((received as Float64Array).length).toBe(3);
+      channel.port1.close();
+    });
+
+    await it('should clone ArrayBuffer', async () => {
+      const channel = new MessageChannel();
+      const buf = new ArrayBuffer(8);
+      const view = new Uint8Array(buf);
+      view[0] = 1;
+      view[7] = 255;
+      const received = await new Promise<unknown>((resolve) => {
+        channel.port2.on('message', resolve);
+        channel.port1.postMessage(buf);
+      });
+      expect(received instanceof ArrayBuffer).toBe(true);
+      const rView = new Uint8Array(received as ArrayBuffer);
+      expect(rView[0]).toBe(1);
+      expect(rView[7]).toBe(255);
+      channel.port1.close();
+    });
+
+    await it('should clone empty array', async () => {
+      const channel = new MessageChannel();
+      const received = await new Promise<unknown>((resolve) => {
+        channel.port2.on('message', resolve);
+        channel.port1.postMessage([]);
+      });
+      expect(Array.isArray(received)).toBe(true);
+      expect((received as unknown[]).length).toBe(0);
+      channel.port1.close();
+    });
+
+    await it('should clone empty object', async () => {
+      const channel = new MessageChannel();
+      const received = await new Promise<unknown>((resolve) => {
+        channel.port2.on('message', resolve);
+        channel.port1.postMessage({});
+      });
+      expect(typeof received).toBe('object');
+      expect(received).toBeDefined();
+      expect(Object.keys(received as object).length).toBe(0);
+      channel.port1.close();
+    });
+  });
+
+  // --- Structured clone (deep clone) ---
+
+  await describe('MessageChannel structured clone', async () => {
+    await it('should clone Date objects', async () => {
+      const channel = new MessageChannel();
+      const date = new Date('2026-01-15T12:00:00Z');
+      const received = await new Promise<unknown>((resolve) => {
+        channel.port2.on('message', resolve);
+        channel.port1.postMessage(date);
+      });
+      expect(received instanceof Date).toBe(true);
+      expect((received as Date).getTime()).toBe(date.getTime());
+      channel.port1.close();
+    });
+
+    await it('should clone Date and preserve time', async () => {
+      const channel = new MessageChannel();
+      const date = new Date(0); // Unix epoch
+      const received = await new Promise<unknown>((resolve) => {
+        channel.port2.on('message', resolve);
+        channel.port1.postMessage(date);
+      });
+      expect(received instanceof Date).toBe(true);
+      expect((received as Date).getTime()).toBe(0);
+      channel.port1.close();
+    });
+
+    await it('should clone RegExp objects', async () => {
+      const channel = new MessageChannel();
+      const regex = /hello\d+/gi;
+      const received = await new Promise<unknown>((resolve) => {
+        channel.port2.on('message', resolve);
+        channel.port1.postMessage(regex);
+      });
+      expect(received instanceof RegExp).toBe(true);
+      expect((received as RegExp).source).toBe('hello\\d+');
+      expect((received as RegExp).flags).toBe('gi');
+      channel.port1.close();
+    });
+
+    await it('should clone RegExp without flags', async () => {
+      const channel = new MessageChannel();
+      const regex = /simple/;
+      const received = await new Promise<unknown>((resolve) => {
+        channel.port2.on('message', resolve);
+        channel.port1.postMessage(regex);
+      });
+      expect(received instanceof RegExp).toBe(true);
+      expect((received as RegExp).source).toBe('simple');
+      expect((received as RegExp).flags).toBe('');
+      channel.port1.close();
+    });
+
+    await it('should clone Map objects', async () => {
+      const channel = new MessageChannel();
+      const map = new Map([['key1', 'value1'], ['key2', 'value2']]);
+      const received = await new Promise<unknown>((resolve) => {
+        channel.port2.on('message', resolve);
+        channel.port1.postMessage(map);
+      });
+      expect(received instanceof Map).toBe(true);
+      expect((received as Map<string, string>).get('key1')).toBe('value1');
+      expect((received as Map<string, string>).get('key2')).toBe('value2');
+      expect((received as Map<string, string>).size).toBe(2);
+      channel.port1.close();
+    });
+
+    await it('should clone empty Map', async () => {
+      const channel = new MessageChannel();
+      const map = new Map();
+      const received = await new Promise<unknown>((resolve) => {
+        channel.port2.on('message', resolve);
+        channel.port1.postMessage(map);
+      });
+      expect(received instanceof Map).toBe(true);
+      expect((received as Map<unknown, unknown>).size).toBe(0);
+      channel.port1.close();
+    });
+
+    await it('should clone Set objects', async () => {
+      const channel = new MessageChannel();
+      const set = new Set([1, 2, 3]);
+      const received = await new Promise<unknown>((resolve) => {
+        channel.port2.on('message', resolve);
+        channel.port1.postMessage(set);
+      });
+      expect(received instanceof Set).toBe(true);
+      expect((received as Set<number>).has(1)).toBe(true);
+      expect((received as Set<number>).has(2)).toBe(true);
+      expect((received as Set<number>).has(3)).toBe(true);
+      expect((received as Set<number>).size).toBe(3);
+      channel.port1.close();
+    });
+
+    await it('should clone empty Set', async () => {
+      const channel = new MessageChannel();
+      const set = new Set();
+      const received = await new Promise<unknown>((resolve) => {
+        channel.port2.on('message', resolve);
+        channel.port1.postMessage(set);
+      });
+      expect(received instanceof Set).toBe(true);
+      expect((received as Set<unknown>).size).toBe(0);
+      channel.port1.close();
+    });
+
+    await it('should clone Error objects', async () => {
+      const channel = new MessageChannel();
+      const error = new Error('test error');
+      error.name = 'CustomError';
+      const received = await new Promise<unknown>((resolve) => {
+        channel.port2.on('message', resolve);
+        channel.port1.postMessage(error);
+      });
+      expect(received instanceof Error).toBe(true);
+      expect((received as Error).message).toBe('test error');
+      channel.port1.close();
+    });
+
+    await it('should clone TypeError', async () => {
+      const channel = new MessageChannel();
+      const error = new TypeError('type error test');
+      const received = await new Promise<unknown>((resolve) => {
+        channel.port2.on('message', resolve);
+        channel.port1.postMessage(error);
+      });
+      expect(received instanceof Error).toBe(true);
+      expect((received as Error).message).toBe('type error test');
+      channel.port1.close();
+    });
+
+    await it('should clone RangeError', async () => {
+      const channel = new MessageChannel();
+      const error = new RangeError('range error test');
+      const received = await new Promise<unknown>((resolve) => {
+        channel.port2.on('message', resolve);
+        channel.port1.postMessage(error);
+      });
+      expect(received instanceof Error).toBe(true);
+      expect((received as Error).message).toBe('range error test');
+      channel.port1.close();
+    });
+
+    await it('should clone Uint8Array', async () => {
+      const channel = new MessageChannel();
+      const arr = new Uint8Array([1, 2, 3, 4, 5]);
+      const received = await new Promise<unknown>((resolve) => {
+        channel.port2.on('message', resolve);
+        channel.port1.postMessage(arr);
+      });
+      expect(received instanceof Uint8Array).toBe(true);
+      expect((received as Uint8Array).length).toBe(5);
+      expect((received as Uint8Array)[0]).toBe(1);
+      expect((received as Uint8Array)[4]).toBe(5);
+      channel.port1.close();
+    });
+
+    await it('should clone Uint16Array', async () => {
+      const channel = new MessageChannel();
+      const arr = new Uint16Array([256, 512, 1024]);
+      const received = await new Promise<unknown>((resolve) => {
+        channel.port2.on('message', resolve);
+        channel.port1.postMessage(arr);
+      });
+      expect(received instanceof Uint16Array).toBe(true);
+      expect((received as Uint16Array)[0]).toBe(256);
+      expect((received as Uint16Array)[2]).toBe(1024);
+      channel.port1.close();
+    });
+
+    await it('should clone nested objects with complex types', async () => {
+      const channel = new MessageChannel();
+      const obj = {
+        date: new Date('2026-03-25'),
+        items: [1, 'two', { three: 3 }],
+        nested: { deep: true },
+      };
+      const received = await new Promise<unknown>((resolve) => {
+        channel.port2.on('message', resolve);
+        channel.port1.postMessage(obj);
+      });
+      const r = received as any;
+      expect(r.date instanceof Date).toBe(true);
+      expect(r.items.length).toBe(3);
+      expect(r.items[0]).toBe(1);
+      expect(r.items[1]).toBe('two');
+      expect(r.items[2].three).toBe(3);
+      expect(r.nested.deep).toBe(true);
+      channel.port1.close();
+    });
+
+    await it('should clone nested Map with Set values', async () => {
+      const channel = new MessageChannel();
+      const map = new Map<string, Set<number>>([
+        ['evens', new Set([2, 4, 6])],
+        ['odds', new Set([1, 3, 5])],
+      ]);
+      const received = await new Promise<unknown>((resolve) => {
+        channel.port2.on('message', resolve);
+        channel.port1.postMessage(map);
+      });
+      const r = received as Map<string, Set<number>>;
+      expect(r instanceof Map).toBe(true);
+      expect(r.get('evens') instanceof Set).toBe(true);
+      expect(r.get('evens')!.has(2)).toBe(true);
+      expect(r.get('evens')!.has(4)).toBe(true);
+      expect(r.get('evens')!.size).toBe(3);
+      expect(r.get('odds')!.has(1)).toBe(true);
+      expect(r.get('odds')!.size).toBe(3);
+      channel.port1.close();
+    });
+
+    await it('should clone Map with numeric keys', async () => {
+      const channel = new MessageChannel();
+      const map = new Map<number, string>([[1, 'one'], [2, 'two']]);
+      const received = await new Promise<unknown>((resolve) => {
+        channel.port2.on('message', resolve);
+        channel.port1.postMessage(map);
+      });
+      const r = received as Map<number, string>;
+      expect(r instanceof Map).toBe(true);
+      expect(r.get(1)).toBe('one');
+      expect(r.get(2)).toBe('two');
+      channel.port1.close();
+    });
+
+    await it('should clone Set containing objects', async () => {
+      const channel = new MessageChannel();
+      const set = new Set([{ a: 1 }, { b: 2 }]);
+      const received = await new Promise<unknown>((resolve) => {
+        channel.port2.on('message', resolve);
+        channel.port1.postMessage(set);
+      });
+      const r = received as Set<{ a?: number; b?: number }>;
+      expect(r instanceof Set).toBe(true);
+      expect(r.size).toBe(2);
+      const items = Array.from(r);
+      // Check that the objects were cloned
+      expect(items.some((item: any) => item.a === 1)).toBe(true);
+      expect(items.some((item: any) => item.b === 2)).toBe(true);
+      channel.port1.close();
+    });
+
+    await it('should clone object with array of Maps', async () => {
+      const channel = new MessageChannel();
+      const obj = {
+        maps: [
+          new Map([['x', 1]]),
+          new Map([['y', 2]]),
+        ],
+      };
+      const received = await new Promise<unknown>((resolve) => {
+        channel.port2.on('message', resolve);
+        channel.port1.postMessage(obj);
+      });
+      const r = received as { maps: Map<string, number>[] };
+      expect(r.maps.length).toBe(2);
+      expect(r.maps[0] instanceof Map).toBe(true);
+      expect(r.maps[0].get('x')).toBe(1);
+      expect(r.maps[1].get('y')).toBe(2);
+      channel.port1.close();
+    });
+
+    await it('should clone long string', async () => {
+      const channel = new MessageChannel();
+      const longStr = 'a'.repeat(10000);
+      const received = await new Promise<unknown>((resolve) => {
+        channel.port2.on('message', resolve);
+        channel.port1.postMessage(longStr);
+      });
+      expect(received).toBe(longStr);
+      expect((received as string).length).toBe(10000);
+      channel.port1.close();
+    });
+  });
+
+  // --- Worker class ---
+
+  await describe('Worker class', async () => {
+    await it('Worker constructor should be a function', async () => {
+      expect(typeof Worker).toBe('function');
+    });
+
+    await it('Worker should have prototype with expected methods', async () => {
+      expect(typeof Worker.prototype.postMessage).toBe('function');
+      expect(typeof Worker.prototype.terminate).toBe('function');
+      expect(typeof Worker.prototype.ref).toBe('function');
+      expect(typeof Worker.prototype.unref).toBe('function');
+    });
+
+    await it('Worker should extend EventEmitter', async () => {
+      const proto = Worker.prototype as any;
+      expect(typeof proto.on).toBe('function');
+      expect(typeof proto.once).toBe('function');
+      expect(typeof proto.emit).toBe('function');
+      expect(typeof proto.removeListener).toBe('function');
+      expect(typeof proto.removeAllListeners).toBe('function');
+    });
+
+    await it('ref should be chainable', async () => {
+      // We can't instantiate without spawning, but we can verify prototype
+      expect(typeof Worker.prototype.ref).toBe('function');
+    });
+
+    await it('unref should be chainable', async () => {
+      expect(typeof Worker.prototype.unref).toBe('function');
+    });
+  });
+
+  // --- Worker file resolution ---
+
+  await describe('Worker file resolution', async () => {
+    await it('Worker should accept URL object', async () => {
+      // Just verify the constructor doesn't throw for URL type
+      // (the actual spawn will fail on Node.js since gjs is not available)
+      expect(typeof Worker).toBe('function');
+    });
+
+    await it('Worker should accept string path', async () => {
+      expect(typeof Worker).toBe('function');
+    });
+  });
+
+  // --- Worker error handling ---
+
+  await describe('Worker error handling', async () => {
+    await it('should emit error for non-existent file on GJS', async () => {
+      const nonExistent = '/tmp/gjsify-nonexistent-worker-' + Date.now() + '.mjs';
+
+      const worker = new Worker(nonExistent) as any;
+      const result = await new Promise<{ type: string; message?: string; code?: number }>((resolve) => {
+        worker.on('error', (err: Error) => {
+          resolve({ type: 'error', message: err.message });
+        });
+        worker.on('exit', (code: number) => {
+          resolve({ type: 'exit', code });
+        });
+      });
+
+      expect(result.type === 'error' || (result.type === 'exit' && result.code !== 0)).toBe(true);
+    });
+
+    await it('should emit exit event with code after terminate', async () => {
+      const worker = new Worker(
+        'parentPort.postMessage("started"); await new Promise(r => setTimeout(r, 5000));',
+        { eval: true }
+      ) as any;
+
+      const started = await new Promise<boolean>((resolve) => {
+        worker.on('message', () => resolve(true));
+        worker.on('error', () => resolve(false));
+        worker.on('exit', () => resolve(false));
+      });
+
+      if (started) {
+        const exitCode = await worker.terminate();
+        expect(typeof exitCode).toBe('number');
+      }
+    });
+  });
+
+  // Worker eval mode tests are covered by the existing 217 worker_threads tests
+  // which handle GJS subprocess timing constraints. The eval+IPC round-trip
+  // requires subprocess spawning which is timing-sensitive in the test runner.
+
+  // --- Worker threadId ---
+
+  await describe('Worker threadId', async () => {
+    await it('each Worker should get a unique threadId', async () => {
+      const w1 = new Worker('parentPort.postMessage(threadId);', { eval: true });
+      const w2 = new Worker('parentPort.postMessage(threadId);', { eval: true });
+
+      // threadId is assigned at construction time
+      expect(typeof w1.threadId).toBe('number');
+      expect(typeof w2.threadId).toBe('number');
+      expect(w1.threadId).not.toBe(w2.threadId);
+
+      await w1.terminate();
+      await w2.terminate();
+    });
+
+    await it('threadId should be a positive integer', async () => {
+      const w = new Worker('void 0', { eval: true });
+      expect(w.threadId).toBeGreaterThan(0);
+      expect(Number.isInteger(w.threadId)).toBe(true);
+      await w.terminate();
+    });
+  });
+};