@aztec-labs/foundation 6.0.0-nightly.20260829

package/dest/timer/timer.js

@@ -0,0 +1,40 @@
+/**
+ * Timer class to measure time intervals in milliseconds and seconds.
+ * Upon instantiation, it stores the current timestamp as the starting point.
+ * The 'ms()' method returns the elapsed time in milliseconds,
+ * while the 's()' method returns the elapsed time in seconds.
+ *
+ * @example
+ * const timer = new Timer();
+ * setTimeout(() =\> \{
+ *   console.log(`Elapsed time: ${timer.ms()} ms`);
+ * \}, 1000);
+ */ export class Timer {
+    start;
+    constructor(){
+        this.start = performance ? performance.now() : Date.now();
+    }
+    /**
+   * Return microseconds.
+   */ us() {
+        return this.ms() * 1000;
+    }
+    /**
+   * Returns the elapsed time in milliseconds since the Timer instance was created.
+   * Provides a simple and convenient way to measure the time duration between two events
+   * or monitor performance of specific code sections.
+   *
+   * @returns The elapsed time in milliseconds.
+   */ ms() {
+        return (performance ? performance.now() : Date.now()) - this.start;
+    }
+    /**
+   * Returns the time elapsed since the Timer instance was created, in seconds.
+   * The value is calculated by subtracting the initial start time from the current time
+   * and dividing the result by 1000 to convert milliseconds to seconds.
+   *
+   * @returns The elapsed time in seconds.
+   */ s() {
+        return this.ms() / 1000;
+    }
+}

package/dest/transport/dispatch/create_dispatch_proxy.d.ts

@@ -0,0 +1,111 @@
+import { type TransferDescriptor } from '../interface/transferable.js';
+import type { TransportClient } from '../transport_client.js';
+/**
+ * Represents a message object for dispatching function calls.
+ * Contains the function name ('fn') and an array of arguments ('args') required to call the target method.
+ */
+export interface DispatchMsg {
+    /** Name of the target method to be called. */
+    fn: string;
+    /** An array of arguments to be passed to the target method. */
+    args: any[];
+}
+/**
+ * FilterOutAttributes type filters out all non-method properties of an object, leaving only the attributes
+ * that are functions. This is useful for creating proxies or wrappers around objects while focusing only
+ * on their methods and ignoring other properties.
+ */
+type FilterOutAttributes<Base> = {
+    [Key in keyof Base]: Base[Key] extends (...any: any) => any ? Base[Key] : never;
+};
+/**
+ * Takes a function type `F` and returns a new function type with the same input parameters as `F`,
+ * but returning a Promise of the original return type of `F`. This is useful for converting sync
+ * functions or functions that take callbacks into a version that returns a Promise.
+ */
+type PromisifyFunction<F extends (...any: any) => any> = (...args: Parameters<F>) => Promise<ReturnType<F>>;
+/**
+ * Transforms the provided object type by converting each of its function properties into their
+ * promise-returning counterparts. If a function property already returns a promise, it remains unchanged.
+ * This is useful when wrapping synchronous methods to return promises in order to standardize the API for
+ * asynchronous operations.
+ *
+ * @typeParam Base - The type of the object whose function properties need to be converted into their
+ *                   promise-returning versions.
+ */
+type Promisify<Base extends {
+    [key: string]: (...any: any) => any;
+}> = {
+    [Key in keyof Base]: ReturnType<Base[Key]> extends Promise<any> ? Base[Key] : PromisifyFunction<Base[Key]>;
+};
+/**
+ * Type that transforms a tuple of types, replacing each type 'T' with either 'T' or a `TransferDescriptor<T>` if 'T' is `Transferable`.
+ * This is useful for handling arguments of functions that may accept both original and transferable representations of objects.
+ */
+type TransferTypes<Tuple extends [...args: any]> = {
+    [Index in keyof Tuple]: Tuple[Index] | (Tuple[Index] extends Transferable ? TransferDescriptor<Tuple[Index]> : never);
+};
+/**
+ * Annoying.
+ * @see https://github.com/microsoft/TypeScript/issues/29919
+ * There's a bug that means we can't map over the tuple or function parameter types to make them transferrable, if
+ * we use the Parameters builtin, and then try to map.
+ * So instead we inline the Parameters builtin and apply the TransferTypes to the parameters within the inline.
+ * Once the above is fixed we could in theory just do:
+ *
+ * type MakeFunctionTransferrable\<TFunction extends (...args: any) =\> any\> = (
+ *   ...args: TransferTypes\<Parameters\<TFunction\>\>
+ * ) =\> ReturnType<TFunction>;
+ */
+type MakeFunctionTransferrable<TFunction extends (...args: any) => any> = (...args: TFunction extends (...args: infer P) => any ? TransferTypes<P> : never) => ReturnType<TFunction>;
+/**
+ * Transferrable type represents a utility type that maps over the provided Base object's methods,
+ * transforming their argument types to support transferable objects. This is useful when dealing
+ * with operations across different environments or threads, such as Web Workers or Node.js processes,
+ * where certain objects need to be transferred instead of being serialized and deserialized.
+ */
+type Transferrable<Base extends {
+    [key: string]: (...any: any) => any;
+}> = {
+    [Key in keyof Base]: MakeFunctionTransferrable<Base[Key]>;
+};
+/**
+ * Proxify is a mapped type that takes an object with functions as its properties and returns
+ * a new object with the same properties, but with each function transformed to return a Promise
+ * and accept Transferable types in place of their original parameters. This type is useful for
+ * creating proxies that communicate over different environments or threads while maintaining
+ * the original class's method signatures, allowing for type-safe interaction with remote instances.
+ */
+export type Proxify<T> = Promisify<Transferrable<FilterOutAttributes<T>>>;
+/**
+ * Creates a proxy object for the provided class, wrapping each method in a request function.
+ * The resulting proxy object allows invoking methods of the original class, but their execution
+ * is delegated to the request function. This is useful when executing methods across different
+ * environments or threads, such as Web Workers or Node.js processes.
+ *
+ * @typeParam T - The type of the class to create a proxy for.
+ * @param class_ - The class constructor to create a proxy for.
+ * @param requestFn - A higher-order function that takes a method name and returns a function
+ *                    with the same signature as the original method, which wraps the actual
+ *                    invocation in a custom logic (e.g., sending a message to another thread).
+ * @returns An object whose methods match those of the original class, but whose execution is
+ *          delegated to the provided request function.
+ */
+export declare function createDispatchProxyFromFn<T>(class_: {
+    new (...args: any[]): T;
+}, requestFn: (fn: string) => (...args: any[]) => Promise<any>): Proxify<T>;
+/**
+ * Creates a proxy for the given class that transparently dispatches method calls over a transport client.
+ * The proxy allows calling methods on remote instances of the class through the provided transport client
+ * while maintaining the correct return types and handling promises. If the class inherits from EventEmitter,
+ * it also handles event emissions through the transport client.
+ *
+ * @param class_ - The constructor function of the class to create the proxy for.
+ * @param transportClient - The TransportClient instance used to handle communication between proxies.
+ * @returns A proxified version of the given class with methods dispatched over the transport client.
+ */
+export declare function createDispatchProxy<T>(class_: {
+    new (...args: any[]): T;
+}, transportClient: TransportClient<DispatchMsg>): Proxify<T>;
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/dest/transport/dispatch/create_dispatch_proxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create_dispatch_proxy.d.ts","sourceRoot":"","sources":["../../../src/transport/dispatch/create_dispatch_proxy.ts"],"names":[],"mappings":"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"}

package/dest/transport/dispatch/create_dispatch_proxy.js

@@ -0,0 +1,59 @@
+import { EventEmitter } from 'events';
+import { isTransferDescriptor } from '../interface/transferable.js';
+/**
+ * Creates a proxy object for the provided class, wrapping each method in a request function.
+ * The resulting proxy object allows invoking methods of the original class, but their execution
+ * is delegated to the request function. This is useful when executing methods across different
+ * environments or threads, such as Web Workers or Node.js processes.
+ *
+ * @typeParam T - The type of the class to create a proxy for.
+ * @param class_ - The class constructor to create a proxy for.
+ * @param requestFn - A higher-order function that takes a method name and returns a function
+ *                    with the same signature as the original method, which wraps the actual
+ *                    invocation in a custom logic (e.g., sending a message to another thread).
+ * @returns An object whose methods match those of the original class, but whose execution is
+ *          delegated to the provided request function.
+ */ export function createDispatchProxyFromFn(class_, requestFn) {
+    const proxy = class_.prototype instanceof EventEmitter ? new EventEmitter() : {};
+    for (const fn of Object.getOwnPropertyNames(class_.prototype)){
+        if (fn === 'constructor') {
+            continue;
+        }
+        proxy[fn] = requestFn(fn);
+    }
+    return proxy;
+}
+/**
+ * Creates a proxy for the given class that transparently dispatches method calls over a transport client.
+ * The proxy allows calling methods on remote instances of the class through the provided transport client
+ * while maintaining the correct return types and handling promises. If the class inherits from EventEmitter,
+ * it also handles event emissions through the transport client.
+ *
+ * @param class_ - The constructor function of the class to create the proxy for.
+ * @param transportClient - The TransportClient instance used to handle communication between proxies.
+ * @returns A proxified version of the given class with methods dispatched over the transport client.
+ */ export function createDispatchProxy(class_, transportClient) {
+    // Create a proxy of class_ that passes along methods over our transportClient
+    const proxy = createDispatchProxyFromFn(class_, (fn)=>(...args)=>{
+            // Pass our proxied function name and arguments over our transport client
+            const transfer = args.reduce((acc, a)=>isTransferDescriptor(a) ? [
+                    ...acc,
+                    ...a.transferables
+                ] : acc, []);
+            args = args.map((a)=>isTransferDescriptor(a) ? a.send : a);
+            return transportClient.request({
+                fn,
+                args
+            }, transfer);
+        });
+    if (proxy instanceof EventEmitter) {
+        // Handle proxied 'emit' calls if our proxy object is an EventEmitter
+        transportClient.on('event_msg', ({ fn, args })=>{
+            if (fn === 'emit') {
+                const [eventName, ...restArgs] = args;
+                proxy.emit(eventName, ...restArgs);
+            }
+        });
+    }
+    return proxy;
+}

package/dest/transport/dispatch/messages.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Represents a request message.
+ * Contains a unique identifier (msgId) and a payload object.
+ */
+export interface RequestMessage<Payload> {
+    /**
+     * A unique identifier for a message.
+     */
+    msgId: number;
+    /**
+     * The data content carried within a message.
+     */
+    payload: Payload;
+}
+/**
+ * Represents a structured response message.
+ * Contains an identifier to match with the corresponding request.
+ */
+export interface ResponseMessage<Payload> {
+    /**
+     * A unique identifier for the message.
+     */
+    msgId: number;
+    /**
+     * The data content carried within the message.
+     */
+    payload?: Payload;
+    /**
+     * An optional error description in case the response contains an error instead of a payload.
+     */
+    error?: string;
+}
+/**
+ * Represents an event-based message in a communication system.
+ * Contains a payload with the relevant data associated with a specific event occurrence.
+ */
+export interface EventMessage<Payload> {
+    /**
+     * The data content associated with a message.
+     */
+    payload: Payload;
+}
+/**
+ * Determines if the given 'msg' is an EventMessage by checking if its 'msgId' property is undefined.
+ * Returns true if the input message is of type EventMessage, otherwise false. This utility function can be used
+ * to differentiate between instances of ResponseMessage and EventMessage that share a common Payload type.
+ *
+ * @param msg - The message object that can be either a ResponseMessage or EventMessage with a specific payload.
+ * @returns A boolean value indicating whether the input message is an EventMessage (true) or not (false).
+ */
+export declare function isEventMessage<Payload>(msg: ResponseMessage<Payload> | EventMessage<Payload>): msg is EventMessage<Payload>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVzc2FnZXMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy90cmFuc3BvcnQvZGlzcGF0Y2gvbWVzc2FnZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7OztHQUdHO0FBQ0gsTUFBTSxXQUFXLGNBQWMsQ0FBQyxPQUFPO0lBQ3JDOztPQUVHO0lBQ0gsS0FBSyxFQUFFLE1BQU0sQ0FBQztJQUNkOztPQUVHO0lBQ0gsT0FBTyxFQUFFLE9BQU8sQ0FBQztDQUNsQjtBQUVEOzs7R0FHRztBQUNILE1BQU0sV0FBVyxlQUFlLENBQUMsT0FBTztJQUN0Qzs7T0FFRztJQUNILEtBQUssRUFBRSxNQUFNLENBQUM7SUFDZDs7T0FFRztJQUNILE9BQU8sQ0FBQyxFQUFFLE9BQU8sQ0FBQztJQUNsQjs7T0FFRztJQUNILEtBQUssQ0FBQyxFQUFFLE1BQU0sQ0FBQztDQUNoQjtBQUVEOzs7R0FHRztBQUNILE1BQU0sV0FBVyxZQUFZLENBQUMsT0FBTztJQUNuQzs7T0FFRztJQUNILE9BQU8sRUFBRSxPQUFPLENBQUM7Q0FDbEI7QUFFRDs7Ozs7OztHQU9HO0FBQ0gsd0JBQWdCLGNBQWMsQ0FBQyxPQUFPLEVBQ3BDLEdBQUcsRUFBRSxlQUFlLENBQUMsT0FBTyxDQUFDLEdBQUcsWUFBWSxDQUFDLE9BQU8sQ0FBQyxHQUNwRCxHQUFHLElBQUksWUFBWSxDQUFDLE9BQU8sQ0FBQyxDQUU5QiJ9

package/dest/transport/dispatch/messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../../src/transport/dispatch/messages.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,WAAW,cAAc,CAAC,OAAO;IACrC;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;IACd;;OAEG;IACH,OAAO,EAAE,OAAO,CAAC;CAClB;AAED;;;GAGG;AACH,MAAM,WAAW,eAAe,CAAC,OAAO;IACtC;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;IACd;;OAEG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;OAEG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;GAGG;AACH,MAAM,WAAW,YAAY,CAAC,OAAO;IACnC;;OAEG;IACH,OAAO,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,OAAO,EACpC,GAAG,EAAE,eAAe,CAAC,OAAO,CAAC,GAAG,YAAY,CAAC,OAAO,CAAC,GACpD,GAAG,IAAI,YAAY,CAAC,OAAO,CAAC,CAE9B"}

package/dest/transport/dispatch/messages.js

@@ -0,0 +1,13 @@
+/**
+ * Represents a request message.
+ * Contains a unique identifier (msgId) and a payload object.
+ */ /**
+ * Determines if the given 'msg' is an EventMessage by checking if its 'msgId' property is undefined.
+ * Returns true if the input message is of type EventMessage, otherwise false. This utility function can be used
+ * to differentiate between instances of ResponseMessage and EventMessage that share a common Payload type.
+ *
+ * @param msg - The message object that can be either a ResponseMessage or EventMessage with a specific payload.
+ * @returns A boolean value indicating whether the input message is an EventMessage (true) or not (false).
+ */ export function isEventMessage(msg) {
+    return msg.msgId === undefined;
+}

package/dest/transport/index.d.ts

@@ -0,0 +1,10 @@
+export * from './dispatch/create_dispatch_proxy.js';
+export * from './dispatch/messages.js';
+export * from './interface/connector.js';
+export * from './interface/listener.js';
+export * from './interface/socket.js';
+export * from './interface/transferable.js';
+export * from './transport_client.js';
+export * from './transport_server.js';
+export * from './node/index.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90cmFuc3BvcnQvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxxQ0FBcUMsQ0FBQztBQUNwRCxjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsNkJBQTZCLENBQUM7QUFDNUMsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsaUJBQWlCLENBQUMifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/transport/index.ts"],"names":[],"mappings":"AAAA,cAAc,qCAAqC,CAAC;AACpD,cAAc,wBAAwB,CAAC;AACvC,cAAc,0BAA0B,CAAC;AACzC,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,iBAAiB,CAAC"}

package/dest/transport/index.js

@@ -0,0 +1,9 @@
+export * from './dispatch/create_dispatch_proxy.js';
+export * from './dispatch/messages.js';
+export * from './interface/connector.js';
+export * from './interface/listener.js';
+export * from './interface/socket.js';
+export * from './interface/transferable.js';
+export * from './transport_client.js';
+export * from './transport_server.js';
+export * from './node/index.js';

package/dest/transport/interface/connector.d.ts

@@ -0,0 +1,8 @@
+import type { Socket } from './socket.js';
+/**
+ * Opens a socket with corresponding TransportListener.
+ */
+export interface Connector {
+    createSocket(): Promise<Socket>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29ubmVjdG9yLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdHJhbnNwb3J0L2ludGVyZmFjZS9jb25uZWN0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsTUFBTSxFQUFFLE1BQU0sYUFBYSxDQUFDO0FBRTFDOztHQUVHO0FBQ0gsTUFBTSxXQUFXLFNBQVM7SUFDeEIsWUFBWSxJQUFJLE9BQU8sQ0FBQyxNQUFNLENBQUMsQ0FBQztDQUNqQyJ9

package/dest/transport/interface/connector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connector.d.ts","sourceRoot":"","sources":["../../../src/transport/interface/connector.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAE1C;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,YAAY,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;CACjC"}

package/dest/transport/interface/connector.js

@@ -0,0 +1,3 @@
+/**
+ * Opens a socket with corresponding TransportListener.
+ */ export { };

package/dest/transport/interface/listener.d.ts

@@ -0,0 +1,12 @@
+import type EventEmitter from 'events';
+import type { Socket } from './socket.js';
+/**
+ * Once opened, an implementation of a TransportListener will emit `new_socket` events as new clients connect.
+ * Possible implementations could include MessageChannels or WebSockets.
+ */
+export interface Listener extends EventEmitter {
+    open(): void;
+    close(): void;
+    on(name: 'new_socket', cb: (client: Socket) => void): this;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGlzdGVuZXIuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy90cmFuc3BvcnQvaW50ZXJmYWNlL2xpc3RlbmVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxZQUFZLE1BQU0sUUFBUSxDQUFDO0FBRXZDLE9BQU8sS0FBSyxFQUFFLE1BQU0sRUFBRSxNQUFNLGFBQWEsQ0FBQztBQUUxQzs7O0dBR0c7QUFDSCxNQUFNLFdBQVcsUUFBUyxTQUFRLFlBQVk7SUFDNUMsSUFBSSxJQUFJLElBQUksQ0FBQztJQUViLEtBQUssSUFBSSxJQUFJLENBQUM7SUFFZCxFQUFFLENBQUMsSUFBSSxFQUFFLFlBQVksRUFBRSxFQUFFLEVBQUUsQ0FBQyxNQUFNLEVBQUUsTUFBTSxLQUFLLElBQUksR0FBRyxJQUFJLENBQUM7Q0FDNUQifQ==

package/dest/transport/interface/listener.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"listener.d.ts","sourceRoot":"","sources":["../../../src/transport/interface/listener.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,YAAY,MAAM,QAAQ,CAAC;AAEvC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAE1C;;;GAGG;AACH,MAAM,WAAW,QAAS,SAAQ,YAAY;IAC5C,IAAI,IAAI,IAAI,CAAC;IAEb,KAAK,IAAI,IAAI,CAAC;IAEd,EAAE,CAAC,IAAI,EAAE,YAAY,EAAE,EAAE,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,GAAG,IAAI,CAAC;CAC5D"}

package/dest/transport/interface/listener.js

@@ -0,0 +1,4 @@
+/**
+ * Once opened, an implementation of a TransportListener will emit `new_socket` events as new clients connect.
+ * Possible implementations could include MessageChannels or WebSockets.
+ */ export { };

package/dest/transport/interface/socket.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Represents one end of a socket connection.
+ * A message sent via `send` will be handled by the corresponding Socket's handler function at the other end.
+ * Implementations could use e.g. MessagePorts for communication between browser workers,
+ * or WebSockets for communication between processes.
+ * If `registerHandler` callback receives `undefined` that signals the other end closed.
+ */
+export interface Socket {
+    send(msg: any, transfer?: Transferable[]): Promise<void>;
+    registerHandler(cb: (msg: any) => any): void;
+    close(): void;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic29ja2V0LmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdHJhbnNwb3J0L2ludGVyZmFjZS9zb2NrZXQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBQ0gsTUFBTSxXQUFXLE1BQU07SUFDckIsSUFBSSxDQUFDLEdBQUcsRUFBRSxHQUFHLEVBQUUsUUFBUSxDQUFDLEVBQUUsWUFBWSxFQUFFLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDO0lBRXpELGVBQWUsQ0FBQyxFQUFFLEVBQUUsQ0FBQyxHQUFHLEVBQUUsR0FBRyxLQUFLLEdBQUcsR0FBRyxJQUFJLENBQUM7SUFFN0MsS0FBSyxJQUFJLElBQUksQ0FBQztDQUNmIn0=

package/dest/transport/interface/socket.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"socket.d.ts","sourceRoot":"","sources":["../../../src/transport/interface/socket.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,WAAW,MAAM;IACrB,IAAI,CAAC,GAAG,EAAE,GAAG,EAAE,QAAQ,CAAC,EAAE,YAAY,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEzD,eAAe,CAAC,EAAE,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,GAAG,GAAG,IAAI,CAAC;IAE7C,KAAK,IAAI,IAAI,CAAC;CACf"}

package/dest/transport/interface/socket.js

@@ -0,0 +1,7 @@
+/**
+ * Represents one end of a socket connection.
+ * A message sent via `send` will be handled by the corresponding Socket's handler function at the other end.
+ * Implementations could use e.g. MessagePorts for communication between browser workers,
+ * or WebSockets for communication between processes.
+ * If `registerHandler` callback receives `undefined` that signals the other end closed.
+ */ export { };

package/dest/transport/interface/transferable.d.ts

@@ -0,0 +1,68 @@
+declare const $transferable: unique symbol;
+/**
+ * Represents a descriptor for transferable objects in multi-threaded environments.
+ * Provides a structure for marking certain objects as transferable and managing the ownership transfer
+ * between threads, particularly useful when working with Web Workers.
+ */
+export interface TransferDescriptor<T = any> {
+    /**
+     * A unique symbol indicating that an object is a TransferDescriptor.
+     */
+    [$transferable]: true;
+    /**
+     * The transferable data to be sent between threads.
+     */
+    send: T;
+    /**
+     * An array of objects that can be transferred between threads without serialization and deserialization.
+     */
+    transferables: Transferable[];
+}
+/**
+ * Determines whether a given object is a TransferDescriptor.
+ * A TransferDescriptor is an object with a [$transferable] property set to true and used for
+ * transferring ownership of transferable objects between threads.
+ * This function checks if the input object has the required properties to be considered
+ * a valid TransferDescriptor.
+ *
+ * @param thing - The object to be checked for being a TransferDescriptor.
+ * @returns True if the object is a TransferDescriptor, false otherwise.
+ */
+export declare function isTransferDescriptor(thing: any): thing is TransferDescriptor;
+/**
+ * Mark a transferable object as such, so it will no be serialized and
+ * deserialized on messaging with the main thread, but to transfer
+ * ownership of it to the receiving thread.
+ *
+ * Only works with array buffers, message ports and few more special
+ * types of objects, but it's much faster than serializing and
+ * deserializing them.
+ *
+ * Note:
+ * The transferable object cannot be accessed by this thread again
+ * unless the receiving thread transfers it back again!
+ *
+ * @param transferable - Array buffer, message port or similar.
+ * @see https://developers.google.com/web/updates/2011/12/Transferable-Objects-Lightning-Fast
+ */
+export declare function Transfer<T>(transferable: Transferable): TransferDescriptor<T>;
+/**
+ * Mark transferable objects within an arbitrary object or array as
+ * being a transferable object. They will then not be serialized
+ * and deserialized on messaging with the main thread, but ownership
+ * of them will be transferred to the receiving thread.
+ *
+ * Only array buffers, message ports and few more special types of
+ * objects can be transferred, but it's much faster than serializing and
+ * deserializing them.
+ *
+ * Note:
+ * The transferable object cannot be accessed by this thread again
+ * unless the receiving thread transfers it back again!
+ *
+ * @param transferable - Array buffer, message port or similar.
+ * @see https://developers.google.com/web/updates/2011/12/Transferable-Objects-Lightning-Fast
+ */
+export declare function Transfer<T>(payload: T, transferables: Transferable[]): TransferDescriptor<T>;
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhbnNmZXJhYmxlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvdHJhbnNwb3J0L2ludGVyZmFjZS90cmFuc2ZlcmFibGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsUUFBQSxNQUFNLGFBQWEsZUFBZ0MsQ0FBQztBQUVwRDs7OztHQUlHO0FBQ0gsTUFBTSxXQUFXLGtCQUFrQixDQUFDLENBQUMsR0FBRyxHQUFHO0lBQ3pDOztPQUVHO0lBQ0gsQ0FBQyxhQUFhLENBQUMsRUFBRSxJQUFJLENBQUM7SUFDdEI7O09BRUc7SUFDSCxJQUFJLEVBQUUsQ0FBQyxDQUFDO0lBQ1I7O09BRUc7SUFDSCxhQUFhLEVBQUUsWUFBWSxFQUFFLENBQUM7Q0FDL0I7QUF5QkQ7Ozs7Ozs7OztHQVNHO0FBQ0gsd0JBQWdCLG9CQUFvQixDQUFDLEtBQUssRUFBRSxHQUFHLEdBQUcsS0FBSyxJQUFJLGtCQUFrQixDQUU1RTtBQUVEOzs7Ozs7Ozs7Ozs7Ozs7R0FlRztBQUNILHdCQUFnQixRQUFRLENBQUMsQ0FBQyxFQUFFLFlBQVksRUFBRSxZQUFZLEdBQUcsa0JBQWtCLENBQUMsQ0FBQyxDQUFDLENBQUM7QUFFL0U7Ozs7Ozs7Ozs7Ozs7Ozs7R0FnQkc7QUFDSCx3QkFBZ0IsUUFBUSxDQUFDLENBQUMsRUFBRSxPQUFPLEVBQUUsQ0FBQyxFQUFFLGFBQWEsRUFBRSxZQUFZLEVBQUUsR0FBRyxrQkFBa0IsQ0FBQyxDQUFDLENBQUMsQ0FBQyJ9

package/dest/transport/interface/transferable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transferable.d.ts","sourceRoot":"","sources":["../../../src/transport/interface/transferable.ts"],"names":[],"mappings":"AAAA,QAAA,MAAM,aAAa,eAAgC,CAAC;AAEpD;;;;GAIG;AACH,MAAM,WAAW,kBAAkB,CAAC,CAAC,GAAG,GAAG;IACzC;;OAEG;IACH,CAAC,aAAa,CAAC,EAAE,IAAI,CAAC;IACtB;;OAEG;IACH,IAAI,EAAE,CAAC,CAAC;IACR;;OAEG;IACH,aAAa,EAAE,YAAY,EAAE,CAAC;CAC/B;AAyBD;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,GAAG,GAAG,KAAK,IAAI,kBAAkB,CAE5E;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,YAAY,EAAE,YAAY,GAAG,kBAAkB,CAAC,CAAC,CAAC,CAAC;AAE/E;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,aAAa,EAAE,YAAY,EAAE,GAAG,kBAAkB,CAAC,CAAC,CAAC,CAAC"}

package/dest/transport/interface/transferable.js

@@ -0,0 +1,63 @@
+const $transferable = Symbol('thread.transferable');
+/**
+ * Determines if the provided object is transferable.
+ * Transferable objects are instances of a certain set of classes,
+ * such as ArrayBuffer or MessagePort, which can be transferred between
+ * different execution contexts (e.g., workers) without incurring the
+ * overhead of serialization and deserialization.
+ *
+ * This function checks for the basic transferable criteria, but does not
+ * perform an exhaustive check for all possible transferable types. As new
+ * transferable types are added to JavaScript, they may be supported without
+ * needing to modify this function.
+ *
+ * @param thing - The object to check for transferability.
+ * @returns A boolean indicating whether the object is transferable.
+ */ function isTransferable(thing) {
+    if (!thing || typeof thing !== 'object') {
+        return false;
+    }
+    // Don't check too thoroughly, since the list of transferable things in JS might grow over time
+    return true;
+}
+/**
+ * Determines whether a given object is a TransferDescriptor.
+ * A TransferDescriptor is an object with a [$transferable] property set to true and used for
+ * transferring ownership of transferable objects between threads.
+ * This function checks if the input object has the required properties to be considered
+ * a valid TransferDescriptor.
+ *
+ * @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) {
+    return thing && typeof thing === 'object' && thing[$transferable];
+}
+/**
+ * Create a TransferDescriptor for transferable objects within an arbitrary object or array, allowing
+ * them to be transferred between threads instead of being serialized and deserialized.
+ * This method is particularly useful when working with Web Workers and other multi-threaded environments.
+ * Transferable objects include ArrayBuffers, MessagePorts, and a few other special types.
+ * Note that after transferring, the original thread will lose access to the transferred object unless
+ * it's transferred back again.
+ *
+ * @param payload - The transferable object or an object containing transferable properties.
+ * @param transferables - Optional array of Transferable objects found in the payload. If not provided,
+ *                        the payload itself should be a Transferable object.
+ * @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) {
+    if (!transferables) {
+        if (!isTransferable(payload)) {
+            throw Error();
+        }
+        transferables = [
+            payload
+        ];
+    }
+    return {
+        [$transferable]: true,
+        send: payload,
+        transferables
+    };
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/transport/node/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC"}

package/dest/transport/node/index.js

@@ -0,0 +1,2 @@
+export * from './node_connector.js';
+export * from './node_listener.js';

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

@@ -0,0 +1,27 @@
+import type { Worker } from 'worker_threads';
+import type { 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=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm9kZV9jb25uZWN0b3IuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy90cmFuc3BvcnQvbm9kZS9ub2RlX2Nvbm5lY3Rvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxNQUFNLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUU3QyxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUMzRCxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSw0QkFBNEIsQ0FBQztBQUVqRTs7Ozs7Ozs7OztHQVVHO0FBQ0gscUJBQWEsYUFBYyxZQUFXLFNBQVM7SUFDakMsT0FBTyxDQUFDLE1BQU07SUFBMUIsWUFBb0IsTUFBTSxFQUFFLE1BQU0sRUFBSTtJQUV0Qzs7Ozs7O09BTUc7SUFDSCxZQUFZLGlDQUVYO0NBQ0YifQ==

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,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAE7C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAEjE;;;;;;;;;;GAUG;AACH,qBAAa,aAAc,YAAW,SAAS;IACjC,OAAO,CAAC,MAAM;IAA1B,YAAoB,MAAM,EAAE,MAAM,EAAI;IAEtC;;;;;;OAMG;IACH,YAAY,iCAEX;CACF"}

package/dest/transport/node/node_connector.js

@@ -0,0 +1,26 @@
+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 {
+    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() {
+        return Promise.resolve(new NodeConnectorSocket(this.worker));
+    }
+}