@aztec/foundation 0.7.2 → 0.7.3

package/dest/transport/node/node_connector.d.ts

@@ -0,0 +1,28 @@
+/// <reference types="node" resolution-mode="require"/>
+import { Worker } from 'worker_threads';
+import { Connector } from '../interface/connector.js';
+import { NodeConnectorSocket } from './node_connector_socket.js';
+/**
+ * The NodeConnector class is a concrete implementation of the Connector interface, utilizing worker_threads for
+ * efficient parallel execution. This class provides an easy way to establish a connection with a Worker instance,
+ * allowing seamless communication via sockets.
+ *
+ * @example
+ * const worker = new Worker('./path/to/worker.js');
+ * const nodeConnector = new NodeConnector(worker);
+ * const socket = await nodeConnector.createSocket();
+ * socket.send('Hello from main thread!');
+ */
+export declare class NodeConnector implements Connector {
+    private worker;
+    constructor(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(): Promise<NodeConnectorSocket>;
+}
+//# sourceMappingURL=node_connector.d.ts.map

package/dest/transport/node/node_connector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node_connector.d.ts","sourceRoot":"","sources":["../../../src/transport/node/node_connector.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAExC,OAAO,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AACtD,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAEjE;;;;;;;;;;GAUG;AACH,qBAAa,aAAc,YAAW,SAAS;IACjC,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,MAAM;IAElC;;;;;;OAMG;IACH,YAAY;CAGb"}

package/dest/transport/node/node_connector.js

@@ -0,0 +1,28 @@
+import { NodeConnectorSocket } from './node_connector_socket.js';
+/**
+ * The NodeConnector class is a concrete implementation of the Connector interface, utilizing worker_threads for
+ * efficient parallel execution. This class provides an easy way to establish a connection with a Worker instance,
+ * allowing seamless communication via sockets.
+ *
+ * @example
+ * const worker = new Worker('./path/to/worker.js');
+ * const nodeConnector = new NodeConnector(worker);
+ * const socket = await nodeConnector.createSocket();
+ * socket.send('Hello from main thread!');
+ */
+export class NodeConnector {
+    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() {
+        return Promise.resolve(new NodeConnectorSocket(this.worker));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm9kZV9jb25uZWN0b3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdHJhbnNwb3J0L25vZGUvbm9kZV9jb25uZWN0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBR0EsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sNEJBQTRCLENBQUM7QUFFakU7Ozs7Ozs7Ozs7R0FVRztBQUNILE1BQU0sT0FBTyxhQUFhO0lBQ3hCLFlBQW9CLE1BQWM7UUFBZCxXQUFNLEdBQU4sTUFBTSxDQUFRO0lBQUcsQ0FBQztJQUV0Qzs7Ozs7O09BTUc7SUFDSCxZQUFZO1FBQ1YsT0FBTyxPQUFPLENBQUMsT0FBTyxDQUFDLElBQUksbUJBQW1CLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUM7SUFDL0QsQ0FBQztDQUNGIn0=

package/dest/transport/node/node_connector_socket.d.ts

@@ -0,0 +1,42 @@
+/// <reference types="node" resolution-mode="require"/>
+import { Worker } from 'worker_threads';
+import { Socket } from '../interface/socket.js';
+/**
+ * NodeConnectorSocket is a wrapper class that implements the Socket interface for messaging between
+ * the main thread and worker threads in a Node.js environment. It uses the Worker API for
+ * communication by sending and receiving messages through postMessage and handling messages using
+ * event listeners.
+ *
+ * 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 declare class NodeConnectorSocket implements Socket {
+    private worker;
+    constructor(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: any, transfer?: Transferable[]): Promise<void>;
+    /**
+     * 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: (msg: any) => any): void;
+    /**
+     * Closes the worker connection and removes all event listeners.
+     * Sends an undefined message to the worker for graceful termination.
+     */
+    close(): void;
+}
+//# sourceMappingURL=node_connector_socket.d.ts.map

package/dest/transport/node/node_connector_socket.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node_connector_socket.d.ts","sourceRoot":"","sources":["../../../src/transport/node/node_connector_socket.ts"],"names":[],"mappings":";AAAA,OAAO,EAAoB,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAE1D,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAEhD;;;;;;;;;GASG;AACH,qBAAa,mBAAoB,YAAW,MAAM;IACpC,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,MAAM;IAElC;;;;;;;;;OASG;IACH,IAAI,CAAC,GAAG,EAAE,GAAG,EAAE,QAAQ,GAAE,YAAY,EAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAK5D;;;;;;OAMG;IACH,eAAe,CAAC,EAAE,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,GAAG,GAAG,IAAI;IAI5C;;;OAGG;IACH,KAAK;CAIN"}

package/dest/transport/node/node_connector_socket.js

@@ -0,0 +1,48 @@
+/**
+ * NodeConnectorSocket is a wrapper class that implements the Socket interface for messaging between
+ * the main thread and worker threads in a Node.js environment. It uses the Worker API for
+ * communication by sending and receiving messages through postMessage and handling messages using
+ * event listeners.
+ *
+ * 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) {
+        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 = []) {
+        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) {
+        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() {
+        void this.send(undefined);
+        this.worker.removeAllListeners();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm9kZV9jb25uZWN0b3Jfc29ja2V0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3RyYW5zcG9ydC9ub2RlL25vZGVfY29ubmVjdG9yX3NvY2tldC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFJQTs7Ozs7Ozs7O0dBU0c7QUFDSCxNQUFNLE9BQU8sbUJBQW1CO0lBQzlCLFlBQW9CLE1BQWM7UUFBZCxXQUFNLEdBQU4sTUFBTSxDQUFRO0lBQUcsQ0FBQztJQUV0Qzs7Ozs7Ozs7O09BU0c7SUFDSCxJQUFJLENBQUMsR0FBUSxFQUFFLFdBQTJCLEVBQUU7UUFDMUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxXQUFXLENBQUMsR0FBRyxFQUFFLFFBQThCLENBQUMsQ0FBQztRQUM3RCxPQUFPLE9BQU8sQ0FBQyxPQUFPLEVBQUUsQ0FBQztJQUMzQixDQUFDO0lBRUQ7Ozs7OztPQU1HO0lBQ0gsZUFBZSxDQUFDLEVBQXFCO1FBQ25DLElBQUksQ0FBQyxNQUFNLENBQUMsRUFBRSxDQUFDLFNBQVMsRUFBRSxFQUFFLENBQUMsQ0FBQztJQUNoQyxDQUFDO0lBRUQ7OztPQUdHO0lBQ0gsS0FBSztRQUNILEtBQUssSUFBSSxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsQ0FBQztRQUMxQixJQUFJLENBQUMsTUFBTSxDQUFDLGtCQUFrQixFQUFFLENBQUM7SUFDbkMsQ0FBQztDQUNGIn0=

package/dest/transport/node/node_listener.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="node" resolution-mode="require"/>
+import EventEmitter from 'events';
+import { Listener } from '../interface/listener.js';
+/**
+ * NodeListener is an event-driven class that extends EventEmitter and implements the Listener interface.
+ * 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 declare class NodeListener extends EventEmitter implements Listener {
+    constructor();
+    /**
+     * 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(): void;
+    /**
+     * 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(): void;
+}
+//# sourceMappingURL=node_listener.d.ts.map

package/dest/transport/node/node_listener.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node_listener.d.ts","sourceRoot":"","sources":["../../../src/transport/node/node_listener.ts"],"names":[],"mappings":";AAAA,OAAO,YAAY,MAAM,QAAQ,CAAC;AAGlC,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAGpD;;;;;GAKG;AACH,qBAAa,YAAa,SAAQ,YAAa,YAAW,QAAQ;;IAKhE;;;;;OAKG;IACH,IAAI;IAIJ;;;;OAIG;IACH,KAAK;CACN"}

package/dest/transport/node/node_listener.js

@@ -0,0 +1,30 @@
+import EventEmitter from 'events';
+import { parentPort } from 'worker_threads';
+import { NodeListenerSocket } from './node_listener_socket.js';
+/**
+ * NodeListener is an event-driven class that extends EventEmitter and implements the Listener interface.
+ * 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() {
+        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() {
+        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() { }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm9kZV9saXN0ZW5lci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy90cmFuc3BvcnQvbm9kZS9ub2RlX2xpc3RlbmVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sWUFBWSxNQUFNLFFBQVEsQ0FBQztBQUNsQyxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFHNUMsT0FBTyxFQUFFLGtCQUFrQixFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFFL0Q7Ozs7O0dBS0c7QUFDSCxNQUFNLE9BQU8sWUFBYSxTQUFRLFlBQVk7SUFDNUM7UUFDRSxLQUFLLEVBQUUsQ0FBQztJQUNWLENBQUM7SUFFRDs7Ozs7T0FLRztJQUNILElBQUk7UUFDRixJQUFJLENBQUMsSUFBSSxDQUFDLFlBQVksRUFBRSxJQUFJLGtCQUFrQixDQUFDLFVBQWlCLENBQUMsQ0FBQyxDQUFDO0lBQ3JFLENBQUM7SUFFRDs7OztPQUlHO0lBQ0gsS0FBSyxLQUFJLENBQUM7Q0FDWCJ9

package/dest/transport/node/node_listener_socket.d.ts

@@ -0,0 +1,37 @@
+/// <reference types="node" resolution-mode="require"/>
+import { MessagePort } from 'worker_threads';
+import { Socket } from '../interface/socket.js';
+/**
+ * An implementation of a TransportSocket using MessagePorts.
+ */
+export declare class NodeListenerSocket implements Socket {
+    private port;
+    constructor(port: MessagePort);
+    /**
+     * 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: any, transfer?: Transferable[]): Promise<void>;
+    /**
+     * 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: (msg: any) => any): void;
+    /**
+     * 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;
+}
+//# sourceMappingURL=node_listener_socket.d.ts.map

package/dest/transport/node/node_listener_socket.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node_listener_socket.d.ts","sourceRoot":"","sources":["../../../src/transport/node/node_listener_socket.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,WAAW,EAAoB,MAAM,gBAAgB,CAAC;AAE/D,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAEhD;;GAEG;AACH,qBAAa,kBAAmB,YAAW,MAAM;IACnC,OAAO,CAAC,IAAI;gBAAJ,IAAI,EAAE,WAAW;IAErC;;;;;;;;;OASG;IACH,IAAI,CAAC,GAAG,EAAE,GAAG,EAAE,QAAQ,GAAE,YAAY,EAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAK5D;;;;;;;OAOG;IACH,eAAe,CAAC,EAAE,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,GAAG,GAAG,IAAI;IAI5C;;;;OAIG;IACH,KAAK;CAKN"}

package/dest/transport/node/node_listener_socket.js

@@ -0,0 +1,44 @@
+/**
+ * An implementation of a TransportSocket using MessagePorts.
+ */
+export class NodeListenerSocket {
+    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 = []) {
+        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) {
+        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() {
+        void this.send(undefined);
+        this.port.removeAllListeners();
+        this.port.close();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm9kZV9saXN0ZW5lcl9zb2NrZXQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdHJhbnNwb3J0L25vZGUvbm9kZV9saXN0ZW5lcl9zb2NrZXQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBSUE7O0dBRUc7QUFDSCxNQUFNLE9BQU8sa0JBQWtCO0lBQzdCLFlBQW9CLElBQWlCO1FBQWpCLFNBQUksR0FBSixJQUFJLENBQWE7SUFBRyxDQUFDO0lBRXpDOzs7Ozs7Ozs7T0FTRztJQUNILElBQUksQ0FBQyxHQUFRLEVBQUUsV0FBMkIsRUFBRTtRQUMxQyxJQUFJLENBQUMsSUFBSSxDQUFDLFdBQVcsQ0FBQyxHQUFHLEVBQUUsUUFBOEIsQ0FBQyxDQUFDO1FBQzNELE9BQU8sT0FBTyxDQUFDLE9BQU8sRUFBRSxDQUFDO0lBQzNCLENBQUM7SUFFRDs7Ozs7OztPQU9HO0lBQ0gsZUFBZSxDQUFDLEVBQXFCO1FBQ25DLElBQUksQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUFDLFNBQVMsRUFBRSxFQUFFLENBQUMsQ0FBQztJQUM5QixDQUFDO0lBRUQ7Ozs7T0FJRztJQUNILEtBQUs7UUFDSCxLQUFLLElBQUksQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLENBQUM7UUFDMUIsSUFBSSxDQUFDLElBQUksQ0FBQyxrQkFBa0IsRUFBRSxDQUFDO1FBQy9CLElBQUksQ0FBQyxJQUFJLENBQUMsS0FBSyxFQUFFLENBQUM7SUFDcEIsQ0FBQztDQUNGIn0=

package/dest/transport/transport_client.d.ts

@@ -0,0 +1,61 @@
+/// <reference types="node" resolution-mode="require"/>
+import EventEmitter from 'events';
+import { Connector } from './interface/connector.js';
+/**
+ * Represents a transport client for communication between TransportServer and clients.
+ * Provides request/response functionality, event handling, and multiplexing support
+ * for efficient and concurrent communication with a corresponding TransportServer.
+ */
+export interface ITransportClient<Payload> extends EventEmitter {
+    on(name: 'event_msg', handler: (payload: Payload) => void): this;
+    emit(name: 'event_msg', payload: Payload): boolean;
+}
+/**
+ * A TransportClient provides a request/response and event api to a corresponding TransportServer.
+ * 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 declare class TransportClient<Payload> extends EventEmitter {
+    private transportConnect;
+    private msgId;
+    private pendingRequests;
+    private socket?;
+    constructor(transportConnect: Connector);
+    /**
+     * 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.
+     */
+    open(): Promise<void>;
+    /**
+     * 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(): void;
+    /**
+     * 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: Payload, transfer?: Transferable[]): Promise<any>;
+    /**
+     * 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.
+     */
+    private handleSocketMessage;
+}
+//# sourceMappingURL=transport_client.d.ts.map

package/dest/transport/transport_client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport_client.d.ts","sourceRoot":"","sources":["../../src/transport/transport_client.ts"],"names":[],"mappings":";AAAA,OAAO,YAAY,MAAM,QAAQ,CAAC;AAIlC,OAAO,EAAE,SAAS,EAAE,MAAM,0BAA0B,CAAC;AAqBrD;;;;GAIG;AACH,MAAM,WAAW,gBAAgB,CAAC,OAAO,CAAE,SAAQ,YAAY;IAE7D,EAAE,CAAC,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,GAAG,IAAI,CAAC;IAEjE,IAAI,CAAC,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC;CACpD;AAED;;;;;GAKG;AACH,qBAAa,eAAe,CAAC,OAAO,CAAE,SAAQ,YAAY;IAK5C,OAAO,CAAC,gBAAgB;IAJpC,OAAO,CAAC,KAAK,CAAK;IAClB,OAAO,CAAC,eAAe,CAAwB;IAC/C,OAAO,CAAC,MAAM,CAAC,CAAS;gBAEJ,gBAAgB,EAAE,SAAS;IAI/C;;;;;;;;OAQG;IACG,IAAI;IAKV;;;;;OAKG;IACH,KAAK;IAML;;;;;;;;OAQG;IACH,OAAO,CAAC,OAAO,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,YAAY,EAAE;IAanD;;;;;;OAMG;IACH,OAAO,CAAC,mBAAmB;CAsB5B"}

package/dest/transport/transport_client.js

@@ -0,0 +1,94 @@
+import EventEmitter from 'events';
+import { createDebugLogger } from '../log/index.js';
+import { isEventMessage } from './dispatch/messages.js';
+const debug = createDebugLogger('aztec:transport_client');
+/**
+ * A TransportClient provides a request/response and event api to a corresponding TransportServer.
+ * 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 = [];
+    }
+    /**
+     * 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));
+    }
+    /**
+     * 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) {
+        if (!this.socket) {
+            throw new Error('Socket not open.');
+        }
+        const msgId = this.msgId++;
+        const msg = { msgId, payload };
+        debug(`->`, msg);
+        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) {
+        if (msg === undefined) {
+            // The remote socket closed.
+            this.close();
+            return;
+        }
+        debug(`<-`, msg);
+        if (isEventMessage(msg)) {
+            this.emit('event_msg', msg.payload);
+            return;
+        }
+        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 {
+            pending.resolve(msg.payload);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/transport/transport_server.d.ts

@@ -0,0 +1,56 @@
+import { Listener } from './interface/listener.js';
+/**
+ * Keeps track of clients, providing a broadcast, and request/response api with multiplexing.
+ */
+export declare class TransportServer<Payload> {
+    private listener;
+    private msgHandlerFn;
+    private sockets;
+    constructor(listener: Listener, msgHandlerFn: (msg: Payload) => Promise<any>);
+    /**
+     * 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(): void;
+    /**
+     * 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(): void;
+    /**
+     * 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.
+     */
+    broadcast(msg: Payload): Promise<void>;
+    /**
+     * 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.
+     */
+    private handleNewSocket;
+    /**
+     * 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.
+     */
+    private getPayloadAndTransfers;
+    /**
+     * 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.
+     */
+    private handleSocketMessage;
+}
+//# sourceMappingURL=transport_server.d.ts.map

package/dest/transport/transport_server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport_server.d.ts","sourceRoot":"","sources":["../../src/transport/transport_server.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAInD;;GAEG;AACH,qBAAa,eAAe,CAAC,OAAO;IAGtB,OAAO,CAAC,QAAQ;IAAY,OAAO,CAAC,YAAY;IAF5D,OAAO,CAAC,OAAO,CAAgB;gBAEX,QAAQ,EAAE,QAAQ,EAAU,YAAY,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC,GAAG,CAAC;IAE5F;;;;OAIG;IACH,KAAK;IAKL;;;OAGG;IACH,IAAI;IAIJ;;;;;;;OAOG;IACG,SAAS,CAAC,GAAG,EAAE,OAAO;IAI5B;;;;;;OAMG;IACH,OAAO,CAAC,eAAe;IAcvB;;;;;OAKG;IACH,OAAO,CAAC,sBAAsB;IAe9B;;;;;;;;OAQG;YACW,mBAAmB;CAalC"}

package/dest/transport/transport_server.js

@@ -0,0 +1,101 @@
+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) {
+        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));
+        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() {
+        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 })));
+    }
+    /**
+     * 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 [closingSocket] = this.sockets.splice(socketIndex, 1);
+                closingSocket.close();
+                return;
+            }
+            return await this.handleSocketMessage(socket, msg);
+        });
+        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) {
+        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];
+        }
+        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];
+        }
+        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 }) {
+        try {
+            const data = await this.msgHandlerFn(payload);
+            const [respPayload, transferables] = this.getPayloadAndTransfers(data);
+            const rep = { msgId, payload: respPayload };
+            await socket.send(rep, transferables);
+        }
+        catch (err) {
+            const rep = { msgId, error: err.stack };
+            await socket.send(rep);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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