@k13engineering/yajrpc 0.0.2 → 0.0.3

package/dist/lib/index.d.ts

@@ -1,47 +1,3 @@
-import type { TJsonRpcError, TJsonRpcMessage, TJsonRpcParameters, TRequestResponse, TRequestResponseValue, TRequestResult } from "./types.js";
-type TRequestHandlerResponse = {
-    result: TRequestResponseValue;
-    error: undefined;
-} | {
-    result: undefined;
-    error: TJsonRpcError;
-} | {
-    result: undefined;
-    error: undefined;
-};
-type TRequestHandler = (args: {
-    method: string;
-    params: TJsonRpcParameters | undefined;
-}) => Promise<TRequestHandlerResponse>;
-type TNotificationHandler = (args: {
-    method: string;
-    params: TJsonRpcParameters | undefined;
-}) => void;
-type TNotifyMethod = (args: {
-    method: string;
-    params: TJsonRpcParameters;
-}) => void;
-type TRequestMethod = (args: {
-    method: string;
-    params: TJsonRpcParameters;
-    timeoutMs?: number;
-}) => Promise<TRequestResult>;
-declare const createJrpc: ({ sendMessage, handleRequest, handleNotification }: {
-    sendMessage: (args: {
-        message: TJsonRpcMessage;
-    }) => void;
-    handleRequest: TRequestHandler;
-    handleNotification: TNotificationHandler;
-}) => {
-    receivedMessage: ({ message }: {
-        message: unknown;
-    }) => {
-        error: Error | undefined;
-    };
-    request: TRequestMethod;
-    notify: TNotifyMethod;
-    close: () => void;
-};
-type TJrpc = ReturnType<typeof createJrpc>;
-export { createJrpc };
-export type { TJsonRpcMessage, TRequestResponse, TRequestResult, TJrpc, TRequestHandler, TNotificationHandler, TRequestMethod, TNotifyMethod };
+import { createJrpc } from "./jrpc.js";
+import { createWebSocketJrpc } from "./websocket.js";
+export { createJrpc, createWebSocketJrpc };

package/dist/lib/index.js

@@ -1,255 +1,7 @@
-import { coerceJrpcMessage } from "./coerce.js";
-/*import type { TJsonRpcError, TJsonRpcMandatoryId, TJsonRpcMessage, TJsonRpcParameters, TRequestResponse, TRequestResponseValue, TRequestResult } from "./types.ts";*/
-
-/*type TPendingRequestHandle = {
-  resolve: (args: TRequestResult) => void;
-};*/
-
-/*type TRequestHandlerResponse = {
-  result: TRequestResponseValue;
-  error: undefined;
-} | {
-  result: undefined;
-  error: TJsonRpcError;
-} | {
-  result: undefined;
-  error: undefined;
-};*/
-
-/*type TRequestHandler = (args: { method: string, params: TJsonRpcParameters | undefined }) => Promise<TRequestHandlerResponse>;*/
-/*type TNotificationHandler = (args: { method: string, params: TJsonRpcParameters | undefined }) => void;*/
-
-/*type TNotifyMethod = (args: { method: string, params: TJsonRpcParameters }) => void;*/
-/*type TRequestMethod = (args: { method: string, params: TJsonRpcParameters, timeoutMs?: number }) => Promise<TRequestResult>;*/
-
-const createJrpc = ({
-  sendMessage,
-  handleRequest,
-  handleNotification
-}/*: {
-  sendMessage: (args: { message: TJsonRpcMessage }) => void;
-  handleRequest: TRequestHandler;
-  handleNotification: TNotificationHandler;
-}*/) => {
-
-  let closed = false;
-
-  const receivedRequest = ({
-    id,
-    method,
-    params
-  }/*: {
-    id: TJsonRpcMandatoryId,
-    method: string,
-    params: TJsonRpcParameters | undefined
-  }*/)/*: { error: Error | undefined }*/ => {
-
-    handleRequest({ method, params }).then((response) => {
-
-      if (response.error !== undefined) {
-        sendMessage({
-          message: {
-            jsonrpc: "2.0",
-            id,
-            error: response.error
-          }
-        });
-        return;
-      }
-
-      if (response.result !== undefined) {
-        sendMessage({
-          message: {
-            jsonrpc: "2.0",
-            result: response.result,
-            id
-          }
-        });
-        return;
-      }
-
-      // send nothing if we neither have a result nor an error
-      // this is a valid case
-    });
-
-    return {
-      error: undefined
-    };
-  };
-
-  let pendingRequests/*: Record<string, TPendingRequestHandle>*/ = {};
-
-  const receivedResponse = ({ id, response }/*: { id: TJsonRpcMandatoryId, response: TRequestResponse }*/)/*: { error: Error | undefined }*/ => {
-    const pendingRequest = pendingRequests[id];
-    if (pendingRequest === undefined) {
-      return {
-        error: Error("received response for non-pending id")
-      };
-    }
-
-    pendingRequest.resolve({
-      response,
-      error: undefined
-    });
-
-    return {
-      error: undefined
-    };
-  };
-
-  // eslint-disable-next-line complexity
-  const receivedMessage = ({ message }/*: { message: unknown }*/)/*: { error: Error | undefined }*/ => {
-    if (closed) {
-      throw Error("connection closed");
-    }
-
-    const { error: coerceError, jrpcMessage } = coerceJrpcMessage({ message });
-    if (coerceError !== undefined) {
-      return {
-        error: coerceError
-      };
-    }
-
-    if (jrpcMessage.id === null) {
-      return {
-        error: Error("this library does not support null ids")
-      };
-    }
-
-    if (jrpcMessage.id === undefined) {
-      handleNotification({
-        method: jrpcMessage.method,
-        params: jrpcMessage.params
-      });
-
-      return { error: undefined };
-    }
-
-    if (jrpcMessage.result !== undefined) {
-      return receivedResponse({
-        id: jrpcMessage.id,
-        response: {
-          result: jrpcMessage.result,
-          error: undefined
-        }
-      });
-    }
-
-    if (jrpcMessage.error !== undefined) {
-      return receivedResponse({
-        id: jrpcMessage.id,
-        response: {
-          result: undefined,
-          error: jrpcMessage.error
-        }
-      });
-    }
-
-    return receivedRequest({
-      id: jrpcMessage.id,
-      method: jrpcMessage.method,
-      params: jrpcMessage.params
-    });
-  };
-
-  const close = () => {
-    if (closed) {
-      throw Error("connection already closed");
-    }
-
-    Object.keys(pendingRequests).forEach((id) => {
-      const pendingRequest = pendingRequests[id];
-      pendingRequest.resolve({
-        error: Error("connection closed"),
-        response: undefined
-      });
-    });
-
-    closed = true;
-  };
-
-  let requestIdCounter = 0;
-
-  const request/*: TRequestMethod*/ = ({
-    method,
-    params,
-    timeoutMs
-  })/*: Promise<TRequestResult>*/ => {
-
-    const requestId = requestIdCounter;
-    requestIdCounter += 1;
-
-    let timeoutHandle/*: NodeJS.Timeout | undefined*/ = undefined;
-    if (timeoutMs !== undefined) {
-      timeoutHandle = setTimeout(() => {
-        const pendingRequest = pendingRequests[requestId];
-        pendingRequest.resolve({
-          error: Error("timeout"),
-          response: undefined
-        });
-      }, timeoutMs);
-    }
-
-    sendMessage({
-      message: {
-        jsonrpc: "2.0",
-        method,
-        params,
-        id: requestId
-      }
-    });
-
-    return new Promise((resolve) => {
-      pendingRequests = {
-        ...pendingRequests,
-        [requestId]: {
-          resolve: (result) => {
-            // remove the request from the pending requests
-            const { [requestId]: requestToDrop, ...otherPendingRequests } = pendingRequests;
-            pendingRequests = otherPendingRequests;
-
-            // clear the timeout
-            clearTimeout(timeoutHandle);
-
-            resolve(result);
-          },
-          timeoutHandle
-        }
-      };
-    });
-  };
-
-  const notify/*: TNotifyMethod*/ = ({ method, params }) => {
-    sendMessage({
-      message: {
-        jsonrpc: "2.0",
-        method,
-        params
-      }
-    });
-  };
-
-  return {
-    receivedMessage,
-    request,
-    notify,
-    close
-  };
-};
-
-/*type TJrpc = ReturnType<typeof createJrpc>;*/
+import { createJrpc } from "./jrpc.js";
+import { createWebSocketJrpc } from "./websocket.js";
 
 export {
-  createJrpc
+  createJrpc,
+  createWebSocketJrpc
 };
-
-/*export type {
-  TJsonRpcMessage,
-  TRequestResponse,
-  TRequestResult,
-  TJrpc,
-  TRequestHandler,
-  TNotificationHandler,
-  TRequestMethod,
-  TNotifyMethod
-};*/

package/dist/lib/jrpc.d.ts

@@ -0,0 +1,20 @@
+import type { TJsonRpcMessage, TNotificationHandler, TNotifyMethod, TRequestHandler, TRequestMethod, TRequestResponse, TRequestResult } from "./types.js";
+declare const createJrpc: ({ sendMessage, handleRequest, handleNotification }: {
+    sendMessage: (args: {
+        message: TJsonRpcMessage;
+    }) => void;
+    handleRequest: TRequestHandler;
+    handleNotification: TNotificationHandler;
+}) => {
+    receivedMessage: ({ message }: {
+        message: unknown;
+    }) => {
+        error: Error | undefined;
+    };
+    request: TRequestMethod;
+    notify: TNotifyMethod;
+    close: () => void;
+};
+type TJrpc = ReturnType<typeof createJrpc>;
+export { createJrpc };
+export type { TJsonRpcMessage, TRequestResponse, TRequestResult, TJrpc, TRequestHandler, TNotificationHandler, TRequestMethod, TNotifyMethod };

package/dist/lib/jrpc.js

@@ -0,0 +1,248 @@
+import { coerceJrpcMessage } from "./coerce.js";
+/*import type {
+  TJsonRpcMandatoryId,
+  TJsonRpcMessage,
+  TJsonRpcParameters,
+  TNotificationHandler,
+  TNotifyMethod,
+  TRequestHandler,
+  TRequestMethod,
+  TRequestResponse,
+  TRequestResult
+} from "./types.ts";*/
+
+/*type TPendingRequestHandle = {
+  resolve: (args: TRequestResult) => void;
+};*/
+
+const createJrpc = ({
+  sendMessage,
+  handleRequest,
+  handleNotification
+}/*: {
+  sendMessage: (args: { message: TJsonRpcMessage }) => void;
+  handleRequest: TRequestHandler;
+  handleNotification: TNotificationHandler;
+}*/) => {
+
+  let closed = false;
+
+  const receivedRequest = ({
+    id,
+    method,
+    params
+  }/*: {
+    id: TJsonRpcMandatoryId,
+    method: string,
+    params: TJsonRpcParameters | undefined
+  }*/)/*: { error: Error | undefined }*/ => {
+
+    handleRequest({ method, params }).then((response) => {
+
+      if (response.error !== undefined) {
+        sendMessage({
+          message: {
+            jsonrpc: "2.0",
+            id,
+            error: response.error
+          }
+        });
+        return;
+      }
+
+      if (response.result !== undefined) {
+        sendMessage({
+          message: {
+            jsonrpc: "2.0",
+            result: response.result,
+            id
+          }
+        });
+        return;
+      }
+
+      // send nothing if we neither have a result nor an error
+      // this is a valid case
+    });
+
+    return {
+      error: undefined
+    };
+  };
+
+  let pendingRequests/*: Record<string, TPendingRequestHandle>*/ = {};
+
+  const receivedResponse = ({ id, response }/*: { id: TJsonRpcMandatoryId, response: TRequestResponse }*/)/*: { error: Error | undefined }*/ => {
+    const pendingRequest = pendingRequests[id];
+    if (pendingRequest === undefined) {
+      return {
+        error: Error("received response for non-pending id")
+      };
+    }
+
+    pendingRequest.resolve({
+      response,
+      error: undefined
+    });
+
+    return {
+      error: undefined
+    };
+  };
+
+  // eslint-disable-next-line complexity
+  const receivedMessage = ({ message }/*: { message: unknown }*/)/*: { error: Error | undefined }*/ => {
+    if (closed) {
+      throw Error("connection closed");
+    }
+
+    const { error: coerceError, jrpcMessage } = coerceJrpcMessage({ message });
+    if (coerceError !== undefined) {
+      return {
+        error: coerceError
+      };
+    }
+
+    if (jrpcMessage.id === null) {
+      return {
+        error: Error("this library does not support null ids")
+      };
+    }
+
+    if (jrpcMessage.id === undefined) {
+      handleNotification({
+        method: jrpcMessage.method,
+        params: jrpcMessage.params
+      });
+
+      return { error: undefined };
+    }
+
+    if (jrpcMessage.result !== undefined) {
+      return receivedResponse({
+        id: jrpcMessage.id,
+        response: {
+          result: jrpcMessage.result,
+          error: undefined
+        }
+      });
+    }
+
+    if (jrpcMessage.error !== undefined) {
+      return receivedResponse({
+        id: jrpcMessage.id,
+        response: {
+          result: undefined,
+          error: jrpcMessage.error
+        }
+      });
+    }
+
+    return receivedRequest({
+      id: jrpcMessage.id,
+      method: jrpcMessage.method,
+      params: jrpcMessage.params
+    });
+  };
+
+  const close = () => {
+    if (closed) {
+      throw Error("connection already closed");
+    }
+
+    Object.keys(pendingRequests).forEach((id) => {
+      const pendingRequest = pendingRequests[id];
+      pendingRequest.resolve({
+        error: Error("connection closed"),
+        response: undefined
+      });
+    });
+
+    closed = true;
+  };
+
+  let requestIdCounter = 0;
+
+  const request/*: TRequestMethod*/ = ({
+    method,
+    params,
+    timeoutMs
+  })/*: Promise<TRequestResult>*/ => {
+
+    const requestId = requestIdCounter;
+    requestIdCounter += 1;
+
+    let timeoutHandle/*: NodeJS.Timeout | undefined*/ = undefined;
+    if (timeoutMs !== undefined) {
+      timeoutHandle = setTimeout(() => {
+        const pendingRequest = pendingRequests[requestId];
+        pendingRequest.resolve({
+          error: Error("timeout"),
+          response: undefined
+        });
+      }, timeoutMs);
+    }
+
+    sendMessage({
+      message: {
+        jsonrpc: "2.0",
+        method,
+        params,
+        id: requestId
+      }
+    });
+
+    return new Promise((resolve) => {
+      pendingRequests = {
+        ...pendingRequests,
+        [requestId]: {
+          resolve: (result) => {
+            // remove the request from the pending requests
+            const { [requestId]: requestToDrop, ...otherPendingRequests } = pendingRequests;
+            pendingRequests = otherPendingRequests;
+
+            // clear the timeout
+            clearTimeout(timeoutHandle);
+
+            resolve(result);
+          },
+          timeoutHandle
+        }
+      };
+    });
+  };
+
+  const notify/*: TNotifyMethod*/ = ({ method, params }) => {
+    sendMessage({
+      message: {
+        jsonrpc: "2.0",
+        method,
+        params
+      }
+    });
+  };
+
+  return {
+    receivedMessage,
+    request,
+    notify,
+    close
+  };
+};
+
+/*type TJrpc = ReturnType<typeof createJrpc>;*/
+
+export {
+  createJrpc
+};
+
+/*export type {
+  TJsonRpcMessage,
+  TRequestResponse,
+  TRequestResult,
+  TJrpc,
+  TRequestHandler,
+  TNotificationHandler,
+  TRequestMethod,
+  TNotifyMethod
+};*/

package/dist/lib/types.d.ts

@@ -65,4 +65,31 @@ type TRequestResult = {
     error: undefined;
     response: TRequestResponse;
 };
-export type { TJsonRpcRequest, TJsonRpcResponse, TJsonRpcNotification, TJsonRpcSuccessResponse, TJsonRpcErrorResponse, TJsonRpcMessage, TJsonRpcParameters, TJsonRpcOptionalId, TJsonRpcMandatoryId, TRequestResponse, TRequestResult, TRequestErrorResponse, TRequestResponseValue, TJsonRpcError, };
+type TRequestHandlerResponse = {
+    result: TRequestResponseValue;
+    error: undefined;
+} | {
+    result: undefined;
+    error: TJsonRpcError;
+} | {
+    result: undefined;
+    error: undefined;
+};
+type TRequestHandler = (args: {
+    method: string;
+    params: TJsonRpcParameters | undefined;
+}) => Promise<TRequestHandlerResponse>;
+type TNotificationHandler = (args: {
+    method: string;
+    params: TJsonRpcParameters | undefined;
+}) => void;
+type TNotifyMethod = (args: {
+    method: string;
+    params: TJsonRpcParameters;
+}) => void;
+type TRequestMethod = (args: {
+    method: string;
+    params: TJsonRpcParameters;
+    timeoutMs?: number;
+}) => Promise<TRequestResult>;
+export type { TJsonRpcRequest, TJsonRpcResponse, TJsonRpcNotification, TJsonRpcSuccessResponse, TJsonRpcErrorResponse, TJsonRpcMessage, TJsonRpcParameters, TJsonRpcOptionalId, TJsonRpcMandatoryId, TRequestResponse, TRequestResult, TRequestErrorResponse, TRequestResponseValue, TJsonRpcError, TRequestHandlerResponse, TRequestHandler, TNotificationHandler, TNotifyMethod, TRequestMethod };

package/dist/lib/types.js

@@ -79,6 +79,26 @@
   response: TRequestResponse;
 };*/
 
+
+// -----------
+
+/*type TRequestHandlerResponse = {
+  result: TRequestResponseValue;
+  error: undefined;
+} | {
+  result: undefined;
+  error: TJsonRpcError;
+} | {
+  result: undefined;
+  error: undefined;
+};*/
+
+/*type TRequestHandler = (args: { method: string, params: TJsonRpcParameters | undefined }) => Promise<TRequestHandlerResponse>;*/
+/*type TNotificationHandler = (args: { method: string, params: TJsonRpcParameters | undefined }) => void;*/
+
+/*type TNotifyMethod = (args: { method: string, params: TJsonRpcParameters }) => void;*/
+/*type TRequestMethod = (args: { method: string, params: TJsonRpcParameters, timeoutMs?: number }) => Promise<TRequestResult>;*/
+
 /*export type {
   TJsonRpcRequest,
   TJsonRpcResponse,
@@ -94,5 +114,13 @@
   TRequestErrorResponse,
   TRequestResponseValue,
   TJsonRpcError,
+
+  // -------
+
+  TRequestHandlerResponse,
+  TRequestHandler,
+  TNotificationHandler,
+  TNotifyMethod,
+  TRequestMethod
 };*/
 /* c8 ignore end */

package/dist/lib/websocket.d.ts

@@ -0,0 +1,35 @@
+import type { TNotificationHandler, TRequestHandler } from "./jrpc.js";
+type TMessageParseResult = {
+    error: Error;
+    message: undefined;
+} | {
+    error: undefined;
+    message: unknown;
+};
+type TWebSocketMessageParser = {
+    parse: (args: {
+        data: string | Uint8Array;
+    }) => TMessageParseResult;
+    format: (args: {
+        message: unknown;
+    }) => string | Uint8Array;
+};
+declare const createWebSocketJrpc: ({ socket, parser, handleRequest, handleNotification, onConnectionError, onRemoteClose }: {
+    socket: WebSocket;
+    parser: TWebSocketMessageParser;
+    handleRequest: TRequestHandler;
+    handleNotification: TNotificationHandler;
+    onConnectionError: (args: {
+        error: Error;
+    }) => void;
+    onRemoteClose: () => void;
+}) => {
+    request: any;
+    notify: any;
+    bufferedAmount: () => any;
+    close: () => void;
+};
+type TWebsocketJrpcHandle = ReturnType<typeof createWebSocketJrpc>;
+declare const createJsonParser: () => TWebSocketMessageParser;
+export { createWebSocketJrpc, createJsonParser };
+export type { TWebsocketJrpcHandle, };

package/dist/lib/websocket.js

@@ -0,0 +1,202 @@
+import { createJrpc } from "./index.js";
+/*import type { TJsonRpcMessage, TNotificationHandler, TRequestHandler } from "./jrpc.ts";*/
+
+/*type TMessageParseResult = {
+  error: Error;
+  message: undefined;
+} | {
+  error: undefined;
+  message: unknown;
+};*/
+
+/*type TWebSocketMessageParser = {
+  parse: (args: { data: string | Uint8Array }) => TMessageParseResult;
+  format: (args: { message: unknown }) => string | Uint8Array;
+};*/
+
+const createWebSocketJrpc = ({
+  socket,
+
+  parser,
+
+  handleRequest,
+  handleNotification,
+
+  onConnectionError,
+  onRemoteClose
+}/*: {
+  socket: WebSocket,
+
+  parser: TWebSocketMessageParser;
+
+  handleRequest: TRequestHandler;
+  handleNotification: TNotificationHandler;
+
+  onConnectionError: (args: { error: Error }) => void;
+  onRemoteClose: () => void;
+}*/) => {
+
+  let closedByUs = false;
+  let connectionError/*: Error | undefined*/ = undefined;
+  socket.binaryType = "arraybuffer";
+
+  let sendQueue/*: (string | Uint8Array)[]*/ = [];
+
+  const maybeSendNext = () => {
+    if (socket.readyState !== WebSocket.OPEN) {
+      return;
+    }
+
+    sendQueue.forEach((data) => {
+      socket.send(data);
+    });
+    sendQueue = [];
+  };
+
+  const sendOrQueueRawMessage = ({ data }/*: { data: string | Uint8Array }*/) => {
+    sendQueue.push(data);
+    maybeSendNext();
+  };
+
+  const sendMessage = ({ message }/*: { message: TJsonRpcMessage }*/) => {
+    const encoded = parser.format({ message });
+    sendOrQueueRawMessage({ data: encoded });
+  };
+
+  const jrpc = createJrpc({
+    sendMessage,
+    handleRequest,
+    handleNotification
+  });
+
+  const dataFromMessageEvent = ({ messageEvent }/*: { messageEvent: MessageEvent }*/)/*: string | Uint8Array*/ => {
+    if (typeof messageEvent.data === "string") {
+      return messageEvent.data;
+    }
+
+    if (messageEvent.data instanceof ArrayBuffer) {
+      return new Uint8Array(messageEvent.data);
+    }
+
+    throw Error("unsupported WebSocket data type");
+  };
+
+  socket.addEventListener("message", (event) => {
+
+    if (closedByUs) {
+      throw Error("WebSocket was closed by us, but received a message from remote");
+    }
+
+    const data = dataFromMessageEvent({ messageEvent: event });
+
+    const { error: parseError, message } = parser.parse({ data });
+    if (parseError !== undefined) {
+      closedByUs = true;
+      socket.close();
+      onConnectionError({
+        error: Error("failed to parse WebSocket message", { cause: parseError })
+      });
+      return;
+    }
+
+    const { error: jrpcError } = jrpc.receivedMessage({ message });
+    if (jrpcError !== undefined) {
+      closedByUs = true;
+      socket.close();
+      onConnectionError({
+        error: Error("failed to handle JRPC message", { cause: jrpcError })
+      });
+      return;
+    }
+  });
+
+  socket.addEventListener("close", () => {
+    sendQueue = [];
+    jrpc.close();
+
+    if (closedByUs) {
+      return;
+    }
+
+    if (connectionError !== undefined) {
+      return;
+    }
+
+    onRemoteClose();
+  });
+
+  socket.addEventListener("error", () => {
+    if (closedByUs) {
+      return;
+    }
+
+    const error = Error("WebSocket connection error");
+    connectionError = error;
+
+    onConnectionError({ error });
+  });
+
+  const close = () => {
+    closedByUs = true;
+    socket.close();
+  };
+
+  const bufferedAmount = () => {
+    return socket.bufferedAmount;
+  };
+
+  return {
+    request: jrpc.request,
+    notify: jrpc.notify,
+
+    bufferedAmount,
+
+    close
+  };
+};
+
+/*type TWebsocketJrpcHandle = ReturnType<typeof createWebSocketJrpc>;*/
+
+const createJsonParser = ()/*: TWebSocketMessageParser*/ => {
+
+  const parse/*: TWebSocketMessageParser["parse"]*/ = ({ data }) => {
+
+    if (typeof data === "string") {
+      try {
+        const message = JSON.parse(data);
+        return {
+          error: undefined,
+          message
+        };
+      } catch (err) {
+        return {
+          error: err /*as Error*/,
+          message: undefined
+        };
+      }
+    }
+
+    return {
+      error: Error("unsupported WebSocket data type"),
+      message: undefined
+    };
+  };
+
+  const format/*: TWebSocketMessageParser["format"]*/ = ({ message }) => {
+    return JSON.stringify(message);
+  };
+
+  return {
+    parse,
+    format
+  };
+};
+
+export {
+  createWebSocketJrpc,
+  createJsonParser
+};
+
+/*export type {
+  TWebsocketJrpcHandle,
+};*/

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.0.2",
+  "version": "0.0.3",
   "name": "@k13engineering/yajrpc",
   "type": "module",
   "description": "Boilerplate project",
@@ -15,6 +15,7 @@
     "@types/node": "^25.0.10",
     "c8": "^10.1.3",
     "deno-node": "^0.0.12",
+    "isomorphic-ws": "^5.0.0",
     "mocha": "^11.7.5",
     "npm-check-updates": "^19.3.1",
     "typescript": "^5.9.3",