@aztec/foundation 0.74.0 → 0.75.0-commit.c03ba01a2a4122e43e90d5133ba017e54b90e9d2

package/dest/timer/timer.d.ts

@@ -1,37 +0,0 @@
-/**
- * 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 declare class Timer {
-    private start;
-    constructor();
-    /**
-     * Return microseconds.
-     */
-    us(): number;
-    /**
-     * 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(): number;
-    /**
-     * 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(): number;
-}
-//# sourceMappingURL=timer.d.ts.map

package/dest/timer/timer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"timer.d.ts","sourceRoot":"","sources":["../../src/timer/timer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,qBAAa,KAAK;IAChB,OAAO,CAAC,KAAK,CAAS;;IAMtB;;OAEG;IACI,EAAE;IAIT;;;;;;OAMG;IACI,EAAE;IAIT;;;;;;OAMG;IACI,CAAC;CAGT"}

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

@@ -1,5 +0,0 @@
-export * from './worker_connector.js';
-export * from './worker_listener.js';
-export * from './shared_worker_connector.js';
-export * from './shared_worker_listener.js';
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/transport/browser/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,6BAA6B,CAAC"}

package/dest/transport/browser/message_port_socket.d.ts

@@ -1,37 +0,0 @@
-import { type Socket } from '../interface/socket.js';
-/**
- * An implementation of a TransportSocket using MessagePorts.
- */
-export declare class MessagePortSocket implements Socket {
-    private port;
-    constructor(port: MessagePort);
-    /**
-     * Send a message to the connected MessagePort, optionally transferring ownership of certain objects.
-     * The 'msg' parameter can be any structured data type and will be sent to the other end of the MessagePort.
-     * The optional 'transfer' parameter is an array of Transferable objects whose ownership will be transferred,
-     * making them inaccessible on the sending side. This can improve performance for large data transfers.
-     *
-     * @param msg - The message to be sent through the MessagePort.
-     * @param transfer - An optional array of Transferable objects to transfer ownership.
-     * @returns A Promise that resolves when the message has been sent.
-     */
-    send(msg: any, transfer?: Transferable[]): Promise<void>;
-    /**
-     * Register a callback function to handle incoming messages from the MessagePort.
-     * The provided callback will be invoked with the message data whenever a new message arrives.
-     * Note that only one callback can be registered at a time. Subsequent calls to this method
-     * will overwrite the previously registered callback.
-     *
-     * @param cb - The callback function to handle incoming messages.
-     */
-    registerHandler(cb: (msg: any) => any): void;
-    /**
-     * Close the MessagePort, unregister the message handler, and send an undefined message.
-     * The 'close' function is useful for gracefully shutting down a connection between two
-     * endpoints by sending an undefined message as an indication of disconnection before
-     * closing the port. After calling this method, the MessagePortSocket instance should not
-     * be used again.
-     */
-    close(): void;
-}
-//# sourceMappingURL=message_port_socket.d.ts.map

package/dest/transport/browser/message_port_socket.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"message_port_socket.d.ts","sourceRoot":"","sources":["../../../src/transport/browser/message_port_socket.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAErD;;GAEG;AACH,qBAAa,iBAAkB,YAAW,MAAM;IAClC,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;;;;;;OAMG;IACH,KAAK;CAKN"}

package/dest/transport/browser/shared_worker_connector.d.ts

@@ -1,19 +0,0 @@
-import { type Connector } from '../interface/connector.js';
-import { MessagePortSocket } from './message_port_socket.js';
-/**
- * SharedWorkerConnector is an implementation of the Connector interface, specifically for SharedWorkers.
- * It enables the creation of MessagePortSockets that communicate with a shared worker and allow
- * multiple scripts to communicate with the worker using the same connection.
- */
-export declare class SharedWorkerConnector implements Connector {
-    private worker;
-    constructor(worker: SharedWorker);
-    /**
-     * Creates a new MessagePortSocket instance using the SharedWorker's port.
-     * This method allows for easy creation of sockets to communicate with the SharedWorker.
-     *
-     * @returns A Promise that resolves to a new MessagePortSocket instance.
-     */
-    createSocket(): Promise<MessagePortSocket>;
-}
-//# sourceMappingURL=shared_worker_connector.d.ts.map

package/dest/transport/browser/shared_worker_connector.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"shared_worker_connector.d.ts","sourceRoot":"","sources":["../../../src/transport/browser/shared_worker_connector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAE7D;;;;GAIG;AACH,qBAAa,qBAAsB,YAAW,SAAS;IACzC,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,YAAY;IAExC;;;;;OAKG;IACH,YAAY;CAGb"}

package/dest/transport/browser/shared_worker_listener.d.ts

@@ -1,38 +0,0 @@
-/// <reference types="node" resolution-mode="require"/>
-import EventEmitter from 'events';
-import { type Listener } from '../interface/listener.js';
-/**
- * Represents the global scope of a Shared Worker.
- * Provides functionality to handle incoming connections and manage communication with other scripts
- * running in a shared context, enabling concurrent access and efficient resource sharing among those scripts.
- */
-declare interface SharedWorkerGlobalScope {
-    /**
-     * Event handler for new connections to the Shared Worker.
-     */
-    onconnect: (...args: any) => any;
-}
-/**
- * SharedWorkerListener is an extension of the EventEmitter class that implements the Listener interface.
- * It provides functionality to handle incoming messages from a shared worker and emit events for new sockets
- * created in response to these incoming connections. This class is meant to be used in the context of managing
- * MessagePort connections within the SharedWorkerGlobalScope.
- */
-export declare class SharedWorkerListener extends EventEmitter implements Listener {
-    private worker;
-    constructor(worker: SharedWorkerGlobalScope);
-    /**
-     * Initializes the shared worker listener by assigning the 'handleMessageEvent' method as the event handler
-     * for the 'onconnect' event of the SharedWorkerGlobalScope. The 'handleMessageEvent' function will be called
-     * whenever a new connection is established with the shared worker.
-     */
-    open(): void;
-    /**
-     * Closes the SharedWorkerListener by detaching the 'onconnect' event handler.
-     * This stops the listener from emitting new sockets on incoming connections.
-     */
-    close(): void;
-    private handleMessageEvent;
-}
-export {};
-//# sourceMappingURL=shared_worker_listener.d.ts.map

package/dest/transport/browser/shared_worker_listener.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"shared_worker_listener.d.ts","sourceRoot":"","sources":["../../../src/transport/browser/shared_worker_listener.ts"],"names":[],"mappings":";AAAA,OAAO,YAAY,MAAM,QAAQ,CAAC;AAElC,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAGzD;;;;GAIG;AACH,OAAO,WAAW,uBAAuB;IACvC;;OAEG;IACH,SAAS,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,KAAK,GAAG,CAAC;CAClC;AAED;;;;;GAKG;AACH,qBAAa,oBAAqB,SAAQ,YAAa,YAAW,QAAQ;IAC5D,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,uBAAuB;IAInD;;;;OAIG;IACH,IAAI;IAIJ;;;OAGG;IACH,KAAK;IAIL,OAAO,CAAC,kBAAkB,CAMxB;CACH"}

package/dest/transport/browser/worker_connector.d.ts

@@ -1,26 +0,0 @@
-import { type Connector } from '../interface/connector.js';
-import { MessagePortSocket } from './message_port_socket.js';
-/**
- * WorkerConnector is a class implementing the Connector interface for creating communication sockets
- * with Web Workers. It allows to establish a connection with the worker and create MessagePortSockets
- * using MessageChannels, enabling seamless communication between the main thread and worker threads.
- *
- * @example
- * const worker = new Worker('./myWorker.js');
- * const connector = new WorkerConnector(worker);
- * const socket = await connector.createSocket();
- * socket.send('Hello, worker!');
- */
-export declare class WorkerConnector implements Connector {
-    private worker;
-    constructor(worker: Worker);
-    /**
-     * Creates a new MessagePortSocket instance by establishing a connection between the Worker and the main thread.
-     * A MessageChannel is created, and one of its ports is sent to the Worker using postMessage.
-     * The other port is used to create a new MessagePortSocket which is then returned as a Promise.
-     *
-     * @returns A Promise that resolves to a new MessagePortSocket instance.
-     */
-    createSocket(): Promise<MessagePortSocket>;
-}
-//# sourceMappingURL=worker_connector.d.ts.map

package/dest/transport/browser/worker_connector.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"worker_connector.d.ts","sourceRoot":"","sources":["../../../src/transport/browser/worker_connector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAC3D,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAE7D;;;;;;;;;;GAUG;AACH,qBAAa,eAAgB,YAAW,SAAS;IACnC,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,MAAM;IAElC;;;;;;OAMG;IACH,YAAY;CAKb"}

package/dest/transport/browser/worker_listener.d.ts

@@ -1,39 +0,0 @@
-/// <reference types="node" resolution-mode="require"/>
-import EventEmitter from 'events';
-import { type Listener } from '../interface/listener.js';
-/**
- * Represents a DedicatedWorkerGlobalScope, which is the global execution context for a dedicated worker.
- * Provides properties and methods to manage the worker's lifecycle and communication with other threads or workers.
- */
-declare interface DedicatedWorkerGlobalScope {
-    /**
-     * Handler for incoming messages from other threads or workers.
-     */
-    onmessage: any;
-}
-/**
- * WorkerListener is a class that extends EventEmitter and implements the Listener interface.
- * It listens for incoming connections on a dedicated worker global scope, and emits a 'new_socket' event
- * with a MessagePortSocket instance for each new connection. This allows applications to communicate
- * with other workers or main thread through the MessagePortSocket abstraction.
- *
- * The open() method starts listening for incoming connections, while the close() method stops it.
- */
-export declare class WorkerListener extends EventEmitter implements Listener {
-    private worker;
-    constructor(worker: DedicatedWorkerGlobalScope);
-    /**
-     * Initializes the WorkerListener by setting the 'onmessage' event handler of the worker.
-     * The 'onmessage' event will be triggered when the worker receives a message, and it will then
-     * call the handleMessageEvent method to handle incoming connections.
-     */
-    open(): void;
-    /**
-     * Close the worker listener by removing the 'onmessage' event handler.
-     * This method effectively stops the WorkerListener from reacting to new incoming messages.
-     */
-    close(): void;
-    private handleMessageEvent;
-}
-export {};
-//# sourceMappingURL=worker_listener.d.ts.map

package/dest/transport/browser/worker_listener.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"worker_listener.d.ts","sourceRoot":"","sources":["../../../src/transport/browser/worker_listener.ts"],"names":[],"mappings":";AAAA,OAAO,YAAY,MAAM,QAAQ,CAAC;AAElC,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAGzD;;;GAGG;AACH,OAAO,WAAW,0BAA0B;IAC1C;;OAEG;IACH,SAAS,EAAE,GAAG,CAAC;CAChB;AAED;;;;;;;GAOG;AACH,qBAAa,cAAe,SAAQ,YAAa,YAAW,QAAQ;IACtD,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,0BAA0B;IAItD;;;;OAIG;IACH,IAAI;IAIJ;;;OAGG;IACH,KAAK;IAIL,OAAO,CAAC,kBAAkB,CAMxB;CACH"}

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

@@ -1,25 +0,0 @@
-/**
- * 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[];
-}
-/**
- * Creates a dispatch function that calls the target's specified method with provided arguments.
- * The created dispatch function takes a DispatchMsg object as input, which contains the name of
- * the method to be called ('fn') and an array of arguments to be passed to the method ('args').
- *
- * @param targetFn - A function that returns the target object containing the methods to be dispatched.
- * @param log - Optional logging function for debugging purposes.
- * @returns A dispatch function that accepts a DispatchMsg object and calls the target's method with provided arguments.
- */
-export declare function createDispatchFn(targetFn: () => any, log?: import("../../log/pino-logger.js").Logger): ({ fn, args }: DispatchMsg) => Promise<any>;
-//# sourceMappingURL=create_dispatch_fn.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"create_dispatch_fn.d.ts","sourceRoot":"","sources":["../../../src/transport/dispatch/create_dispatch_fn.ts"],"names":[],"mappings":"AAIA;;;GAGG;AACH,MAAM,WAAW,WAAW;IAC1B;;OAEG;IACH,EAAE,EAAE,MAAM,CAAC;IACX;;OAEG;IACH,IAAI,EAAE,GAAG,EAAE,CAAC;CACb;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,EAAE,GAAG,4CAAsC,kBACjE,WAAW,kBAKxC"}

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

@@ -1,102 +0,0 @@
-import { type TransferDescriptor } from '../interface/transferable.js';
-import { type TransportClient } from '../transport_client.js';
-import { type DispatchMsg } from './create_dispatch_fn.js';
-/**
- * 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=create_dispatch_proxy.d.ts.map

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

@@ -1 +0,0 @@
-{"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/messages.d.ts

@@ -1,52 +0,0 @@
-/**
- * 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=messages.d.ts.map

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

@@ -1 +0,0 @@
-{"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/index.d.ts

@@ -1,12 +0,0 @@
-export * from './dispatch/create_dispatch_fn.js';
-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 './browser/index.js';
-export * from './node/index.js';
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/transport/index.ts"],"names":[],"mappings":"AAAA,cAAc,kCAAkC,CAAC;AACjD,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,oBAAoB,CAAC;AACnC,cAAc,iBAAiB,CAAC"}

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

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

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

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

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

@@ -1,13 +0,0 @@
-/// <reference types="node" resolution-mode="require"/>
-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=listener.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"listener.d.ts","sourceRoot":"","sources":["../../../src/transport/interface/listener.ts"],"names":[],"mappings":";AAAA,OAAO,KAAK,YAAY,MAAM,QAAQ,CAAC;AAEvC,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,aAAa,CAAC;AAE1C;;;GAGG;AACH,MAAM,WAAW,QAAS,SAAQ,YAAY;IAE5C,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/socket.d.ts

@@ -1,13 +0,0 @@
-/**
- * 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=socket.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"socket.d.ts","sourceRoot":"","sources":["../../../src/transport/interface/socket.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,WAAW,MAAM;IAErB,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/transferable.d.ts

@@ -1,68 +0,0 @@
-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=transferable.d.ts.map

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

@@ -1 +0,0 @@
-{"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/node/index.d.ts

@@ -1,3 +0,0 @@
-export * from './node_connector.js';
-export * from './node_listener.js';
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"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/node_connector.d.ts

@@ -1,28 +0,0 @@
-/// <reference types="node" resolution-mode="require"/>
-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=node_connector.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"node_connector.d.ts","sourceRoot":"","sources":["../../../src/transport/node/node_connector.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAE7C,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,2BAA2B,CAAC;AAC3D,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"}