@aztec/foundation 0.74.0 → 0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2

package/dest/transport/interface/transferable.js

@@ -13,8 +13,7 @@ const $transferable = Symbol('thread.transferable');
  *
  * @param thing - The object to check for transferability.
  * @returns A boolean indicating whether the object is transferable.
- */
-function isTransferable(thing) {
+ */ function isTransferable(thing) {
     if (!thing || typeof thing !== 'object') {
         return false;
     }
@@ -30,8 +29,7 @@ function isTransferable(thing) {
  *
  * @param thing - The object to be checked for being a TransferDescriptor.
  * @returns True if the object is a TransferDescriptor, false otherwise.
- */
-export function isTransferDescriptor(thing) {
+ */ export function isTransferDescriptor(thing) {
     return thing && typeof thing === 'object' && thing[$transferable];
 }
 /**
@@ -48,18 +46,18 @@ export function isTransferDescriptor(thing) {
  * @returns A TransferDescriptor<T> containing the payload and transferables, marked as transferable.
  * @throws Error if payload is not transferable and transferables array is not provided.
  * @see https://developers.google.com/web/updates/2011/12/Transferable-Objects-Lightning-Fast
- */
-export function Transfer(payload, transferables) {
+ */ export function Transfer(payload, transferables) {
     if (!transferables) {
         if (!isTransferable(payload)) {
             throw Error();
         }
-        transferables = [payload];
+        transferables = [
+            payload
+        ];
     }
     return {
         [$transferable]: true,
         send: payload,
-        transferables,
+        transferables
     };
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhbnNmZXJhYmxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3RyYW5zcG9ydC9pbnRlcmZhY2UvdHJhbnNmZXJhYmxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sYUFBYSxHQUFHLE1BQU0sQ0FBQyxxQkFBcUIsQ0FBQyxDQUFDO0FBc0JwRDs7Ozs7Ozs7Ozs7Ozs7R0FjRztBQUNILFNBQVMsY0FBYyxDQUFDLEtBQVU7SUFDaEMsSUFBSSxDQUFDLEtBQUssSUFBSSxPQUFPLEtBQUssS0FBSyxRQUFRLEVBQUUsQ0FBQztRQUN4QyxPQUFPLEtBQUssQ0FBQztJQUNmLENBQUM7SUFDRCwrRkFBK0Y7SUFDL0YsT0FBTyxJQUFJLENBQUM7QUFDZCxDQUFDO0FBRUQ7Ozs7Ozs7OztHQVNHO0FBQ0gsTUFBTSxVQUFVLG9CQUFvQixDQUFDLEtBQVU7SUFDN0MsT0FBTyxLQUFLLElBQUksT0FBTyxLQUFLLEtBQUssUUFBUSxJQUFJLEtBQUssQ0FBQyxhQUFhLENBQUMsQ0FBQztBQUNwRSxDQUFDO0FBdUNEOzs7Ozs7Ozs7Ozs7OztHQWNHO0FBQ0gsTUFBTSxVQUFVLFFBQVEsQ0FBSSxPQUFVLEVBQUUsYUFBOEI7SUFDcEUsSUFBSSxDQUFDLGFBQWEsRUFBRSxDQUFDO1FBQ25CLElBQUksQ0FBQyxjQUFjLENBQUMsT0FBTyxDQUFDLEVBQUUsQ0FBQztZQUM3QixNQUFNLEtBQUssRUFBRSxDQUFDO1FBQ2hCLENBQUM7UUFDRCxhQUFhLEdBQUcsQ0FBQyxPQUFPLENBQUMsQ0FBQztJQUM1QixDQUFDO0lBRUQsT0FBTztRQUNMLENBQUMsYUFBYSxDQUFDLEVBQUUsSUFBSTtRQUNyQixJQUFJLEVBQUUsT0FBTztRQUNiLGFBQWE7S0FDZCxDQUFDO0FBQ0osQ0FBQyJ9

package/dest/transport/node/index.js

@@ -1,3 +1,2 @@
 export * from './node_connector.js';
 export * from './node_listener.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdHJhbnNwb3J0L25vZGUvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLG9CQUFvQixDQUFDIn0=

package/dest/transport/node/node_connector.js

@@ -9,20 +9,18 @@ import { NodeConnectorSocket } from './node_connector_socket.js';
  * const nodeConnector = new NodeConnector(worker);
  * const socket = await nodeConnector.createSocket();
  * socket.send('Hello from main thread!');
- */
-export class NodeConnector {
-    constructor(worker) {
+ */ export class NodeConnector {
+    worker;
+    constructor(worker){
         this.worker = worker;
     }
     /**
-     * Creates a new instance of NodeConnectorSocket using the worker provided in the constructor.
-     * The createSocket method is used to establish connections using the worker_threads module,
-     * allowing for efficient and fast communication between different parts of the application.
-     *
-     * @returns A Promise that resolves to a newly created NodeConnectorSocket instance.
-     */
-    createSocket() {
+   * Creates a new instance of NodeConnectorSocket using the worker provided in the constructor.
+   * The createSocket method is used to establish connections using the worker_threads module,
+   * allowing for efficient and fast communication between different parts of the application.
+   *
+   * @returns A Promise that resolves to a newly created NodeConnectorSocket instance.
+   */ createSocket() {
         return Promise.resolve(new NodeConnectorSocket(this.worker));
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm9kZV9jb25uZWN0b3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdHJhbnNwb3J0L25vZGUvbm9kZV9jb25uZWN0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBR0EsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sNEJBQTRCLENBQUM7QUFFakU7Ozs7Ozs7Ozs7R0FVRztBQUNILE1BQU0sT0FBTyxhQUFhO0lBQ3hCLFlBQW9CLE1BQWM7UUFBZCxXQUFNLEdBQU4sTUFBTSxDQUFRO0lBQUcsQ0FBQztJQUV0Qzs7Ozs7O09BTUc7SUFDSCxZQUFZO1FBQ1YsT0FBTyxPQUFPLENBQUMsT0FBTyxDQUFDLElBQUksbUJBQW1CLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUM7SUFDL0QsQ0FBQztDQUNGIn0=

package/dest/transport/node/node_connector_socket.js

@@ -7,42 +7,38 @@
  * The send method sends messages to the worker thread, and the registerHandler method registers a
  * callback function to handle incoming messages from the worker. The close method cleans up
  * resources when the socket is no longer needed.
- */
-export class NodeConnectorSocket {
-    constructor(worker) {
+ */ export class NodeConnectorSocket {
+    worker;
+    constructor(worker){
         this.worker = worker;
     }
     /**
-     * Sends a message from the NodeConnectorSocket instance to the associated worker thread.
-     * The 'msg' can be any data type and 'transfer' is an optional array of transferable objects
-     * that can be transferred with zero-copy semantics. The function returns a resolved Promise
-     * once the message has been posted.
-     *
-     * @param msg - The message to send to the worker thread.
-     * @param transfer - Optional array of Transferable objects to transfer ownership alongside the message.
-     * @returns A Promise that resolves when the message has been posted.
-     */
-    send(msg, transfer = []) {
+   * Sends a message from the NodeConnectorSocket instance to the associated worker thread.
+   * The 'msg' can be any data type and 'transfer' is an optional array of transferable objects
+   * that can be transferred with zero-copy semantics. The function returns a resolved Promise
+   * once the message has been posted.
+   *
+   * @param msg - The message to send to the worker thread.
+   * @param transfer - Optional array of Transferable objects to transfer ownership alongside the message.
+   * @returns A Promise that resolves when the message has been posted.
+   */ send(msg, transfer = []) {
         this.worker.postMessage(msg, transfer);
         return Promise.resolve();
     }
     /**
-     * Registers a callback function to handle incoming messages from the worker.
-     * The provided callback will be executed whenever a message is received from
-     * the worker, passing the message as its single argument.
-     *
-     * @param cb - The callback function to be called when a message is received.
-     */
-    registerHandler(cb) {
+   * Registers a callback function to handle incoming messages from the worker.
+   * The provided callback will be executed whenever a message is received from
+   * the worker, passing the message as its single argument.
+   *
+   * @param cb - The callback function to be called when a message is received.
+   */ registerHandler(cb) {
         this.worker.on('message', cb);
     }
     /**
-     * Closes the worker connection and removes all event listeners.
-     * Sends an undefined message to the worker for graceful termination.
-     */
-    close() {
+   * Closes the worker connection and removes all event listeners.
+   * Sends an undefined message to the worker for graceful termination.
+   */ close() {
         void this.send(undefined);
         this.worker.removeAllListeners();
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm9kZV9jb25uZWN0b3Jfc29ja2V0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3RyYW5zcG9ydC9ub2RlL25vZGVfY29ubmVjdG9yX3NvY2tldC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFJQTs7Ozs7Ozs7O0dBU0c7QUFDSCxNQUFNLE9BQU8sbUJBQW1CO0lBQzlCLFlBQW9CLE1BQWM7UUFBZCxXQUFNLEdBQU4sTUFBTSxDQUFRO0lBQUcsQ0FBQztJQUV0Qzs7Ozs7Ozs7O09BU0c7SUFDSCxJQUFJLENBQUMsR0FBUSxFQUFFLFdBQTJCLEVBQUU7UUFDMUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxXQUFXLENBQUMsR0FBRyxFQUFFLFFBQThCLENBQUMsQ0FBQztRQUM3RCxPQUFPLE9BQU8sQ0FBQyxPQUFPLEVBQUUsQ0FBQztJQUMzQixDQUFDO0lBRUQ7Ozs7OztPQU1HO0lBQ0gsZUFBZSxDQUFDLEVBQXFCO1FBQ25DLElBQUksQ0FBQyxNQUFNLENBQUMsRUFBRSxDQUFDLFNBQVMsRUFBRSxFQUFFLENBQUMsQ0FBQztJQUNoQyxDQUFDO0lBRUQ7OztPQUdHO0lBQ0gsS0FBSztRQUNILEtBQUssSUFBSSxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsQ0FBQztRQUMxQixJQUFJLENBQUMsTUFBTSxDQUFDLGtCQUFrQixFQUFFLENBQUM7SUFDbkMsQ0FBQztDQUNGIn0=

package/dest/transport/node/node_listener.js

@@ -6,25 +6,21 @@ import { NodeListenerSocket } from './node_listener_socket.js';
  * It provides methods to open and close communication with a worker thread using the NodeListenerSocket.
  * The 'new_socket' event is emitted when a new NodeListenerSocket instance is created, allowing for
  * efficient processing of incoming messages from the parent thread.
- */
-export class NodeListener extends EventEmitter {
-    constructor() {
+ */ export class NodeListener extends EventEmitter {
+    constructor(){
         super();
     }
     /**
-     * Opens a new connection to a parent worker thread and emits an event with the created NodeListenerSocket instance.
-     * The 'new_socket' event can be listened for, providing access to the newly created NodeListenerSocket.
-     *
-     * Fires NodeListener#new_socket.
-     */
-    open() {
+   * Opens a new connection to a parent worker thread and emits an event with the created NodeListenerSocket instance.
+   * The 'new_socket' event can be listened for, providing access to the newly created NodeListenerSocket.
+   *
+   * Fires NodeListener#new_socket.
+   */ open() {
         this.emit('new_socket', new NodeListenerSocket(parentPort));
     }
     /**
-     * Closes the NodeListener instance.
-     * This method currently has no implementation, as there is no need to perform any actions
-     * when closing a NodeListener. It exists for compatibility with the Listener interface.
-     */
-    close() { }
+   * Closes the NodeListener instance.
+   * This method currently has no implementation, as there is no need to perform any actions
+   * when closing a NodeListener. It exists for compatibility with the Listener interface.
+   */ close() {}
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm9kZV9saXN0ZW5lci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy90cmFuc3BvcnQvbm9kZS9ub2RlX2xpc3RlbmVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sWUFBWSxNQUFNLFFBQVEsQ0FBQztBQUNsQyxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFHNUMsT0FBTyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFFL0Q7Ozs7O0dBS0c7QUFDSCxNQUFNLE9BQU8sWUFBYSxTQUFRLFlBQVk7SUFDNUM7UUFDRSxLQUFLLEVBQUUsQ0FBQztJQUNWLENBQUM7SUFFRDs7Ozs7T0FLRztJQUNILElBQUk7UUFDRixJQUFJLENBQUMsSUFBSSxDQUFDLFlBQVksRUFBRSxJQUFJLGtCQUFrQixDQUFDLFVBQWlCLENBQUMsQ0FBQyxDQUFDO0lBQ3JFLENBQUM7SUFFRDs7OztPQUlHO0lBQ0gsS0FBSyxLQUFJLENBQUM7Q0FDWCJ9

package/dest/transport/node/node_listener_socket.js

@@ -1,44 +1,40 @@
 /**
  * An implementation of a TransportSocket using MessagePorts.
- */
-export class NodeListenerSocket {
-    constructor(port) {
+ */ export class NodeListenerSocket {
+    port;
+    constructor(port){
         this.port = port;
     }
     /**
-     * Sends a message through the MessagePort along with any provided Transferables.
-     * The transfer list allows for efficient sending of certain types of data,
-     * such as ArrayBuffer, ImageBitmap, and MessagePort.
-     * The Promise resolves once the message has been successfully sent.
-     *
-     * @param msg - The message to be sent through the MessagePort.
-     * @param transfer - An optional array of Transferable objects to be transferred.
-     * @returns A Promise that resolves once the message has been sent.
-     */
-    send(msg, transfer = []) {
+   * Sends a message through the MessagePort along with any provided Transferables.
+   * The transfer list allows for efficient sending of certain types of data,
+   * such as ArrayBuffer, ImageBitmap, and MessagePort.
+   * The Promise resolves once the message has been successfully sent.
+   *
+   * @param msg - The message to be sent through the MessagePort.
+   * @param transfer - An optional array of Transferable objects to be transferred.
+   * @returns A Promise that resolves once the message has been sent.
+   */ send(msg, transfer = []) {
         this.port.postMessage(msg, transfer);
         return Promise.resolve();
     }
     /**
-     * Registers a callback function to handle incoming messages from the MessagePort.
-     * When a message is received, the provided callback function will be invoked with
-     * the received message as its argument. This method allows for efficient and
-     * dynamic handling of incoming data in a NodeListenerSocket instance.
-     *
-     * @param cb - The callback function to process incoming messages.
-     */
-    registerHandler(cb) {
+   * Registers a callback function to handle incoming messages from the MessagePort.
+   * When a message is received, the provided callback function will be invoked with
+   * the received message as its argument. This method allows for efficient and
+   * dynamic handling of incoming data in a NodeListenerSocket instance.
+   *
+   * @param cb - The callback function to process incoming messages.
+   */ registerHandler(cb) {
         this.port.on('message', cb);
     }
     /**
-     * Closes the NodeListenerSocket instance, removing all listeners and closing the underlying MessagePort.
-     * Sends an undefined message to notify any connected ports about the closure before removing event listeners
-     * and cleaning up resources. This method should be called when the socket is no longer needed to avoid memory leaks.
-     */
-    close() {
+   * Closes the NodeListenerSocket instance, removing all listeners and closing the underlying MessagePort.
+   * Sends an undefined message to notify any connected ports about the closure before removing event listeners
+   * and cleaning up resources. This method should be called when the socket is no longer needed to avoid memory leaks.
+   */ close() {
         void this.send(undefined);
         this.port.removeAllListeners();
         this.port.close();
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm9kZV9saXN0ZW5lcl9zb2NrZXQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdHJhbnNwb3J0L25vZGUvbm9kZV9saXN0ZW5lcl9zb2NrZXQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBSUE7O0dBRUc7QUFDSCxNQUFNLE9BQU8sa0JBQWtCO0lBQzdCLFlBQW9CLElBQWlCO1FBQWpCLFNBQUksR0FBSixJQUFJLENBQWE7SUFBRyxDQUFDO0lBRXpDOzs7Ozs7Ozs7T0FTRztJQUNILElBQUksQ0FBQyxHQUFRLEVBQUUsV0FBMkIsRUFBRTtRQUMxQyxJQUFJLENBQUMsSUFBSSxDQUFDLFdBQVcsQ0FBQyxHQUFHLEVBQUUsUUFBOEIsQ0FBQyxDQUFDO1FBQzNELE9BQU8sT0FBTyxDQUFDLE9BQU8sRUFBRSxDQUFDO0lBQzNCLENBQUM7SUFFRDs7Ozs7OztPQU9HO0lBQ0gsZUFBZSxDQUFDLEVBQXFCO1FBQ25DLElBQUksQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUFDLFNBQVMsRUFBRSxFQUFFLENBQUMsQ0FBQztJQUM5QixDQUFDO0lBRUQ7Ozs7T0FJRztJQUNILEtBQUs7UUFDSCxLQUFLLElBQUksQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLENBQUM7UUFDMUIsSUFBSSxDQUFDLElBQUksQ0FBQyxrQkFBa0IsRUFBRSxDQUFDO1FBQy9CLElBQUksQ0FBQyxJQUFJLENBQUMsS0FBSyxFQUFFLENBQUM7SUFDcEIsQ0FBQztDQUNGIn0=

package/dest/transport/transport_client.js

@@ -8,67 +8,70 @@ const log = createLogger('foundation:transport_client');
  * If `broadcast` is called on TransportServer, TransportClients will emit an `event_msg`.
  * The `request` method will block until a response is returned from the TransportServer's dispatch function.
  * Request multiplexing is supported.
- */
-export class TransportClient extends EventEmitter {
-    constructor(transportConnect) {
-        super();
-        this.transportConnect = transportConnect;
-        this.msgId = 0;
-        this.pendingRequests = [];
+ */ export class TransportClient extends EventEmitter {
+    transportConnect;
+    msgId;
+    pendingRequests;
+    socket;
+    constructor(transportConnect){
+        super(), this.transportConnect = transportConnect, this.msgId = 0, this.pendingRequests = [];
     }
     /**
-     * Initializes and opens the socket connection for the TransportClient.
-     * This method creates a new Socket instance using the provided Connector,
-     * registers a handler for incoming messages, and establishes the connection.
-     * It should be called before making any requests or handling events.
-     *
-     * @throws An error if the socket is already open or there's an issue opening the connection.
-     * @returns A Promise that resolves when the socket connection is successfully opened.
-     */
-    async open() {
+   * Initializes and opens the socket connection for the TransportClient.
+   * This method creates a new Socket instance using the provided Connector,
+   * registers a handler for incoming messages, and establishes the connection.
+   * It should be called before making any requests or handling events.
+   *
+   * @throws An error if the socket is already open or there's an issue opening the connection.
+   * @returns A Promise that resolves when the socket connection is successfully opened.
+   */ async open() {
         this.socket = await this.transportConnect.createSocket();
-        this.socket.registerHandler(msg => this.handleSocketMessage(msg));
+        this.socket.registerHandler((msg)=>this.handleSocketMessage(msg));
     }
     /**
-     * Close the transport client's socket connection and remove all event listeners.
-     * This method should be called when the client is no longer needed to ensure proper cleanup
-     * and prevent potential memory leaks. Once closed, the client cannot be reused and a new
-     * instance must be created if another connection is needed.
-     */
-    close() {
+   * Close the transport client's socket connection and remove all event listeners.
+   * This method should be called when the client is no longer needed to ensure proper cleanup
+   * and prevent potential memory leaks. Once closed, the client cannot be reused and a new
+   * instance must be created if another connection is needed.
+   */ close() {
         this.socket?.close();
         this.socket = undefined;
         this.removeAllListeners();
     }
     /**
-     * Sends a request to the TransportServer with the given payload and transferable objects.
-     * The method will block until a response from the TransportServer's dispatch function is returned.
-     * Request multiplexing is supported, allowing multiple requests to be sent concurrently.
-     *
-     * @param payload - The message payload to send to the server.
-     * @param transfer - An optional array of ArrayBuffer, MessagePort, or ImageBitmap objects to transfer ownership.
-     * @returns A Promise that resolves with the server's response data or rejects with an error message.
-     */
-    request(payload, transfer) {
+   * Sends a request to the TransportServer with the given payload and transferable objects.
+   * The method will block until a response from the TransportServer's dispatch function is returned.
+   * Request multiplexing is supported, allowing multiple requests to be sent concurrently.
+   *
+   * @param payload - The message payload to send to the server.
+   * @param transfer - An optional array of ArrayBuffer, MessagePort, or ImageBitmap objects to transfer ownership.
+   * @returns A Promise that resolves with the server's response data or rejects with an error message.
+   */ request(payload, transfer) {
         if (!this.socket) {
             throw new Error('Socket not open.');
         }
         const msgId = this.msgId++;
-        const msg = { msgId, payload };
+        const msg = {
+            msgId,
+            payload
+        };
         log.debug(format(`->`, msg));
-        return new Promise((resolve, reject) => {
-            this.pendingRequests.push({ resolve, reject, msgId });
+        return new Promise((resolve, reject)=>{
+            this.pendingRequests.push({
+                resolve,
+                reject,
+                msgId
+            });
             this.socket.send(msg, transfer).catch(reject);
         });
     }
     /**
-     * Handles incoming socket messages from the TransportServer, such as ResponseMessage and EventMessage.
-     * If it's an EventMessage, emits an 'event_msg' event with the payload.
-     * If it's a ResponseMessage, resolves or rejects the corresponding pending request based on the message content.
-     *
-     * @param msg - The ResponseMessage or EventMessage received from the TransportServer, or undefined if the remote socket closed.
-     */
-    handleSocketMessage(msg) {
+   * Handles incoming socket messages from the TransportServer, such as ResponseMessage and EventMessage.
+   * If it's an EventMessage, emits an 'event_msg' event with the payload.
+   * If it's a ResponseMessage, resolves or rejects the corresponding pending request based on the message content.
+   *
+   * @param msg - The ResponseMessage or EventMessage received from the TransportServer, or undefined if the remote socket closed.
+   */ handleSocketMessage(msg) {
         if (msg === undefined) {
             // The remote socket closed.
             this.close();
@@ -79,17 +82,15 @@ export class TransportClient extends EventEmitter {
             this.emit('event_msg', msg.payload);
             return;
         }
-        const reqIndex = this.pendingRequests.findIndex(r => r.msgId === msg.msgId);
+        const reqIndex = this.pendingRequests.findIndex((r)=>r.msgId === msg.msgId);
         if (reqIndex === -1) {
             return;
         }
         const [pending] = this.pendingRequests.splice(reqIndex, 1);
         if (msg.error) {
             pending.reject(new Error(msg.error));
-        }
-        else {
+        } else {
             pending.resolve(msg.payload);
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,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

package/dest/transport/transport_server.js

@@ -1,52 +1,52 @@
 import { isTransferDescriptor } from './interface/transferable.js';
 /**
  * Keeps track of clients, providing a broadcast, and request/response api with multiplexing.
- */
-export class TransportServer {
-    constructor(listener, msgHandlerFn) {
+ */ export class TransportServer {
+    listener;
+    msgHandlerFn;
+    sockets;
+    constructor(listener, msgHandlerFn){
         this.listener = listener;
         this.msgHandlerFn = msgHandlerFn;
         this.sockets = [];
     }
     /**
-     * Starts the TransportServer, allowing it to accept new connections and handle incoming messages.
-     * The server will listen for 'new_socket' events from the underlying listener and invoke the provided message handler function
-     * for each received message. The server remains active until the 'stop' method is called.
-     */
-    start() {
-        this.listener.on('new_socket', client => this.handleNewSocket(client));
+   * Starts the TransportServer, allowing it to accept new connections and handle incoming messages.
+   * The server will listen for 'new_socket' events from the underlying listener and invoke the provided message handler function
+   * for each received message. The server remains active until the 'stop' method is called.
+   */ start() {
+        this.listener.on('new_socket', (client)=>this.handleNewSocket(client));
         this.listener.open();
     }
     /**
-     * Stops accepting new connections. It doesn't close existing sockets.
-     * It's expected the clients will gracefully complete by closing their end, sending an `undefined` message.
-     */
-    stop() {
+   * Stops accepting new connections. It doesn't close existing sockets.
+   * It's expected the clients will gracefully complete by closing their end, sending an `undefined` message.
+   */ stop() {
         this.listener.close();
     }
     /**
-     * Sends a broadcast message to all connected clients.
-     * The given payload will be sent to all the clients currently connected to the TransportServer.
-     * It waits for all the messages to be sent and resolves when they are all sent successfully.
-     *
-     * @param msg - The payload to broadcast to all connected clients.
-     * @returns A Promise that resolves when all messages have been sent successfully.
-     */
-    async broadcast(msg) {
-        await Promise.all(this.sockets.map(s => s.send({ payload: msg })));
+   * Sends a broadcast message to all connected clients.
+   * The given payload will be sent to all the clients currently connected to the TransportServer.
+   * It waits for all the messages to be sent and resolves when they are all sent successfully.
+   *
+   * @param msg - The payload to broadcast to all connected clients.
+   * @returns A Promise that resolves when all messages have been sent successfully.
+   */ async broadcast(msg) {
+        await Promise.all(this.sockets.map((s)=>s.send({
+                payload: msg
+            })));
     }
     /**
-     * Handles the addition of a new socket to the server by registering a message handler for the client
-     * and adding the socket to the list of active sockets. The message handler processes incoming messages
-     * from the client, including detecting client disconnection and removing the closed socket.
-     *
-     * @param socket - The new Socket instance that has connected to the server.
-     */
-    handleNewSocket(socket) {
-        socket.registerHandler(async (msg) => {
+   * Handles the addition of a new socket to the server by registering a message handler for the client
+   * and adding the socket to the list of active sockets. The message handler processes incoming messages
+   * from the client, including detecting client disconnection and removing the closed socket.
+   *
+   * @param socket - The new Socket instance that has connected to the server.
+   */ handleNewSocket(socket) {
+        socket.registerHandler(async (msg)=>{
             if (msg === undefined) {
                 // Client socket has closed. Remove it from the list of sockets. Call close on it for any cleanup.
-                const socketIndex = this.sockets.findIndex(s => s === socket);
+                const socketIndex = this.sockets.findIndex((s)=>s === socket);
                 const [closingSocket] = this.sockets.splice(socketIndex, 1);
                 closingSocket.close();
                 return;
@@ -56,46 +56,59 @@ export class TransportServer {
         this.sockets.push(socket);
     }
     /**
-     * Detect the 'transferables' argument to our socket from our message
-     * handler return type.
-     * @param data - The compound payload data.
-     * @returns The split data and transferables.
-     */
-    getPayloadAndTransfers(data) {
+   * Detect the 'transferables' argument to our socket from our message
+   * handler return type.
+   * @param data - The compound payload data.
+   * @returns The split data and transferables.
+   */ getPayloadAndTransfers(data) {
         if (isTransferDescriptor(data)) {
             // We treat PayloadWithTransfers specially so that we're able to
             // attach transferables while keeping a simple return-type based usage
-            return [data.send, data.transferables];
+            return [
+                data.send,
+                data.transferables
+            ];
         }
         if (data instanceof Uint8Array) {
             // We may want to devise a better solution to this. We maybe given a view over a non cloneable/transferrable
             // ArrayBuffer (such as a view over wasm memory). In this case we want to take a copy, and then transfer it.
             const respPayload = data instanceof Uint8Array && ArrayBuffer.isView(data) ? new Uint8Array(data) : data;
-            const transferables = data instanceof Uint8Array ? [respPayload.buffer] : [];
-            return [respPayload, transferables];
+            const transferables = data instanceof Uint8Array ? [
+                respPayload.buffer
+            ] : [];
+            return [
+                respPayload,
+                transferables
+            ];
         }
-        return [data, []];
+        return [
+            data,
+            []
+        ];
     }
     /**
-     * Handles incoming socket messages, processing the request and sending back a response.
-     * This function is responsible for invoking the registered message handler function with the received
-     * payload, extracting the result and transferables, and sending a response message back to the client.
-     * In case of an error during message handling, it sends an error response with the stack trace.
-     *
-     * @param socket - The Socket instance from which the message was received.
-     * @param msg - The RequestMessage object containing the message ID and payload.
-     */
-    async handleSocketMessage(socket, { msgId, payload }) {
+   * Handles incoming socket messages, processing the request and sending back a response.
+   * This function is responsible for invoking the registered message handler function with the received
+   * payload, extracting the result and transferables, and sending a response message back to the client.
+   * In case of an error during message handling, it sends an error response with the stack trace.
+   *
+   * @param socket - The Socket instance from which the message was received.
+   * @param msg - The RequestMessage object containing the message ID and payload.
+   */ async handleSocketMessage(socket, { msgId, payload }) {
         try {
             const data = await this.msgHandlerFn(payload);
             const [respPayload, transferables] = this.getPayloadAndTransfers(data);
-            const rep = { msgId, payload: respPayload };
+            const rep = {
+                msgId,
+                payload: respPayload
+            };
             await socket.send(rep, transferables);
-        }
-        catch (err) {
-            const rep = { msgId, error: err.stack };
+        } catch (err) {
+            const rep = {
+                msgId,
+                error: err.stack
+            };
             await socket.send(rep);
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,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

package/dest/trees/index.js

@@ -1,3 +1,2 @@
 export * from './unbalanced_merkle_tree.js';
 export * from './unbalanced_tree_store.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdHJlZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyw2QkFBNkIsQ0FBQztBQUM1QyxjQUFjLDRCQUE0QixDQUFDIn0=