kkrpc 0.0.2

package/.turbo/turbo-test.log

@@ -0,0 +1,57 @@
+
+
+> kkrpc@ test /Users/hacker/Dev/projects/kkrpc/packages/kkrpc
+> bun run scripts/test.ts
+
+Check file:///Users/hacker/Dev/projects/kkrpc/packages/kkrpc/__deno_tests__/deno-web-worker.test.ts
+running 1 test from ./__deno_tests__/deno-web-worker.test.ts
+Call Worker Exposed API ...Check file:///Users/hacker/Dev/projects/kkrpc/packages/kkrpc/__tests__/scripts/worker.ts
+ ok (538ms)
+
+ok | 1 passed | 0 failed (541ms)
+
+bun test v1.1.34 (5e5e7c60)
+
+__tests__/http.test.ts:
+(pass) HTTP RPC > echo service [4.72ms]
+(pass) HTTP RPC > math operations [0.81ms]
+(pass) HTTP RPC > concurrent calls [0.74ms]
+(pass) HTTP RPC > stress test with concurrent calls [220.99ms]
+(pass) HTTP RPC > error handling - invalid endpoint [0.85ms]
+(pass) HTTP RPC > error handling - wrong method [0.30ms]
+
+__tests__/websocket.test.ts:
+(pass) WebSocket RPC [32.65ms]
+(pass) WebSocket concurrent connections [2.86ms]
+
+__tests__/bun.worker.test.ts:
+(pass) Bun Worker [33.52ms]
+
+__tests__/stdio-rpc.test.ts:
+(pass) RPCChannel Test > DenoStdio [483.69ms]
+(pass) RPCChannel Test > NodeStdio [374.62ms]
+
+__tests__/serialization.test.ts:
+(pass) Serializer > should serialize and deserialize a message [0.16ms]
+(pass) Serializer > should serialize and deserialize a response [1.69ms]
+---------------------------|---------|---------|-------------------
+File                       | % Funcs | % Lines | Uncovered Line #s
+---------------------------|---------|---------|-------------------
+All files                  |   78.63 |   70.89 |
+ __tests__/scripts/api.ts  |   80.00 |   94.74 | 
+ mod.ts                    |  100.00 |  100.00 | 
+ src/adapters/deno.ts      |    0.00 |   20.00 | 13-28,32-35
+ src/adapters/http.ts      |  100.00 |  100.00 | 
+ src/adapters/node.ts      |   84.62 |   91.43 | 25,42-43
+ src/adapters/websocket.ts |   77.27 |    1.61 | 3-124
+ src/adapters/worker.ts    |   50.00 |    1.77 | 3-113
+ src/channel.ts            |   73.08 |   88.39 | 42,159,178-184,213-219,251-252
+ src/interface.ts          |  100.00 |  100.00 | 
+ src/serialization.ts      |  100.00 |   81.82 | 28-29,46-47
+ src/utils.ts              |  100.00 |  100.00 | 
+---------------------------|---------|---------|-------------------
+
+ 13 pass
+ 0 fail
+ 14640 expect() calls
+Ran 13 tests across 5 files. [1205.00ms]

package/README.md

@@ -0,0 +1,88 @@
+# kkrpc
+
+> A TypeScript-first RPC library that enables seamless bi-directional communication between processes.
+> Call remote functions as if they were local, with full TypeScript type safety and autocompletion support.
+
+## Supported Environments
+
+- stdio: RPC over stdio between any combinations of Node.js, Deno, Bun processes
+- web: RPC over `postMessage` API and message channel between browser main thread and web workers, or main thread and iframe
+  - Web Worker API (web standard) is also supported in Deno and Bun, the main thread can call functions in worker and vice versa.
+- http: RPC over HTTP like tRPC
+  - supports any HTTP server (e.g. hono, bun, nodejs http, express, fastify, deno, etc.)
+- WebSocket: RPC over WebSocket
+
+The core of **kkrpc** design is in `RPCChannel` and `IoInterface`.
+
+- `RPCChannel` is the bidirectional RPC channel
+- `LocalAPI` is the APIs to be exposed to the other side of the channel
+- `RemoteAPI` is the APIs exposed by the other side of the channel, and callable on the local side
+- `rpc.getAPI()` returns an object that is `RemoteAPI` typed, and is callable on the local side like a normal local function call.
+- `IoInterface` is the interface for implementing the IO for different environments. The implementations are called adapters.
+  - For example, for a Node process to communicate with a Deno process, we need `NodeIo` and `DenoIo` adapters which implements `IoInterface`. They share the same stdio pipe (`stdin/stdout`).
+  - In web, we have `WorkerChildIO` and `WorkerParentIO` adapters for web worker, `IframeParentIO` and `IframeChildIO` adapters for iframe.
+
+> In browser, import from `kkrpc/browser` instead of `kkrpc`, Deno adapter uses node:buffer which doesn't work in browser.
+
+```ts
+interface IoInterface {
+	name: string
+	read(): Promise<Buffer | Uint8Array | string | null> // Reads input
+	write(data: string): Promise<void> // Writes output
+}
+
+class RPCChannel<
+	LocalAPI extends Record<string, any>,
+	RemoteAPI extends Record<string, any>,
+	Io extends IoInterface = IoInterface
+> {}
+```
+
+## Examplesr
+
+Below are simple examples.
+
+### Stdio Example
+
+```ts
+import { NodeIo, RPCChannel } from "kkrpc"
+import { apiMethods } from "./api.ts"
+
+const stdio = new NodeIo(process.stdin, process.stdout)
+const child = new RPCChannel(stdio, apiMethods)
+```
+
+```ts
+import { spawn } from "child_process"
+
+const workerBun = spawn("bun", ["scripts/node-api.ts"])
+const io = new NodeIo(worker.stdout, worker.stdin)
+const parent = new RPCChannel<{}, API>(io, {})
+const api = parent.getAPI()
+
+expect(await api.add(1, 2)).toBe(3)
+```
+
+### Web Worker Example
+
+```ts
+import { RPCChannel, WorkerChildIO, type DestroyableIoInterface } from "kkrpc"
+
+const worker = new Worker(new URL("./scripts/worker.ts", import.meta.url).href, { type: "module" })
+const io = new WorkerChildIO(worker)
+const rpc = new RPCChannel<API, API, DestroyableIoInterface>(io, apiMethods)
+const api = rpc.getAPI()
+
+expect(await api.add(1, 2)).toBe(3)
+```
+
+```ts
+import { RPCChannel, WorkerParentIO, type DestroyableIoInterface } from "kkrpc"
+
+const io: DestroyableIoInterface = new WorkerChildIO()
+const rpc = new RPCChannel<API, API, DestroyableIoInterface>(io, apiMethods)
+const api = rpc.getAPI()
+
+const sum = await api.add(1, 2)
+expect(sum).toBe(3)
+```

package/__deno_tests__/deno-web-worker.test.ts

@@ -0,0 +1,31 @@
+/**
+ * If you see error in this file, it's likely Deno extension is not enabled.
+ */
+import { assertEquals } from "jsr:@std/assert"
+import { apiMethods, type API } from "../__tests__/scripts/api.ts"
+import { WorkerParentIO } from "../src/adapters/worker.ts"
+import { RPCChannel } from "../src/channel.ts"
+import type { DestroyableIoInterface } from "../src/interface.ts"
+
+const worker = new Worker(new URL("../__tests__/scripts/worker.ts", import.meta.url).href, {
+	type: "module"
+})
+const io = new WorkerParentIO(worker)
+const rpc = new RPCChannel<API, API, DestroyableIoInterface>(io, apiMethods)
+const api = rpc.getAPI()
+
+Deno.test("Call Worker Exposed API", async () => {
+	for (let i = 0; i < 100; i++) {
+		const randInt1 = Math.floor(Math.random() * 100)
+		const randInt2 = Math.floor(Math.random() * 100)
+		const product = await api.math.grade2.multiply(randInt1, randInt2)
+		assertEquals(product, randInt1 * randInt2)
+
+		const sum = await api.math.grade1.add(randInt1, randInt2)
+		assertEquals(sum, randInt1 + randInt2)
+		api.math.grade1.add(randInt1, randInt2, (sum) => {
+			assertEquals(sum, randInt1 + randInt2)
+		})
+	}
+	io.destroy()
+})

package/__tests__/bun.worker.test.ts

@@ -0,0 +1,24 @@
+import { expect, test } from "bun:test"
+import { NodeIo, RPCChannel, WorkerParentIO, type DestroyableIoInterface } from "../mod.ts"
+import { apiMethods, type API } from "./scripts/api.ts"
+
+const worker = new Worker(new URL("./scripts/worker.ts", import.meta.url).href, { type: "module" })
+const io = new WorkerParentIO(worker)
+const rpc = new RPCChannel<API, API, DestroyableIoInterface>(io, apiMethods)
+const api = rpc.getAPI()
+
+test("Bun Worker", async () => {
+	for (let i = 0; i < 100; i++) {
+		const randInt1 = Math.floor(Math.random() * 100)
+		const randInt2 = Math.floor(Math.random() * 100)
+		const product = await api.math.grade2.multiply(randInt1, randInt2)
+		expect(product).toBe(randInt1 * randInt2)
+
+		const sum = await api.math.grade1.add(randInt1, randInt2)
+		expect(sum).toBe(randInt1 + randInt2)
+		api.math.grade1.add(randInt1, randInt2, (sum) => {
+			expect(sum).toBe(randInt1 + randInt2)
+		})
+	}
+	io.destroy()
+})

package/__tests__/http.test.ts

@@ -0,0 +1,100 @@
+import { type Server } from "bun"
+import { afterAll, beforeAll, describe, expect, test } from "bun:test"
+import { RPCChannel } from "../mod.ts"
+import { HTTPClientIO, HTTPServerIO } from "../src/adapters/http.ts"
+import { apiMethods, type API } from "./scripts/api.ts"
+
+describe("HTTP RPC", () => {
+	let server: Server
+	let serverIO: HTTPServerIO
+	let serverRPC: RPCChannel<API, API>
+	let clientIO: HTTPClientIO
+	let api: API
+
+	// Setup before tests
+	beforeAll(() => {
+		// Create server
+		serverIO = new HTTPServerIO()
+		serverRPC = new RPCChannel<API, API>(serverIO, apiMethods)
+
+		server = Bun.serve({
+			port: 3000,
+			async fetch(req) {
+				const url = new URL(req.url)
+				if (url.pathname === "/rpc") {
+					if (req.method !== "POST") {
+						return new Response("Method not allowed", { status: 405 })
+					}
+					const res = await serverIO.handleRequest(await req.text())
+					return new Response(res, { headers: { "Content-Type": "application/json" } })
+				}
+				return new Response("Not found", { status: 404 })
+			}
+		})
+
+		// Create client
+		clientIO = new HTTPClientIO({
+			url: "http://localhost:3000/rpc"
+		})
+		const clientRPC = new RPCChannel<API, API>(clientIO, apiMethods)
+		api = clientRPC.getAPI()
+	})
+
+	// Cleanup after tests
+	afterAll(() => {
+		server.stop()
+	})
+
+	test("echo service", async () => {
+		const message = "Hello RPC!"
+		const result = await api.echo(message)
+		expect(result).toBe(message)
+	})
+
+	test("math operations", async () => {
+		const sum = await api.math.grade1.add(5, 3)
+		expect(sum).toBe(8)
+
+		const product = await api.math.grade2.multiply(4, 6)
+		expect(product).toBe(24)
+	})
+
+	test("concurrent calls", async () => {
+		const results = await Promise.all([
+			api.math.grade1.add(10, 20),
+			api.math.grade2.multiply(10, 20)
+		])
+		expect(results).toEqual([30, 200])
+	})
+
+	test("stress test with concurrent calls", async () => {
+		// Run stress test 100 times
+		for (let iteration = 0; iteration < 100; iteration++) {
+			// Create 50 pairs of random numbers
+			const pairs = Array(50)
+				.fill(0)
+				.map(() => [Math.random(), Math.random()])
+			const expectedSums = pairs.map(([a, b]) => a + b)
+
+			// Make concurrent API calls
+			const actualSums = await Promise.all(pairs.map(([a, b]) => api.math.grade1.add(a, b)))
+
+			// Compare results
+			expect(actualSums).toEqual(expectedSums)
+		}
+	})
+
+	test("error handling - invalid endpoint", async () => {
+		const response = await fetch("http://localhost:3000/invalid")
+		expect(response.status).toBe(404)
+		expect(await response.text()).toBe("Not found")
+	})
+
+	test("error handling - wrong method", async () => {
+		const response = await fetch("http://localhost:3000/rpc", {
+			method: "GET"
+		})
+		expect(response.status).toBe(405)
+		expect(await response.text()).toBe("Method not allowed")
+	})
+})

package/__tests__/scripts/api.ts

@@ -0,0 +1,38 @@
+export interface API {
+	echo(message: string): Promise<string>
+	add(a: number, b: number): Promise<number>
+	subtract(a: number, b: number): Promise<number>
+	addCallback(a: number, b: number, callback: (result: number) => void): void
+	math: {
+		grade1: {
+			add(a: number, b: number, callback?: (result: number) => void): Promise<number>
+		}
+		grade2: {
+			multiply(a: number, b: number, callback?: (result: number) => void): Promise<number>
+		}
+	}
+}
+
+// Define your API methods
+export const apiMethods: API = {
+	echo: async (message: string) => message,
+	add: async (a: number, b: number) => a + b,
+	subtract: async (a: number, b: number) => a - b,
+	addCallback: async (a: number, b: number, callback?: (result: number) => void) => {
+		callback?.(a + b)
+	},
+	math: {
+		grade1: {
+			add: async (a: number, b: number, callback?: (result: number) => void) => {
+				callback?.(a + b)
+				return a + b
+			}
+		},
+		grade2: {
+			multiply: async (a: number, b: number, callback?: (result: number) => void) => {
+				callback?.(a * b)
+				return a * b
+			}
+		}
+	}
+}

package/__tests__/scripts/deno-api.ts

@@ -0,0 +1,5 @@
+import { DenoIo, RPCChannel } from "../../mod.ts"
+import { apiMethods } from "./api.ts"
+
+const io = new DenoIo(Deno.stdin.readable, Deno.stdout.writable)
+const child = new RPCChannel(io, apiMethods)

package/__tests__/scripts/node-api.ts

@@ -0,0 +1,5 @@
+import { NodeIo, RPCChannel } from "../../mod.ts"
+import { apiMethods } from "./api.ts"
+
+const stdio = new NodeIo(process.stdin, process.stdout)
+const child = new RPCChannel(stdio, apiMethods)

package/__tests__/scripts/worker.ts

@@ -0,0 +1,10 @@
+import { RPCChannel, WorkerChildIO, type DestroyableIoInterface } from "../../mod.ts"
+import { apiMethods, type API } from "./api.ts"
+
+const io: DestroyableIoInterface = new WorkerChildIO()
+const rpc = new RPCChannel<API, API, DestroyableIoInterface>(io, apiMethods)
+const api = rpc.getAPI()
+
+// const randInt1 = Math.floor(Math.random() * 100)
+// const randInt2 = Math.floor(Math.random() * 100)
+// api.add(randInt1, randInt2)

package/__tests__/serialization.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, test } from "bun:test"
+import {
+	deserializeMessage,
+	deserializeResponse,
+	serializeMessage,
+	serializeResponse,
+	type Message
+} from "../src/serialization.ts"
+
+describe("Serializer", () => {
+	test("should serialize and deserialize a message", async () => {
+		const message: Message = {
+			id: "1",
+			method: "testMethod",
+			args: [1, 2, 3],
+			type: "request"
+		}
+		const serialized = serializeMessage(message)
+		const deserialized = await deserializeMessage(serialized)
+		expect(deserialized).toEqual(message as any)
+	})
+
+	test("should serialize and deserialize a response", async () => {
+		const response = {
+			id: 1
+		}
+		const serializedResponse = serializeResponse(response as any)
+		const deserializedResponse = await deserializeResponse(serializedResponse)
+		expect(deserializedResponse).toEqual(response as any)
+	})
+})

package/__tests__/stdio-rpc.test.ts

@@ -0,0 +1,90 @@
+import { spawn } from "child_process"
+import type { ChildProcessWithoutNullStreams } from "node:child_process"
+import path from "node:path"
+import { sleep } from "bun"
+import { describe, expect, test } from "bun:test"
+import { DenoIo, NodeIo } from "../mod.ts"
+import { RPCChannel } from "../src/channel.ts"
+import { apiMethods, type API } from "./scripts/api.ts"
+
+function getProjectRoot(): string {
+	const fileUrl = new URL(import.meta.url).pathname
+	const folderPath = path.dirname(path.dirname(fileUrl))
+	return folderPath
+}
+
+const projectRoot = getProjectRoot()
+const testsPath = path.join(projectRoot, "__tests__")
+
+async function runWorker(worker: ChildProcessWithoutNullStreams) {
+	// worker.stderr.pipe(process.stdout);
+
+	// const stdio = createStdio();
+	const io = new NodeIo(worker.stdout, worker.stdin)
+	const rpc = new RPCChannel<{}, API>(io, {})
+	const api = rpc.getAPI()
+
+	expect(await api.add(1, 2)).toEqual(3)
+	const sum2 = await new Promise((resolve, reject) => {
+		api.addCallback(1, 2, (sum) => {
+			resolve(sum)
+		})
+	})
+
+	expect(sum2).toEqual(3)
+	expect(await api.subtract(1, 2)).toEqual(-1)
+
+	// stress test
+	for (let i = 0; i < 1000; i++) {
+		expect(await api.add(i, i)).toEqual(i + i)
+		expect(await api.subtract(i, i)).toEqual(0)
+	}
+	// stress test with concurrent calls
+	await Promise.all(
+		Array(5_000)
+			.fill(0)
+			.map(async (x, idx) => expect(await api.add(idx, idx)).toEqual(idx + idx))
+	)
+	await Promise.all(
+		Array(5_000)
+			.fill(0)
+			.map(() =>
+				api.addCallback(1, 2, (sum) => {
+					//   expect(sum).toEqual(3);
+				})
+			)
+	)
+	const dummyCallback = (sum: number) => {}
+	await Promise.all(
+		Array(5_000)
+			.fill(0)
+			.map(() => api.addCallback(1, 2, dummyCallback))
+	)
+
+	/* -------------------------------------------------------------------------- */
+	/*                              Nested Object API                             */
+	/* -------------------------------------------------------------------------- */
+	expect(await api.math.grade1.add(1, 2)).toEqual(3)
+	expect(await api.math.grade2.multiply(2, 3)).toEqual(6)
+
+	/* --------------------- Nested Object API with Callback -------------------- */
+	expect(await api.math.grade1.add(1, 2, (result) => expect(result).toEqual(3))).toEqual(3)
+	expect(await api.math.grade2.multiply(2, 3, (result) => expect(result).toEqual(6))).toEqual(6)
+
+	worker.kill()
+}
+
+describe("RPCChannel Test", () => {
+	test("DenoStdio", async () => {
+		const workerDeno = spawn("deno", [path.join(testsPath, "scripts/deno-api.ts")])
+		await runWorker(workerDeno)
+	})
+	test("NodeStdio", async () => {
+		const workerBun = spawn("node", [path.join(testsPath, "scripts/node-api.js")])
+		await runWorker(workerBun)
+	})
+	// test("NodeStdio with bun", async () => {
+	// 	const workerBun = spawn("bun", [path.join(testsPath, "scripts/node-api.ts")])
+	// 	await runWorker(workerBun)
+	// })
+})

package/__tests__/websocket.test.ts

@@ -0,0 +1,109 @@
+import { afterAll, beforeAll, expect, test } from "bun:test"
+import { WebSocketServer } from "ws"
+import { RPCChannel } from "../mod.ts"
+import { WebSocketClientIO, WebSocketServerIO } from "../src/adapters/websocket.ts"
+import type { DestroyableIoInterface } from "../src/interface.ts"
+import { apiMethods, type API } from "./scripts/api.ts"
+
+const PORT = 3001
+let wss: WebSocketServer
+let serverRPC: RPCChannel<API, API>
+
+beforeAll(() => {
+	// Create WebSocket server
+	wss = new WebSocketServer({ port: PORT })
+
+	// Handle WebSocket connections
+	wss.on("connection", (ws: WebSocket) => {
+		const serverIO = new WebSocketServerIO(ws)
+		serverRPC = new RPCChannel<API, API>(serverIO, apiMethods)
+	})
+})
+
+afterAll(() => {
+	wss.close()
+})
+
+test("WebSocket RPC", async () => {
+	const clientIO = new WebSocketClientIO({
+		url: `ws://localhost:${PORT}`
+	})
+
+	const clientRPC = new RPCChannel<API, API, DestroyableIoInterface>(clientIO, apiMethods)
+	const api = clientRPC.getAPI()
+
+	// Test individual calls
+	const sum = await api.add(5, 3)
+	expect(sum).toBe(8)
+
+	const product = await api.math.grade2.multiply(4, 6)
+	expect(product).toBe(24)
+
+	// Test concurrent calls
+	const results = await Promise.all([
+		api.add(10, 20),
+		api.math.grade2.multiply(10, 20),
+		api.add(30, 40),
+		api.math.grade2.multiply(30, 40)
+	])
+
+	expect(results).toEqual([30, 200, 70, 1200])
+
+	// Test multiple random calls
+	for (let i = 0; i < 100; i++) {
+		const a = Math.floor(Math.random() * 100)
+		const b = Math.floor(Math.random() * 100)
+
+		const sum = await api.add(a, b)
+		expect(sum).toBe(a + b)
+
+		const product = await api.math.grade2.multiply(a, b)
+		expect(product).toBe(a * b)
+	}
+
+	clientIO.destroy()
+})
+
+// test("WebSocket error handling", async () => {
+// 	const invalidPort = 54321
+// 	const clientIO = new WebSocketClientIO({
+// 		url: `ws://localhost:${invalidPort}`
+// 	})
+
+// 	const clientRPC = new RPCChannel<{}, API, DestroyableIoInterface>(clientIO, {})
+// 	const api = clientRPC.getAPI()
+// 	expect(() => api.add(1, 2)).toThrow()
+// 	clientIO.destroy()
+// })
+
+test("WebSocket concurrent connections", async () => {
+	const numClients = 5
+	const clients = Array.from({ length: numClients }, () => {
+		const clientIO = new WebSocketClientIO({
+			url: `ws://localhost:${PORT}`
+		})
+		return {
+			io: clientIO,
+			rpc: new RPCChannel<{}, API, DestroyableIoInterface>(clientIO, {})
+		}
+	})
+
+	try {
+		// Test concurrent calls from multiple clients
+		const results = await Promise.all(
+			clients.flatMap(({ rpc }) => {
+				const api = rpc.getAPI()
+				return [api.add(10, 20), api.math.grade2.multiply(10, 20)]
+			})
+		)
+
+		// Verify results
+		for (let i = 0; i < results.length; i += 2) {
+			expect(results[i]).toBe(30) // add result
+			expect(results[i + 1]).toBe(200) // multiply result
+		}
+	} finally {
+		// Cleanup
+		clients.forEach(({ io }) => io.destroy())
+	}
+})

package/browser-mod.ts

@@ -0,0 +1,7 @@
+export * from "./src/adapters/worker.ts"
+export * from "./src/adapters/node.ts"
+export * from "./src/interface.ts"
+export * from "./src/channel.ts"
+export * from "./src/utils.ts"
+export * from "./src/serialization.ts"
+export * from "./src/adapters/iframe.ts"

package/deno.json

@@ -0,0 +1,20 @@
+{
+	"name": "@kunkun/kkrpc",
+	"version": "0.0.2",
+	"tasks": {
+		"dev": "deno run --watch main.ts"
+	},
+	"exports": {
+		".": "./mod.ts",
+		"./browser": "./browser-mod.ts"
+	},
+	"imports": {
+		"@std/assert": "jsr:@std/assert@1"
+	},
+	"lint": {
+		"rules": {
+			"exclude": ["no-explicit-any"]
+		}
+	},
+	"license": "MIT"
+}

package/mod.ts

@@ -0,0 +1,9 @@
+export * from "./src/adapters/worker.ts"
+export * from "./src/adapters/node.ts"
+export * from "./src/adapters/websocket.ts"
+export * from "./src/adapters/http.ts"
+export * from "./src/interface.ts"
+export * from "./src/channel.ts"
+export * from "./src/utils.ts"
+export * from "./src/serialization.ts"
+export { DenoIo } from "./src/adapters/deno.ts"

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "kkrpc",
+  "module": "index.ts",
+  "version": "0.0.2",
+  "type": "module",
+  "exports": {
+    ".": "./mod.ts",
+    "./browser": "./browser-mod.ts"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@types/ws": "^8.5.10",
+    "typedoc": "^0.26.11"
+  },
+  "peerDependencies": {
+    "typescript": "^5.0.0"
+  },
+  "dependencies": {
+    "ws": "^8.16.0"
+  },
+  "scripts": {
+    "test": "bun run scripts/test.ts",
+    "docs": "typedoc --out docs"
+  }
+}

package/scripts/prepare.ts

@@ -0,0 +1,6 @@
+import { $ } from "bun"
+
+// const denoTypes = await $`deno types`.text()
+// // filter out the line with no-default-lib
+// const denoTypesFiltered = denoTypes.split("\n").filter((line) => !line.includes("no-default-lib"))
+// await Bun.write("./deno.d.ts", denoTypesFiltered.join("\n"))