promise-worker-bi 5.0.2 → 6.0.0-beta.1

package/README.md

@@ -1,4 +1,10 @@
-# promise-worker-bi [![Build Status](https://travis-ci.org/dumbmatter/promise-worker-bi.svg?branch=master)](https://travis-ci.org/dumbmatter/promise-worker-bi)
+# promise-worker-bi
+
+[![Build Status](https://github.com/dumbmatter/promise-worker-bi/actions/workflows/nodejs.yml/badge.svg)](https://github.com/dumbmatter/promise-worker-bi/actions/workflows/nodejs.yml)
+[![GitHub Repo stars](https://img.shields.io/github/stars/dumbmatter/promise-worker-bi)](https://github.com/dumbmatter/promise-worker-bi)
+[![GitHub](https://img.shields.io/github/license/dumbmatter/promise-worker-bi)](https://github.com/dumbmatter/promise-worker-bi)
+[![npm](https://img.shields.io/npm/v/promise-worker-bi)](https://www.npmjs.com/package/promise-worker-bi)
+[![npm](https://img.shields.io/npm/dm/promise-worker-bi)](https://www.npmjs.com/package/promise-worker-bi)
 
 A small (~2 kB min+gz) and performant library for communicating with web workers and shared workers, using promises. Post a message from the browser to the worker, get a promise that resolves to the response. Post a message from the worker to the browser, get a promise that resolves to the response. And with shared workers, you can either broadcast to all browser tabs or send a message to a specific tab.
 
@@ -21,14 +27,14 @@ const promiseWorker = new PWBHost(worker);
 
 // Only needed if you send messages from the worker to the host
 promiseWorker.register((message) => {
-  return "pong2";
+	return "pong2";
 });
 
 try {
-  const response = await promiseWorker.postMessage("ping");
-  // handle response 'pong'
+	const response = await promiseWorker.postMessage("ping");
+	// handle response 'pong'
 } catch (error) {
-  // handle error
+	// handle error
 }
 ```
 
@@ -42,14 +48,14 @@ const promiseWorker = new PWBWorker();
 
 // Only needed if you send messages from the host to the worker
 promiseWorker.register((message) => {
-  return "pong";
+	return "pong";
 });
 
 try {
-  const response = await promiseWorker.postMessage("ping2");
-  // handle response 'pong2'
+	const response = await promiseWorker.postMessage("ping2");
+	// handle response 'pong2'
 } catch (error) {
-  // handle error
+	// handle error
 }
 ```
 
@@ -61,15 +67,15 @@ The message you send can be any object, array, string, number, etc. - anything t
 
 ```js
 await promiseWorker.postMessage({
-  hello: "world",
-  answer: 42,
-  "this is fun": true,
+	hello: "world",
+	answer: 42,
+	"this is fun": true,
 });
 ```
 
 ```js
 promiseWorker.register((message) => {
-  console.log(message); // { hello: 'world', answer: 42, 'this is fun': true }
+	console.log(message); // { hello: 'world', answer: 42, 'this is fun': true }
 });
 ```
 
@@ -79,7 +85,7 @@ The registered handler can return either a Promise or a normal value:
 
 ```js
 promiseWorker.register(async () => {
-  "much async, very promise";
+	"much async, very promise";
 });
 ```
 
@@ -94,15 +100,15 @@ Any thrown errors or asynchronous rejections during a response will be propagate
 
 ```js
 promiseWorker.register((message) => {
-  throw new Error("naughty!");
+	throw new Error("naughty!");
 });
 ```
 
 ```js
 try {
-  await promiseWorker.postMessage("whoops");
+	await promiseWorker.postMessage("whoops");
 } catch (error) {
-  console.log(error.message); // 'naughty!'
+	console.log(error.message); // 'naughty!'
 }
 ```
 
@@ -113,8 +119,8 @@ For a Web Worker, we could just use [the normal `error` event](https://developer
 Therefore, promise-worker-bi includes a unified API that works in Web Workers and Shared Workers. Include some code like this in your host:
 
 ```js
-promiseWorker.registerError((error) => {
-  console.log("Error inside worker!", err);
+promiseWorker.addEventListener("error", (errorError) => {
+	console.log("Error inside worker!", errorError.error);
 });
 ```
 
@@ -130,21 +136,21 @@ If you need to send messages of multiple types to the worker, just add some type
 
 ```js
 const response1 = await promiseWorker.postMessage({
-  type: "en",
+	type: "en",
 });
 
 const response2 = await promiseWorker.postMessage({
-  type: "en",
+	type: "fr",
 });
 ```
 
 ```js
 promiseWorker.register((message) => {
-  if (message.type === "en") {
-    return "Hello!";
-  } else if (message.type === "fr") {
-    return "Bonjour!";
-  }
+	if (message.type === "en") {
+		return "Hello!";
+	} else if (message.type === "fr") {
+		return "Bonjour!";
+	}
 });
 ```
 
@@ -162,14 +168,14 @@ const worker = new SharedWorker("worker.js");
 const promiseWorker = new PWBHost(worker);
 
 promiseWorker.register((message) => {
-  console.log(message);
+	console.log(message);
 });
 
 // setTimeout is just to give you enough time to open main.js and main2.js in
 // two separate tabs.
 setTimeout(async () => {
-  const response = await promiseWorker.postMessage("broadcast");
-  console.log("Echoed response:", response);
+	const response = await promiseWorker.postMessage("broadcast");
+	console.log("Echoed response:", response);
 }, 1000);
 ```
 
@@ -199,13 +205,13 @@ import { PWBWorker } from "promise-worker-bi";
 const promiseWorker = new PWBWorker();
 
 promiseWorker.register((message, hostID) => {
-  if (message === "broadcast") {
-    promiseWorker.postMessage("to all tabs");
-  } else {
-    promiseWorker.postMessage(`hello host ${hostID}`, hostID);
-  }
+	if (message === "broadcast") {
+		promiseWorker.postMessage("to all tabs");
+	} else {
+		promiseWorker.postMessage(`hello host ${hostID}`, hostID);
+	}
 
-  return message;
+	return message;
 });
 ```
 
@@ -244,12 +250,12 @@ If you want to respond to a message by sending a transferable object back, such
 
 ```js
 promiseWorker.register(async (message) => {
-  const processedMessage = await processMessage(message);
+	const processedMessage = await processMessage(message);
 
-  return {
-    message: processedMessage,
-    _PWB_TRANSFER: [processedMessage.someTransferableProprty],
-  };
+	return {
+		message: processedMessage,
+		_PWB_TRANSFER: [processedMessage.someTransferableProprty],
+	};
 });
 ```
 
@@ -279,13 +285,17 @@ Create a new instance of `PWBHost`, using the given worker.
 
 - `worker` - the `Worker`, `SharedWorker` or [PseudoWorker](https://github.com/nolanlawson/pseudo-worker) to use.
 
-#### `promiseWorker.registerError((error: Error) => void)`
+#### `promiseWorker.addEventListener("error", (event: ErrorEvent) => void)`
+
+When an error in your web/shared worker process occurs that is _not_ directly in response to a `promiseWorker.postMessage` call, you can see it by listening to the "error" event here.
+
+`promiseWorker` is EventTarget so you can use `addEventListener`, `removeEventListener`, and all their normal options.
 
-This should only be called in the browser, not in a worker.
+#### `promiseWorker.addEventListener("close", (event: Event) => void)`
 
-When an error in your web/shared worker process occurs that is _not_ directly in response to a `promiseWorker.postMessage` call, it will be sent to the callback you provide here to `promiseWorker.registerError`.
+There is no built-in API to listen for when a web/shared worker closes, which can happen in various situations such as the OS killing it to free up memory. promise-worker-bi includes a "close" event you can use for this purpose.
 
-Although [normally stack traces are not sent from the worker to the main thread](https://github.com/mknichel/javascript-errors/blob/master/README.md#dedicated-workers), promise-worker-bi magically works around this problem so you will see a stack trace in `error`.
+`promiseWorker` is EventTarget so you can use `addEventListener`, `removeEventListener`, and all their normal options.
 
 ### Worker bundle
 
@@ -295,17 +305,17 @@ Create a new instance of `PWBWorker`.
 
 ### Both bundles
 
-#### `promiseWorker.register((message: any, hostID?: number) => any)`
+#### `promiseWorker.register((message: unknown, hostID?: number) => unknown)`
 
 Register a message handler wherever you will be receiving messages: in the worker, in the browser, or both. Your handler consumes a message and returns a promise or value.
 
 The `hostID` parameter is only defined inside a shared worker, in which case it is a unique number identifying the host that the message came from.
 
-The return value of the callback function (shown above as `any`) must resolve to something [structured cloneable](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm).
+The return value of the callback function (shown above as `unknown`) must resolve to something [structured cloneable](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm).
 
-If you want to [transfer an object](https://developer.mozilla.org/en-US/docs/Glossary/Transferable_objects) in the return value of the callback, then the return type should be `{ message: any, _PWB_TRANSFER: Transferable[] }` rather than just `any`.
+If you want to [transfer an object](https://developer.mozilla.org/en-US/docs/Glossary/Transferable_objects) in the return value of the callback, then the return type should be `{ message: unknown, _PWB_TRANSFER: Transferable[] }` rather than just `unknown`.
 
-#### `promiseWorker.postMessage(message: any, hostID?: number, transfer?: Transferable[]): Promise<any>`
+#### `promiseWorker.postMessage(message: unknown, hostID?: number, transfer?: Transferable[]): Promise<unknown>`
 
 Send a message to the browser or worker and return a Promise. `message` must resolve to something [structured cloneable](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm).
 

package/dist/index.d.ts

@@ -1,38 +1,65 @@
-type ErrorCallback = (a: Error) => void;
-type QueryCallback = (a: any[], b: number | undefined) => any;
-declare abstract class PWBBase {
-    _callbacks: Map<number, (a: Error | null, b: any) => void>;
-    _queryCallback: QueryCallback;
-    _workerType: "SharedWorker" | "Worker" | undefined;
-    constructor();
-    register(cb: QueryCallback): void;
-    abstract _postMessage(obj: any[], hostID?: number | undefined, transfer?: Transferable[] | undefined): void;
-    _postResponse(messageID: number, error: Error | null, result?: any, hostID?: number | undefined): void;
-    _handleQuery(messageID: number, query: any, hostID: number | undefined): void;
-    _onMessageCommon(e: MessageEvent): {
-        message: any;
-        type: number;
-    } | void;
+//#region src/message.d.ts
+declare const MSGTYPE_QUERY = 0;
+declare const MSGTYPE_RESPONSE = 1;
+declare const MSGTYPE_HOST_ID = 2;
+declare const MSGTYPE_HOST_LOCK = 3;
+declare const MSGTYPE_WORKER_LOCK = 4;
+declare const MSGTYPE_WORKER_ERROR = 5;
+type QueryMessage = [type: typeof MSGTYPE_QUERY, messageId: number, query: unknown] | [type: typeof MSGTYPE_QUERY, messageId: number, query: unknown, hostId: number | undefined];
+type ResponseMessage = [type: typeof MSGTYPE_RESPONSE, messageId: number, error: Error] | [type: typeof MSGTYPE_RESPONSE, messageId: number, error: null, result: unknown];
+type HostIdMessage = [type: typeof MSGTYPE_HOST_ID, hostId: number] | [type: typeof MSGTYPE_HOST_ID, hostId: number, workerLockId: string];
+type HostLockMessage = [type: typeof MSGTYPE_HOST_LOCK, hostID: number, hostLockId: string];
+type WorkerLockMessage = [type: typeof MSGTYPE_WORKER_LOCK, workerLockId: string];
+type WorkerErrorMessage = [type: typeof MSGTYPE_WORKER_ERROR, error: Error];
+type Message = QueryMessage | ResponseMessage | HostIdMessage | HostLockMessage | WorkerLockMessage | WorkerErrorMessage;
+//#endregion
+//#region src/PWBBase.d.ts
+type QueryCallback = (a: unknown, b: number | undefined) => unknown;
+type EventMap = Record<string, Event>;
+declare abstract class PWBBase<Events extends EventMap> extends EventTarget {
+  protected _callbacks: Map<number, (a: Error | null, b: unknown) => void>;
+  protected _queryCallback: QueryCallback;
+  constructor();
+  addEventListener<K extends keyof Events>(type: K, listener: ((event: Events[K]) => void) | {
+    handleEvent(object: Events[K]): void;
+  } | null, options?: AddEventListenerOptions | boolean): void;
+  dispatchEvent<K extends keyof Events>(event: Events[K]): boolean;
+  removeEventListener<K extends keyof Events>(type: K, listener: ((event: Events[K]) => void) | {
+    handleEvent(object: Events[K]): void;
+  } | null, options?: EventListenerOptions | boolean): void;
+  register(cb: QueryCallback): void;
+  protected abstract _postMessage(obj: Message, hostID?: number | undefined, transfer?: Transferable[] | undefined): void;
+  private _postResponse;
+  private _handleQuery;
+  protected _onMessageCommon(e: MessageEvent): [type: 2, hostId: number] | [type: 2, hostId: number, workerLockId: string] | HostLockMessage | WorkerLockMessage | WorkerErrorMessage | undefined;
 }
-declare class PWBHost extends PWBBase {
-    _errorCallback: ErrorCallback | undefined;
-    _hostID: number | undefined;
-    _hostIDQueue: (() => void)[] | undefined;
-    _worker: SharedWorker | Worker;
-    constructor(worker: SharedWorker | Worker);
-    registerError(cb: ErrorCallback): void;
-    _postMessage(obj: any[], _hostID?: unknown, transfer?: Transferable[] | undefined): void;
-    postMessage(userMessage: any, _hostID?: undefined, transfer?: Transferable[] | undefined): Promise<any>;
-    _onMessage(e: MessageEvent): void;
+//#endregion
+//#region src/PWBHost.d.ts
+type HostEvents = {
+  close: Event;
+  error: ErrorEvent;
+};
+export declare class PWBHost extends PWBBase<HostEvents> {
+  private _hostID;
+  private _hostIDQueue;
+  private _worker;
+  constructor(worker: SharedWorker | Worker);
+  protected _postMessage(obj: QueryMessage | ResponseMessage | HostLockMessage, _hostID?: unknown, transfer?: Transferable[] | undefined): void;
+  postMessage(userMessage: unknown, _hostID?: undefined, transfer?: Transferable[] | undefined): Promise<any>;
+  private handleWorkerLock;
+  private _onMessage;
 }
-declare class PWBWorker extends PWBBase {
-    _hosts: Map<number, {
-        port: MessagePort;
-    }>;
-    _maxHostID: number;
-    constructor();
-    _postMessage(obj: any[], targetHostID?: number | undefined, transfer?: Transferable[] | undefined): void;
-    postMessage(userMessage: any, targetHostID?: number | undefined, transfer?: Transferable[] | undefined): Promise<any>;
-    _onMessage(e: MessageEvent): void;
+//#endregion
+//#region src/PWBWorker.d.ts
+type WorkerEvents = Record<string, Event>;
+export declare class PWBWorker extends PWBBase<WorkerEvents> {
+  private _hosts;
+  private _maxHostID;
+  private _sharedWorker;
+  private _workerLockAcquired;
+  constructor();
+  protected _postMessage(message: QueryMessage | ResponseMessage | HostIdMessage | WorkerLockMessage | WorkerErrorMessage, targetHostID?: number | undefined, transfer?: Transferable[] | undefined): void;
+  postMessage(userMessage: unknown, targetHostID?: number | undefined, transfer?: Transferable[] | undefined): Promise<unknown>;
+  private _onMessage;
 }
-export { PWBHost, PWBWorker };
+//#endregion

package/dist/index.js

@@ -1,377 +1,299 @@
-let messageIDs = 0;
-const MSGTYPE_QUERY = 0;
-const MSGTYPE_RESPONSE = 1;
-const MSGTYPE_HOST_ID = 2;
-const MSGTYPE_HOST_CLOSE = 3;
-const MSGTYPE_WORKER_ERROR = 4;
-const MSGTYPES = [MSGTYPE_QUERY, MSGTYPE_RESPONSE, MSGTYPE_HOST_ID, MSGTYPE_HOST_CLOSE, MSGTYPE_WORKER_ERROR];
-
-// Inlined from https://github.com/then/is-promise
-const isPromise = obj => !!obj && (typeof obj === "object" || typeof obj === "function") && typeof obj.then === "function";
-const toFakeError = error => {
-  const fakeError = {
-    name: error.name,
-    message: error.message
-  };
-  if (typeof error.stack === "string") {
-    fakeError.stack = error.stack;
-  }
-
-  // These are non-standard properties, I think only in some versions of Firefox
-  // @ts-expect-error
-  if (typeof error.fileName === "string") {
-    // @ts-expect-error
-    fakeError.fileName = error.fileName;
-  }
-  // @ts-expect-error
-  if (typeof error.columnNumber === "number") {
-    // @ts-expect-error
-    fakeError.columnNumber = error.columnNumber;
-  }
-  // @ts-expect-error
-  if (typeof error.lineNumber === "number") {
-    // @ts-expect-error
-    fakeError.lineNumber = error.lineNumber;
-  }
-  return fakeError;
+const isError = (error) => {
+	if (Error.isError) return Error.isError(error);
+	return true;
 };
-
-// Object rather than FakeError for convenience
-const fromFakeError = fakeError => {
-  const error = new Error();
-  return Object.assign(error, fakeError);
+const parseMessage = (message) => {
+	if (!Array.isArray(message) || message.length < 2 || message.length > 4) return;
+	const type = message[0];
+	if (type === 0) {
+		if (typeof message[1] !== "number") throw new Error("Invalid messageID");
+		if (message[3] !== void 0 && typeof message[3] !== "number") throw new Error("Invalid hostID");
+		return message;
+	}
+	if (type === 1) {
+		if (typeof message[1] !== "number") throw new Error("Invalid messageID");
+		if (message[2] !== null && !isError(message[2])) throw new Error("Invalid error");
+		return message;
+	}
+	if (type === 2) {
+		if (typeof message[1] !== "number") throw new Error("Invalid hostID");
+		if (message[2] !== void 0 && typeof message[2] !== "string") throw new Error("Invalid workerLockId");
+		return message;
+	}
+	if (type === 3) {
+		if (typeof message[1] !== "number") throw new Error("Invalid hostID");
+		if (typeof message[2] !== "string") throw new Error("Invalid hostLockId");
+		return message;
+	}
+	if (type === 4) {
+		if (typeof message[1] !== "string") throw new Error("Invalid workerLockId");
+		return message;
+	}
+	if (type === 5) {
+		if (!isError(message[1])) throw new Error("Invalid error");
+		return message;
+	}
+	throw new Error("Invalid message type");
 };
-const logError = err => {
-  // Logging in the console makes debugging in the worker easier
-  console.error("Error in Worker:");
-  console.error(err); // Safari needs it on new line
+//#endregion
+//#region src/PWBBase.ts
+const isPromise = (obj) => !!obj && (typeof obj === "object" || typeof obj === "function") && typeof obj.then === "function";
+const logError = (err) => {
+	console.error("Error in worker:");
+	console.error(err);
 };
-class PWBBase {
-  constructor() {
-    // console.log('constructor', worker);
-    this._callbacks = new Map();
-    this._queryCallback = () => {};
-
-    // @ts-expect-error
-    this._onMessage = this._onMessage.bind(this);
-  }
-  register(cb) {
-    // console.log('register', cb);
-    this._queryCallback = cb;
-  }
-
-  // From worker, 2nd param could be hostID if sending to specific host. From UI, 2nd param could be an array of transferable objects
-
-  _postResponse(messageID, error, result, hostID) {
-    // console.log('_postResponse', messageID, error, result);
-    if (error) {
-      logError(error);
-      this._postMessage([MSGTYPE_RESPONSE, messageID, toFakeError(error)], hostID);
-    } else {
-      // Hackily identify when message contains transferable objects
-      if (typeof result === "object" && result !== null && Object.hasOwn(result, "message") && Object.hasOwn(result, "_PWB_TRANSFER")) {
-        this._postMessage([MSGTYPE_RESPONSE, messageID, null, result.message], hostID, result._PWB_TRANSFER);
-      } else {
-        this._postMessage([MSGTYPE_RESPONSE, messageID, null, result], hostID);
-      }
-    }
-  }
-  _handleQuery(messageID, query, hostID) {
-    // console.log('_handleQuery', messageID, query);
-    try {
-      const result = this._queryCallback(query, hostID);
-      if (!isPromise(result)) {
-        this._postResponse(messageID, null, result, hostID);
-      } else {
-        result.then(finalResult => {
-          this._postResponse(messageID, null, finalResult, hostID);
-        }, finalError => {
-          this._postResponse(messageID, finalError, hostID);
-        });
-      }
-    } catch (err) {
-      this._postResponse(messageID, err);
-    }
-  }
-
-  // Either return messageID and type if further processing is needed, or undefined otherwise
-  _onMessageCommon(e) {
-    // console.log('_onMessage', e.data);
-    const message = e.data;
-    if (!Array.isArray(message) || message.length < 3 || message.length > 4) {
-      return; // Ignore - this message is not for us
-    }
-    if (typeof message[0] !== "number" || MSGTYPES.indexOf(message[0]) < 0) {
-      throw new Error("Invalid messageID");
-    }
-    const type = message[0];
-    if (typeof message[1] !== "number") {
-      throw new Error("Invalid messageID");
-    }
-    const messageID = message[1];
-    if (type === MSGTYPE_QUERY) {
-      const query = message[2];
-      if (typeof message[3] !== "number" && message[3] !== undefined) {
-        throw new Error("Invalid hostID");
-      }
-      const hostID = message[3];
-      this._handleQuery(messageID, query, hostID);
-      return;
-    }
-    if (type === MSGTYPE_RESPONSE) {
-      if (message[2] !== null && typeof message[2] !== "object") {
-        throw new Error("Invalid error");
-      }
-      const error = message[2] === null ? null : fromFakeError(message[2]);
-      const result = message[3];
-      const callback = this._callbacks.get(messageID);
-      if (callback === undefined) {
-        // Ignore - user might have created multiple PromiseWorkers.
-        // This message is not for us.
-        return;
-      }
-      this._callbacks.delete(messageID);
-      callback(error, result);
-      return;
-    }
-    return {
-      message,
-      type
-    };
-  }
-}
-class PWBHost extends PWBBase {
-  // Only defined on host
-
-  constructor(worker) {
-    super();
-
-    // The following if statement used to check `worker instanceof Worker` but I have recieved
-    // reports that in some weird cases, Safari will inappropriately return false for that, even
-    // in obvious cases like:
-    //
-    //     blob = new Blob(["self.onmessage = function() {};"], { type: "text/javascript" });
-    //     worker = new Worker(window.URL.createObjectURL(blob));
-    //     console.log(worker instanceof Worker);
-    //
-    // So instead, let's do this test for worker.port which only exists on shared workers.
-    // @ts-expect-error
-    if (worker.port === undefined) {
-      this._workerType = "Worker";
-
-      // @ts-expect-error
-      worker.addEventListener("message", this._onMessage);
-    } else {
-      this._workerType = "SharedWorker";
-
-      // @ts-expect-error - it doesn't know if _worker is Worker or SharedWorker, but I do
-      worker.port.addEventListener("message", this._onMessage);
-      // @ts-expect-error - it doesn't know if _worker is Worker or SharedWorker, but I do
-      worker.port.start();
-
-      // Handle tab close. This isn't perfect, but there is no perfect method
-      // http://stackoverflow.com/q/13662089/786644 and this should work like
-      // 99% of the time. It is a memory leak if it fails, but for most use
-      // cases, it shouldn't be noticeable.
-      window.addEventListener("beforeunload", () => {
-        // Prevent firing if we don't know hostID yet
-        if (this._hostID !== undefined) {
-          this._postMessage([MSGTYPE_HOST_CLOSE, -1, this._hostID]);
-        }
-      });
-    }
-    this._worker = worker;
-    this._hostIDQueue = [];
-  }
-  registerError(cb) {
-    // console.log('registerError', cb);
-    this._errorCallback = cb;
-
-    // Some browsers (Firefox) call onerror on every host, while others
-    // (Chrome) do nothing. Let's disable that everywhere, for consistency.
-    this._worker.addEventListener("error", e => {
-      e.preventDefault();
-      e.stopPropagation();
-    });
-  }
-  _postMessage(obj, _hostID, transfer) {
-    // console.log('_postMessage', obj, _hostID, transfer);
-    if (this._workerType === "Worker") {
-      // @ts-expect-error - it doesn't know if _worker is Worker or SharedWorker, but I do
-      this._worker.postMessage(obj, transfer);
-    } else if (this._workerType === "SharedWorker") {
-      // @ts-expect-error - it doesn't know if _worker is Worker or SharedWorker, but I do
-      this._worker.port.postMessage(obj, transfer);
-    } else {
-      throw new Error("WTF");
-    }
-  }
-  postMessage(userMessage, _hostID, transfer) {
-    // console.log('postMessage', userMessage, _hostID, transfer);
-    const actuallyPostMessage = (resolve, reject) => {
-      const messageID = messageIDs;
-      messageIDs += 1;
-      const messageToSend = [MSGTYPE_QUERY, messageID, userMessage, this._hostID];
-      this._callbacks.set(messageID, (error, result) => {
-        if (error) {
-          reject(error);
-        } else {
-          resolve(result);
-        }
-      });
-      this._postMessage(messageToSend, undefined, transfer);
-    };
-    return new Promise((resolve, reject) => {
-      // Don't send a message until hostID is known, otherwise it's a race
-      // condition and sometimes hostID will be undefined.
-      if (this._hostIDQueue !== undefined) {
-        this._hostIDQueue.push(() => {
-          actuallyPostMessage(resolve, reject);
-        });
-      } else {
-        actuallyPostMessage(resolve, reject);
-      }
-    });
-  }
-  _onMessage(e) {
-    const common = this._onMessageCommon(e);
-    if (!common) {
-      return;
-    }
-    const {
-      message,
-      type
-    } = common;
-    if (type === MSGTYPE_HOST_ID) {
-      if (message[2] !== undefined && typeof message[2] !== "number") {
-        throw new Error("Invalid hostID");
-      }
-      const hostID = message[2];
-      this._hostID = hostID;
-      if (this._hostIDQueue !== undefined) {
-        this._hostIDQueue.forEach(func => {
-          // Not entirely sure why setTimeout is needed, might be just for unit tests
-          setTimeout(() => {
-            func();
-          }, 0);
-        });
-        this._hostIDQueue = undefined; // Never needed again after initial setup
-      }
-    } else if (type === MSGTYPE_WORKER_ERROR) {
-      if (message[2] !== undefined && message[2] !== null && typeof message[2] === "object") {
-        const error = fromFakeError(message[2]);
-        if (this._errorCallback !== undefined) {
-          this._errorCallback(error);
-        }
-      }
-    }
-  }
-}
-class PWBWorker extends PWBBase {
-  constructor() {
-    super();
-
-    // Only actually used for SharedWorker
-    this._hosts = new Map();
-    this._maxHostID = -1;
-    if (
-    // @ts-expect-error
-    typeof SharedWorkerGlobalScope !== "undefined" &&
-    // @ts-expect-error
-    self instanceof SharedWorkerGlobalScope) {
-      this._workerType = "SharedWorker";
-      self.addEventListener("connect", e => {
-        // @ts-expect-error
-        const port = e.ports[0];
-        port.addEventListener("message", e2 => this._onMessage(e2));
-        port.start();
-        this._maxHostID += 1;
-        const hostID = this._maxHostID;
-        this._hosts.set(hostID, {
-          port
-        });
-
-        // Send back hostID to this host, otherwise it has no way to know it
-        this._postMessage([MSGTYPE_HOST_ID, -1, hostID], hostID);
-      });
-      self.addEventListener("error", e => {
-        logError(e.error);
-
-        // Just send to first host, so as to not duplicate error tracking
-        const hostID = this._hosts.keys().next().value;
-        if (hostID !== undefined) {
-          this._postMessage([MSGTYPE_WORKER_ERROR, -1, toFakeError(e.error)], hostID);
-        }
-      });
-    } else {
-      this._workerType = "Worker";
-      self.addEventListener("message", this._onMessage);
-
-      // Since this is not a Shared Worker, hostID is always 0 so it's not strictly required to
-      // send this back, but it makes the API a bit more consistent if there is the same
-      // initialization handshake in both cases.
-      this._postMessage([MSGTYPE_HOST_ID, -1, 0], 0);
-      self.addEventListener("error", e => {
-        logError(e.error);
-        this._postMessage([MSGTYPE_WORKER_ERROR, -1, toFakeError(e.error)]);
-      });
-    }
-  }
-  _postMessage(obj, targetHostID, transfer) {
-    // console.log('_postMessage', obj, targetHostID);
-    if (this._workerType === "SharedWorker") {
-      // If targetHostID has been deleted, this will do nothing, which is fine I think
-      this._hosts.forEach(({
-        port
-      }, hostID) => {
-        if (targetHostID === undefined || targetHostID === hostID) {
-          // @ts-expect-error TypeScript thinks transfer can't be undefined
-          port.postMessage(obj, transfer);
-        }
-      });
-    } else if (this._workerType === "Worker") {
-      // @ts-expect-error TypeScript thinks self is window, which has a different postMessage call signature. In a worker, this is correct.
-      self.postMessage(obj, transfer);
-    } else {
-      throw new Error("WTF");
-    }
-  }
-  postMessage(userMessage, targetHostID, transfer) {
-    // console.log('postMessage', userMessage, targetHostID);
-    const actuallyPostMessage = (resolve, reject) => {
-      const messageID = messageIDs;
-      messageIDs += 1;
-      const messageToSend = [MSGTYPE_QUERY, messageID, userMessage];
-      this._callbacks.set(messageID, (error, result) => {
-        if (error) {
-          reject(error);
-        } else {
-          resolve(result);
-        }
-      });
-      this._postMessage(messageToSend, targetHostID, transfer);
-    };
-    return new Promise((resolve, reject) => {
-      actuallyPostMessage(resolve, reject);
-    });
-  }
-  _onMessage(e) {
-    const common = this._onMessageCommon(e);
-    if (!common) {
-      return;
-    }
-    const {
-      message,
-      type
-    } = common;
-    if (type === MSGTYPE_HOST_CLOSE) {
-      if (typeof message[2] !== "number") {
-        throw new Error("Invalid hostID");
-      }
-      const hostID = message[2];
-      this._hosts.delete(hostID);
-    }
-  }
-}
-
+const isSharedWorker = (worker) => {
+	return worker.port !== void 0;
+};
+var PWBBase = class extends EventTarget {
+	_callbacks;
+	_queryCallback;
+	constructor() {
+		super();
+		this._callbacks = /* @__PURE__ */ new Map();
+		this._queryCallback = () => {};
+		this._onMessage = this._onMessage.bind(this);
+	}
+	addEventListener(type, listener, options) {
+		super.addEventListener(type, listener, options);
+	}
+	dispatchEvent(event) {
+		return super.dispatchEvent(event);
+	}
+	removeEventListener(type, listener, options) {
+		super.removeEventListener(type, listener, options);
+	}
+	register(cb) {
+		this._queryCallback = cb;
+	}
+	_postResponse(messageID, error, result, hostID) {
+		if (error) {
+			logError(error);
+			this._postMessage([
+				1,
+				messageID,
+				error
+			], hostID);
+		} else if (typeof result === "object" && result !== null && Object.hasOwn(result, "message") && Object.hasOwn(result, "_PWB_TRANSFER")) this._postMessage([
+			1,
+			messageID,
+			null,
+			result.message
+		], hostID, result._PWB_TRANSFER);
+		else this._postMessage([
+			1,
+			messageID,
+			null,
+			result
+		], hostID);
+	}
+	_handleQuery(message) {
+		const messageID = message[1];
+		const query = message[2];
+		const hostID = message[3];
+		try {
+			const result = this._queryCallback(query, hostID);
+			if (!isPromise(result)) this._postResponse(messageID, null, result, hostID);
+			else result.then((finalResult) => {
+				this._postResponse(messageID, null, finalResult, hostID);
+			}, (finalError) => {
+				this._postResponse(messageID, finalError, void 0, hostID);
+			});
+		} catch (err) {
+			this._postResponse(messageID, err);
+		}
+	}
+	_onMessageCommon(e) {
+		const message = parseMessage(e.data);
+		if (!message) return;
+		if (message[0] === 0) {
+			this._handleQuery(message);
+			return;
+		}
+		if (message[0] === 1) {
+			const messageID = message[1];
+			const error = message[2] === null ? null : message[2];
+			const callback = this._callbacks.get(messageID);
+			if (callback === void 0) return;
+			this._callbacks.delete(messageID);
+			callback(error, message[3]);
+			return;
+		}
+		return message;
+	}
+};
+//#endregion
+//#region src/PWBHost.ts
+let nextMessageID$1 = 0;
+var PWBHost = class extends PWBBase {
+	_hostID;
+	_hostIDQueue;
+	_worker;
+	constructor(worker) {
+		super();
+		if (!isSharedWorker(worker)) worker.addEventListener("message", this._onMessage);
+		else {
+			worker.port.addEventListener("message", this._onMessage);
+			worker.port.start();
+		}
+		this._worker = worker;
+		this._hostIDQueue = [];
+	}
+	_postMessage(obj, _hostID, transfer) {
+		if (isSharedWorker(this._worker)) {
+			if (transfer) this._worker.port.postMessage(obj, transfer);
+			else this._worker.port.postMessage(obj);
+		} else if (transfer) this._worker.postMessage(obj, transfer);
+		else this._worker.postMessage(obj);
+	}
+	postMessage(userMessage, _hostID, transfer) {
+		const actuallyPostMessage = (resolve, reject) => {
+			const messageID = nextMessageID$1;
+			nextMessageID$1 += 1;
+			const messageToSend = [
+				0,
+				messageID,
+				userMessage,
+				this._hostID
+			];
+			this._callbacks.set(messageID, (error, result) => {
+				if (error) reject(error);
+				else resolve(result);
+			});
+			this._postMessage(messageToSend, void 0, transfer);
+		};
+		return new Promise((resolve, reject) => {
+			if (this._hostIDQueue !== void 0) this._hostIDQueue.push(() => {
+				actuallyPostMessage(resolve, reject);
+			});
+			else actuallyPostMessage(resolve, reject);
+		});
+	}
+	handleWorkerLock(workerLockId) {
+		navigator.locks.request(workerLockId, { mode: "shared" }, async () => {
+			this.dispatchEvent(new Event("close"));
+		});
+	}
+	_onMessage(e) {
+		const message = this._onMessageCommon(e);
+		if (!message) return;
+		if (message[0] === 2) {
+			if (this._hostID !== void 0) throw new Error("Received duplicate hostID message");
+			const hostID = message[1];
+			this._hostID = hostID;
+			if (this._hostIDQueue !== void 0) {
+				for (const cb of this._hostIDQueue) setTimeout(() => {
+					cb();
+				}, 0);
+				this._hostIDQueue = void 0;
+			}
+			if (message[2] !== void 0) this.handleWorkerLock(message[2]);
+			const hostLockId = `pwb-host-${Math.random()}`;
+			navigator.locks.request(hostLockId, async () => {
+				this._postMessage([
+					3,
+					hostID,
+					hostLockId
+				]);
+				return new Promise(() => {});
+			});
+		} else if (message[0] === 5) {
+			const error = message[1];
+			this.dispatchEvent(new ErrorEvent("error", { error }));
+		} else if (message[0] === 4) this.handleWorkerLock(message[1]);
+	}
+};
+//#endregion
+//#region src/PWBWorker.ts
+let nextMessageID = 0;
+var PWBWorker = class extends PWBBase {
+	_hosts = /* @__PURE__ */ new Map();
+	_maxHostID = -1;
+	_sharedWorker;
+	_workerLockAcquired = false;
+	constructor() {
+		super();
+		const workerLockId = `pwb-worker-${Math.random()}`;
+		navigator.locks.request(workerLockId, async () => {
+			this._workerLockAcquired = true;
+			this._postMessage([4, workerLockId]);
+			return new Promise(() => {});
+		});
+		if (typeof SharedWorkerGlobalScope !== "undefined" && self instanceof SharedWorkerGlobalScope) {
+			this._sharedWorker = true;
+			const _self = self;
+			_self.addEventListener("connect", (e) => {
+				const port = e.ports[0];
+				port.addEventListener("message", (e2) => this._onMessage(e2));
+				port.start();
+				this._maxHostID += 1;
+				const hostID = this._maxHostID;
+				this._hosts.set(hostID, { port });
+				let message;
+				if (this._workerLockAcquired) message = [
+					2,
+					hostID,
+					workerLockId
+				];
+				else message = [2, hostID];
+				this._postMessage(message, hostID);
+			});
+			_self.addEventListener("error", (e) => {
+				logError(e.error);
+				e.preventDefault();
+				const hostID = this._hosts.keys().next().value;
+				if (hostID !== void 0) this._postMessage([5, e.error], hostID);
+			});
+		} else {
+			this._sharedWorker = false;
+			const _self = self;
+			_self.addEventListener("message", this._onMessage);
+			this._postMessage([2, 0], 0);
+			_self.addEventListener("error", (e) => {
+				logError(e.error);
+				e.preventDefault();
+				this._postMessage([5, e.error]);
+			});
+		}
+	}
+	_postMessage(message, targetHostID, transfer) {
+		if (this._sharedWorker) {
+			for (const [hostID, { port }] of this._hosts) if (targetHostID === void 0 || targetHostID === hostID) {
+				if (transfer) port.postMessage(message, transfer);
+				else port.postMessage(message);
+			}
+		} else {
+			const _self = self;
+			if (transfer) _self.postMessage(message, transfer);
+			else _self.postMessage(message);
+		}
+	}
+	postMessage(userMessage, targetHostID, transfer) {
+		const actuallyPostMessage = (resolve, reject) => {
+			const messageID = nextMessageID;
+			nextMessageID += 1;
+			const messageToSend = [
+				0,
+				messageID,
+				userMessage
+			];
+			this._callbacks.set(messageID, (error, result) => {
+				if (error) reject(error);
+				else resolve(result);
+			});
+			this._postMessage(messageToSend, targetHostID, transfer);
+		};
+		return new Promise((resolve, reject) => {
+			actuallyPostMessage(resolve, reject);
+		});
+	}
+	_onMessage(e) {
+		const message = this._onMessageCommon(e);
+		if (!message) return;
+		if (message[0] === 3) navigator.locks.request(message[2], () => {
+			if (this._hosts.size > 1) this._hosts.delete(message[1]);
+		});
+	}
+};
+//#endregion
 export { PWBHost, PWBWorker };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "promise-worker-bi",
-	"version": "5.0.2",
+	"version": "6.0.0-beta.1",
 	"description": "Promise-based messaging for Web Workers and Shared Workers",
 	"main": "./dist/index.js",
 	"types": "./dist/index.d.ts",
@@ -12,13 +12,10 @@
 	},
 	"type": "module",
 	"scripts": {
-		"prepack": "node --run build",
-		"build": "rm -rf dist && rollup -c && tsc --emitDeclarationOnly",
-		"build-test": "node --run build && node scripts/build-test.js",
-		"lint": "eslint .",
-		"prettier": "prettier --write 'src/*.ts' && prettier --write 'test/*.js' && prettier --write 'scripts/*.js'",
-		"karma": "node --run build-test && karma start",
-		"test": "tsc --noEmit && node --run lint && node --run karma",
+		"prepack": "pnpm run build",
+		"build": "tsdown",
+		"lint": "pnpm run build && tsc && eslint .",
+		"test": "pnpm run build && vitest run",
 		"prepare": "husky"
 	},
 	"repository": {
@@ -40,36 +37,26 @@
 	},
 	"homepage": "https://github.com/dumbmatter/promise-worker-bi",
 	"devDependencies": {
-		"@babel/core": "^7.29.0",
-		"@babel/preset-typescript": "^7.28.5",
 		"@eslint/js": "^10.0.1",
-		"@rollup/plugin-babel": "^7.0.0",
-		"@rollup/plugin-node-resolve": "^16.0.3",
-		"@typescript-eslint/eslint-plugin": "^8.56.1",
-		"@typescript-eslint/parser": "^8.56.1",
-		"eslint": "^10.0.3",
-		"eslint-plugin-import-x": "^4.16.1",
-		"globals": "^17.4.0",
+		"@typescript-eslint/eslint-plugin": "^8.69.0",
+		"@typescript-eslint/parser": "^8.69.0",
+		"@vitest/browser-playwright": "^5.0.0",
+		"eslint": "^10.10.0",
+		"eslint-plugin-import-x": "^4.17.1",
+		"globals": "^17.12.0",
 		"husky": "^9.1.7",
-		"karma": "^6.4.1",
-		"karma-chrome-launcher": "^3.1.1",
-		"karma-firefox-launcher": "^2.1.2",
-		"karma-mocha": "^2.0.1",
-		"karma-mocha-reporter": "^2.2.5",
-		"lint-staged": "^16.3.2",
-		"mocha": "^11.7.5",
-		"prettier": "^3.8.1",
-		"rollup": "^4.59.0",
-		"rollup-plugin-node-builtins": "^2.1.2",
-		"rollup-plugin-node-globals": "^1.4.0",
-		"tinyglobby": "^0.2.15",
-		"typescript": "^5.9.3",
-		"typescript-eslint": "^8.56.1"
+		"lint-staged": "^17.5.0",
+		"oxfmt": "^0.66.0",
+		"playwright": "^1.63.0",
+		"tsdown": "^0.23.0",
+		"typescript": "^6.0.3",
+		"typescript-eslint": "^8.69.0",
+		"vitest": "^5.0.0"
 	},
 	"files": [
 		"dist"
 	],
 	"lint-staged": {
-		"*.{js,cjs,mjs,jsx,json,scss,ts,cts,mts,tsx}": "prettier --write"
+		"*": "oxfmt --no-error-on-unmatched-pattern"
 	}
 }