@dynamic-labs/message-transport 4.0.0-alpha.0 → 4.0.0-alpha.10

package/src/messageTypes/UserInterfaceModuleMessages.cjs

@@ -0,0 +1,12 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const userInterfaceEventNames = [
+    'authFlowCancelled',
+    'authFlowClosed',
+    'authFlowOpened',
+];
+
+exports.userInterfaceEventNames = userInterfaceEventNames;

package/src/messageTypes/UserInterfaceModuleMessages.d.ts

@@ -1,8 +1,14 @@
 export type UserInterfaceModuleMessages = {
     openUserProfile: () => void;
+    hideUserProfile: () => void;
     openAuthFlow: () => void;
+    hideAuthFlow: () => void;
     /** Opens the secret key export for embedded wallets */
     revealEmbeddedWalletKey: (params: {
         type: 'recovery-phrase' | 'private-key';
     }) => void;
+    authFlowCancelled: () => void;
+    authFlowClosed: () => void;
+    authFlowOpened: () => void;
 };
+export declare const userInterfaceEventNames: ("authFlowCancelled" | "authFlowClosed" | "authFlowOpened")[];

package/src/messageTypes/UserInterfaceModuleMessages.js

@@ -0,0 +1,8 @@
+'use client'
+const userInterfaceEventNames = [
+    'authFlowCancelled',
+    'authFlowClosed',
+    'authFlowOpened',
+];
+
+export { userInterfaceEventNames };

package/src/messageTypes/WalletsModuleMessages.cjs

@@ -0,0 +1,12 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const userWalletsEventNames = [
+    'messageSigned',
+    'walletAdded',
+    'walletRemoved',
+];
+
+exports.userWalletsEventNames = userWalletsEventNames;

package/src/messageTypes/WalletsModuleMessages.d.ts

@@ -27,4 +27,33 @@ export type WalletsModuleMessages = {
     setPrimary: (params: {
         walletId: string;
     }) => Promise<void>;
+    onWalletEvent: (params: WalletEventArguments & {
+        walletId: string;
+    }) => void;
+    handleConnectedWallet: (wallet: Partial<BaseWallet>) => Promise<boolean>;
+    messageSigned: (params: {
+        messageToSign: string;
+        signedMessage: string;
+    }) => void;
+    walletAdded: (params: {
+        wallet: BaseWallet;
+        userWallets: BaseWallet[];
+    }) => void;
+    walletRemoved: (params: {
+        wallet: BaseWallet;
+        userWallets: BaseWallet[];
+    }) => void;
+};
+export type WalletEvents = {
+    chainChange: (props: {
+        chain: string;
+    }) => void;
 };
+type WalletEventArguments = {
+    [E in keyof WalletEvents]: {
+        event: E;
+        eventParams: Parameters<WalletEvents[E]>;
+    };
+}[keyof WalletEvents];
+export declare const userWalletsEventNames: ("messageSigned" | "walletAdded" | "walletRemoved")[];
+export {};

package/src/messageTypes/WalletsModuleMessages.js

@@ -0,0 +1,8 @@
+'use client'
+const userWalletsEventNames = [
+    'messageSigned',
+    'walletAdded',
+    'walletRemoved',
+];
+
+export { userWalletsEventNames };

package/src/messageTypes/ZeroDevExtensionMessages.d.ts

@@ -0,0 +1,10 @@
+export type KernelAccountSettings = {
+    entryPointAddress: string;
+    chainId: number;
+    ecdsaProviderType: string | null;
+    kernelVersion: string;
+    projectId: string;
+};
+export type ZeroDevExtensionMessages = {
+    getKernelAccountSettings: () => Promise<KernelAccountSettings>;
+};

package/src/messageTypes/index.d.ts

@@ -1,3 +1,4 @@
+export * from './AccountAbstractionMessages';
 export * from './AuthModuleMessages';
 export * from './ConsoleMessages';
 export * from './EmbeddedWalletsModuleMessages';
@@ -8,9 +9,12 @@ export * from './NetworksModuleMessages';
 export * from './OtpMessages';
 export * from './PasskeyMessages';
 export * from './PlatformServiceMessages';
+export * from './ProjectSettingsMessages';
 export * from './SdkModuleMessages';
+export * from './SecureStorageMessages';
 export * from './SocialAuthModuleMessages';
 export * from './SolanaMessages';
 export * from './UserInterfaceModuleMessages';
 export * from './WalletsModuleMessages';
 export * from './WebViewVisibilityMessages';
+export * from './ZeroDevExtensionMessages';

package/src/requestChannel/createRequestChannelMessageSender/createRequestChannelMessageSender.cjs

@@ -0,0 +1,43 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var utils = require('../utils/utils.cjs');
+
+const createRequestChannelMessageSender = ({ requestType, messageSessionId, timeoutMap, onReceiveAck, messageTransport, onTimeout, params, }) => {
+    const ackMessageType = utils.getAckMessageType(requestType);
+    const message = {
+        args: params,
+        messageSessionId,
+        type: requestType,
+    };
+    // We must listen for acks
+    const handleAckMessage = ({ messageSessionId: incomingSessionId, type: incomingType, }) => {
+        if (incomingSessionId !== messageSessionId ||
+            incomingType !== ackMessageType)
+            return;
+        clearTimeout(timeoutMap[messageSessionId]);
+        delete timeoutMap[messageSessionId];
+        onReceiveAck === null || onReceiveAck === void 0 ? void 0 : onReceiveAck();
+    };
+    const sendMessage = () => {
+        const startTimer = () => {
+            const timeoutTimer = setTimeout(onTimeout, utils.TIMEOUT_DURATION);
+            timeoutMap[messageSessionId] = timeoutTimer;
+        };
+        // If this message transport is currently blocked, we must only start
+        // the timeout once the message is actually emitted
+        if ('isBlocked' in messageTransport && messageTransport.isBlocked) {
+            messageTransport.emit(message, { onEmit: startTimer });
+            return;
+        }
+        // Now we emit the event to set off the request
+        messageTransport.emit(message);
+        // We start the timer immediately since the message was not blocked
+        startTimer();
+    };
+    return { handleAckMessage, sendMessage };
+};
+
+exports.createRequestChannelMessageSender = createRequestChannelMessageSender;

package/src/requestChannel/createRequestChannelMessageSender/createRequestChannelMessageSender.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="node" />
+import { MessageTransportData, WithBlock } from '../../messageTransport';
+import { MessageTransportWithDefaultOrigin } from '../../messageTransport/decorators/applyDefaultMessageOrigin/applyDefaultMessageOrigin';
+import { RequestTypes } from '../types';
+type RequestChannelMessageSenderParams<T extends RequestTypes, K extends Extract<keyof T, string>> = {
+    requestType: K;
+    messageSessionId: string;
+    timeoutMap: Record<string, NodeJS.Timer>;
+    onReceiveAck?: VoidFunction;
+    onTimeout: VoidFunction;
+    messageTransport: MessageTransportWithDefaultOrigin | WithBlock<MessageTransportWithDefaultOrigin>;
+    params: Parameters<T[K]>;
+};
+export declare const createRequestChannelMessageSender: <T extends RequestTypes, K extends Extract<keyof T, string>>({ requestType, messageSessionId, timeoutMap, onReceiveAck, messageTransport, onTimeout, params, }: RequestChannelMessageSenderParams<T, K>) => {
+    handleAckMessage: ({ messageSessionId: incomingSessionId, type: incomingType, }: MessageTransportData) => void;
+    sendMessage: () => void;
+};
+export {};

package/src/requestChannel/createRequestChannelMessageSender/createRequestChannelMessageSender.js

@@ -0,0 +1,39 @@
+'use client'
+import { getAckMessageType, TIMEOUT_DURATION } from '../utils/utils.js';
+
+const createRequestChannelMessageSender = ({ requestType, messageSessionId, timeoutMap, onReceiveAck, messageTransport, onTimeout, params, }) => {
+    const ackMessageType = getAckMessageType(requestType);
+    const message = {
+        args: params,
+        messageSessionId,
+        type: requestType,
+    };
+    // We must listen for acks
+    const handleAckMessage = ({ messageSessionId: incomingSessionId, type: incomingType, }) => {
+        if (incomingSessionId !== messageSessionId ||
+            incomingType !== ackMessageType)
+            return;
+        clearTimeout(timeoutMap[messageSessionId]);
+        delete timeoutMap[messageSessionId];
+        onReceiveAck === null || onReceiveAck === void 0 ? void 0 : onReceiveAck();
+    };
+    const sendMessage = () => {
+        const startTimer = () => {
+            const timeoutTimer = setTimeout(onTimeout, TIMEOUT_DURATION);
+            timeoutMap[messageSessionId] = timeoutTimer;
+        };
+        // If this message transport is currently blocked, we must only start
+        // the timeout once the message is actually emitted
+        if ('isBlocked' in messageTransport && messageTransport.isBlocked) {
+            messageTransport.emit(message, { onEmit: startTimer });
+            return;
+        }
+        // Now we emit the event to set off the request
+        messageTransport.emit(message);
+        // We start the timer immediately since the message was not blocked
+        startTimer();
+    };
+    return { handleAckMessage, sendMessage };
+};
+
+export { createRequestChannelMessageSender };

package/src/requestChannel/createRequestChannelMessageSender/index.d.ts

@@ -0,0 +1 @@
+export * from './createRequestChannelMessageSender';

package/src/requestChannel/index.d.ts

@@ -1 +1,2 @@
 export * from './requestChannel';
+export * from './types';

package/src/requestChannel/requestChannel.cjs

@@ -4,14 +4,12 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var _tslib = require('../../_virtual/_tslib.cjs');
+var isSerializedError = require('../utils/isSerializedError/isSerializedError.cjs');
 var parseErrorFromTransport = require('../utils/parseErrorFromTransport/parseErrorFromTransport.cjs');
 var serializeErrorForTransport = require('../utils/serializeErrorForTransport/serializeErrorForTransport.cjs');
-var isSerializedError = require('../utils/isSerializedError/isSerializedError.cjs');
+var createRequestChannelMessageSender = require('./createRequestChannelMessageSender/createRequestChannelMessageSender.cjs');
+var utils = require('./utils/utils.cjs');
 
-/** Given a request event name, returns the event name for its resolve */
-const getResolveMessageType = (type) => `${type}__resolve`;
-/** Given a request event name, returns the event name for its reject */
-const getRejectMessageType = (type) => `${type}__reject`;
 /**
  * Allows handling and submitting requests to and from a webview.
  * Requests are messages that (can) expect some response.
@@ -37,22 +35,43 @@ const createRequestChannel = (messageTransport) => {
     const idPrefix = Math.random().toString();
     /** Always returns a different string */
     const getUniqueId = () => `${idPrefix}-${uniqueIdCounter++}`;
+    /** Maps a request's session ID to its time out timer */
+    const timeoutMap = {};
     return {
-        emit: (requestName, ...params) => {
+        emit: (requestType, ...params) => new Promise((resolve, reject) => {
             // Generate the unique id for this message exchange session
             // Although we won't listen for a response, it must still be unique
             // to avoid tangling with other requests.
             const messageSessionId = getUniqueId();
-            messageTransport.emit({
-                args: params,
+            const { handleAckMessage, sendMessage } = createRequestChannelMessageSender.createRequestChannelMessageSender({
                 messageSessionId,
-                type: requestName,
+                messageTransport,
+                onReceiveAck: () => {
+                    cleanupMessageHandler();
+                    resolve();
+                },
+                onTimeout: () => {
+                    cleanupMessageHandler();
+                    reject(utils.createNoHandlerError(requestType));
+                },
+                params,
+                requestType,
+                timeoutMap,
             });
-        },
+            const cleanupMessageHandler = () => messageTransport.off(handleAckMessage);
+            messageTransport.on(handleAckMessage);
+            sendMessage();
+        }),
         handle: (requestType, handler) => {
             const messageHandler = (_a) => _tslib.__awaiter(void 0, [_a], void 0, function* ({ args, messageSessionId, type: incomingType, }) {
                 if (requestType !== incomingType)
                     return;
+                // Emit an Ack since the message will time out unless some handler acks it in time
+                messageTransport.emit({
+                    args: [],
+                    messageSessionId,
+                    type: utils.getAckMessageType(requestType),
+                });
                 const result = handler(...args);
                 // If the handler doesn't return a promise,
                 // that means we don't need to respond.
@@ -63,14 +82,14 @@ const createRequestChannel = (messageTransport) => {
                     messageTransport.emit({
                         args: [response],
                         messageSessionId,
-                        type: getResolveMessageType(requestType),
+                        type: utils.getResolveMessageType(requestType),
                     });
                 }
                 catch (error) {
                     messageTransport.emit({
                         args: [serializeErrorForTransport.serializeErrorForTransport(error)],
                         messageSessionId,
-                        type: getRejectMessageType(requestType),
+                        type: utils.getRejectMessageType(requestType),
                     });
                 }
             });
@@ -79,43 +98,51 @@ const createRequestChannel = (messageTransport) => {
                 messageTransport.off(messageHandler);
             };
         },
-        request: (requestName, ...params) => new Promise((resolve, reject) => {
-            const requestType = requestName;
+        request: (requestType, ...params) => new Promise((resolve, reject) => {
             // Generate the unique id for this message exchange session
+            // Although we won't listen for a response, it must still be unique
+            // to avoid tangling with other requests.
             const messageSessionId = getUniqueId();
-            const resolveMessageType = getResolveMessageType(requestType);
-            const rejectMessageType = getRejectMessageType(requestType);
-            // Before actually emitting the event, we start listening to the
-            // response events
-            const handleMessage = ({ args: [result], messageSessionId: incomingSessionId, type: incomingType, }) => {
-                if (incomingSessionId !== messageSessionId)
+            const resolveMessageType = utils.getResolveMessageType(requestType);
+            const rejectMessageType = utils.getRejectMessageType(requestType);
+            const { handleAckMessage, sendMessage } = createRequestChannelMessageSender.createRequestChannelMessageSender({
+                messageSessionId,
+                messageTransport,
+                onTimeout: () => {
+                    cleanupMessageHandler();
+                    reject(utils.createNoHandlerError(requestType));
+                },
+                params,
+                requestType,
+                timeoutMap,
+            });
+            // We also need to listen to resolve and reject messages, besides acks
+            const handleMessage = (message) => {
+                if (message.messageSessionId !== messageSessionId)
                     return;
+                const { args: [result], type: incomingType, } = message;
                 if (incomingType === resolveMessageType) {
+                    cleanupMessageHandler();
                     resolve(result);
-                    cleanup();
+                    return;
                 }
                 if (incomingType === rejectMessageType) {
+                    cleanupMessageHandler();
                     if (isSerializedError.isSerializedError(result)) {
                         reject(parseErrorFromTransport.parseErrorFromTransport(result));
                     }
                     else {
                         reject(result);
                     }
-                    cleanup();
+                    return;
                 }
+                handleAckMessage(message);
             };
-            const cleanup = () => messageTransport.off(handleMessage);
+            const cleanupMessageHandler = () => messageTransport.off(handleMessage);
             messageTransport.on(handleMessage);
-            // Now we emit the event to set off the request
-            messageTransport.emit({
-                args: params,
-                messageSessionId,
-                type: requestType,
-            });
+            sendMessage();
         }),
     };
 };
 
 exports.createRequestChannel = createRequestChannel;
-exports.getRejectMessageType = getRejectMessageType;
-exports.getResolveMessageType = getResolveMessageType;

package/src/requestChannel/requestChannel.d.ts

@@ -1,38 +1,6 @@
+import { WithBlock } from '../messageTransport';
 import { MessageTransportWithDefaultOrigin } from '../messageTransport/decorators/applyDefaultMessageOrigin/applyDefaultMessageOrigin';
-/**
- * An object that defines request types, and whether they expect a response
- */
-export type RequestTypes = Record<string, (...params: any[]) => Promise<any> | void>;
-/**
- * Only the request types from T that return promises
- * i.e. those that expect a response
- */
-type TypesExpectingResponse<T extends RequestTypes> = {
-    [K in keyof T]: ReturnType<T[K]> extends Promise<any> ? K : never;
-}[keyof T];
-export type RequestChannel<T extends RequestTypes> = {
-    /**
-     * Listens to incoming requests of this type, and calls the handler when they arrive.
-     * If the type of this request expects some response, the handler must return a promise
-     * that resolves to this response.
-     * @returns an unsubscribe function.
-     */
-    handle: <K extends keyof T>(requestType: K, handler: T[K]) => VoidFunction;
-    /**
-     * Triggers handlers for this request type, with the given params.
-     * Doesn't care whether this request will have a response or not, so returns void.
-     */
-    emit: <K extends keyof T>(requestName: K, ...params: Parameters<T[K]>) => void;
-    /**
-     * Triggers handlers for this request type, with the given params.
-     * @returns a promise that resolves/rejects when a handler fulfills this request.
-     */
-    request: <K extends TypesExpectingResponse<T>>(requestName: K, ...params: Parameters<T[K]>) => ReturnType<T[K]>;
-};
-/** Given a request event name, returns the event name for its resolve */
-export declare const getResolveMessageType: (type: string) => string;
-/** Given a request event name, returns the event name for its reject */
-export declare const getRejectMessageType: (type: string) => string;
+import { RequestChannel, RequestTypes } from './types';
 /**
  * Allows handling and submitting requests to and from a webview.
  * Requests are messages that (can) expect some response.
@@ -51,5 +19,4 @@ export declare const getRejectMessageType: (type: string) => string;
  *
  * This is an abstraction built on top of the MessageTransport interface.
  */
-export declare const createRequestChannel: <T extends RequestTypes = never>(messageTransport: MessageTransportWithDefaultOrigin) => RequestChannel<T>;
-export {};
+export declare const createRequestChannel: <T extends RequestTypes = never>(messageTransport: MessageTransportWithDefaultOrigin | WithBlock<MessageTransportWithDefaultOrigin>) => RequestChannel<T>;

package/src/requestChannel/requestChannel.js

@@ -1,13 +1,11 @@
 'use client'
 import { __awaiter } from '../../_virtual/_tslib.js';
+import { isSerializedError } from '../utils/isSerializedError/isSerializedError.js';
 import { parseErrorFromTransport } from '../utils/parseErrorFromTransport/parseErrorFromTransport.js';
 import { serializeErrorForTransport } from '../utils/serializeErrorForTransport/serializeErrorForTransport.js';
-import { isSerializedError } from '../utils/isSerializedError/isSerializedError.js';
+import { createRequestChannelMessageSender } from './createRequestChannelMessageSender/createRequestChannelMessageSender.js';
+import { createNoHandlerError, getAckMessageType, getResolveMessageType, getRejectMessageType } from './utils/utils.js';
 
-/** Given a request event name, returns the event name for its resolve */
-const getResolveMessageType = (type) => `${type}__resolve`;
-/** Given a request event name, returns the event name for its reject */
-const getRejectMessageType = (type) => `${type}__reject`;
 /**
  * Allows handling and submitting requests to and from a webview.
  * Requests are messages that (can) expect some response.
@@ -33,22 +31,43 @@ const createRequestChannel = (messageTransport) => {
     const idPrefix = Math.random().toString();
     /** Always returns a different string */
     const getUniqueId = () => `${idPrefix}-${uniqueIdCounter++}`;
+    /** Maps a request's session ID to its time out timer */
+    const timeoutMap = {};
     return {
-        emit: (requestName, ...params) => {
+        emit: (requestType, ...params) => new Promise((resolve, reject) => {
             // Generate the unique id for this message exchange session
             // Although we won't listen for a response, it must still be unique
             // to avoid tangling with other requests.
             const messageSessionId = getUniqueId();
-            messageTransport.emit({
-                args: params,
+            const { handleAckMessage, sendMessage } = createRequestChannelMessageSender({
                 messageSessionId,
-                type: requestName,
+                messageTransport,
+                onReceiveAck: () => {
+                    cleanupMessageHandler();
+                    resolve();
+                },
+                onTimeout: () => {
+                    cleanupMessageHandler();
+                    reject(createNoHandlerError(requestType));
+                },
+                params,
+                requestType,
+                timeoutMap,
             });
-        },
+            const cleanupMessageHandler = () => messageTransport.off(handleAckMessage);
+            messageTransport.on(handleAckMessage);
+            sendMessage();
+        }),
         handle: (requestType, handler) => {
             const messageHandler = (_a) => __awaiter(void 0, [_a], void 0, function* ({ args, messageSessionId, type: incomingType, }) {
                 if (requestType !== incomingType)
                     return;
+                // Emit an Ack since the message will time out unless some handler acks it in time
+                messageTransport.emit({
+                    args: [],
+                    messageSessionId,
+                    type: getAckMessageType(requestType),
+                });
                 const result = handler(...args);
                 // If the handler doesn't return a promise,
                 // that means we don't need to respond.
@@ -75,41 +94,51 @@ const createRequestChannel = (messageTransport) => {
                 messageTransport.off(messageHandler);
             };
         },
-        request: (requestName, ...params) => new Promise((resolve, reject) => {
-            const requestType = requestName;
+        request: (requestType, ...params) => new Promise((resolve, reject) => {
             // Generate the unique id for this message exchange session
+            // Although we won't listen for a response, it must still be unique
+            // to avoid tangling with other requests.
             const messageSessionId = getUniqueId();
             const resolveMessageType = getResolveMessageType(requestType);
             const rejectMessageType = getRejectMessageType(requestType);
-            // Before actually emitting the event, we start listening to the
-            // response events
-            const handleMessage = ({ args: [result], messageSessionId: incomingSessionId, type: incomingType, }) => {
-                if (incomingSessionId !== messageSessionId)
+            const { handleAckMessage, sendMessage } = createRequestChannelMessageSender({
+                messageSessionId,
+                messageTransport,
+                onTimeout: () => {
+                    cleanupMessageHandler();
+                    reject(createNoHandlerError(requestType));
+                },
+                params,
+                requestType,
+                timeoutMap,
+            });
+            // We also need to listen to resolve and reject messages, besides acks
+            const handleMessage = (message) => {
+                if (message.messageSessionId !== messageSessionId)
                     return;
+                const { args: [result], type: incomingType, } = message;
                 if (incomingType === resolveMessageType) {
+                    cleanupMessageHandler();
                     resolve(result);
-                    cleanup();
+                    return;
                 }
                 if (incomingType === rejectMessageType) {
+                    cleanupMessageHandler();
                     if (isSerializedError(result)) {
                         reject(parseErrorFromTransport(result));
                     }
                     else {
                         reject(result);
                     }
-                    cleanup();
+                    return;
                 }
+                handleAckMessage(message);
             };
-            const cleanup = () => messageTransport.off(handleMessage);
+            const cleanupMessageHandler = () => messageTransport.off(handleMessage);
             messageTransport.on(handleMessage);
-            // Now we emit the event to set off the request
-            messageTransport.emit({
-                args: params,
-                messageSessionId,
-                type: requestType,
-            });
+            sendMessage();
         }),
     };
 };
 
-export { createRequestChannel, getRejectMessageType, getResolveMessageType };
+export { createRequestChannel };

package/src/requestChannel/types.d.ts

@@ -0,0 +1,55 @@
+/**
+ * An object that defines request types, and whether they expect a response
+ */
+export type RequestTypes = Record<string, (...params: any[]) => Promise<any> | void>;
+/**
+ * Only the request types from T that return promises
+ * i.e. those that expect a response
+ */
+type TypesExpectingResponse<T extends RequestTypes> = Extract<{
+    [K in keyof T]: ReturnType<T[K]> extends Promise<any> ? K : never;
+}[keyof T], string>;
+export type RequestChannel<T extends RequestTypes> = {
+    /**
+     * Listens to incoming requests of this type, and calls the handler when they arrive.
+     * If the type of this request expects some response, the handler must return a promise
+     * that resolves to this response.
+     *
+     * @returns an unsubscribe function.
+     */
+    handle: <K extends Extract<keyof T, string>>(requestType: K, handler: T[K]) => VoidFunction;
+    /**
+     * Triggers handlers for this request type, with the given params.
+     * Doesn't expect a response. Resolves as soon as the message is acknowledged by
+     * any handler.
+     *
+     * If no handlers emit an ack for this message, this will reject.
+     *
+     * Lifetime of an "emit" message:
+     * 1. "Emit" message is sent.
+     * 2. A handler receives the message.
+     * 3. The handler immediately emits an ack message for it, acknowledging it.
+     * 4. This method's promise resolves.
+     */
+    emit: <K extends Extract<keyof T, string>>(requestName: K, ...params: Parameters<T[K]>) => Promise<void>;
+    /**
+     * Triggers handlers for this request type, with the given params.
+     * As opposed to emit, this expects a response message. A handler must still
+     * acknowledge this message, but the promise will only resolve when the handler
+     * emits back a response message. The promise resolves with whatever data was sent
+     * in the response.
+     *
+     * If no handlers emit an ack for this message, or if a handler responds
+     * with a failure, this will reject.
+     *
+     * Lifetime of a "request" message:
+     * 1. "Request" message is sent.
+     * 2. A handler receives the message.
+     * 3. The handler immediately emits an ack message for it, acknowledging it.
+     * 4. The handler performs the requested action.
+     * 5. The handler emits a response message.
+     * 6. This method's promise resolves with the response's data.
+     */
+    request: <K extends TypesExpectingResponse<T>>(requestName: K, ...params: Parameters<T[K]>) => ReturnType<T[K]>;
+};
+export {};

package/src/requestChannel/utils/index.d.ts

@@ -0,0 +1 @@
+export * from './utils';