@abndnce/pulsar-client 0.0.8 → 0.0.10

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.mts

@@ -23,12 +23,21 @@ declare function connectDirect(host: string, port: number): Promise<PulsarClient
 //#endregion
 //#region lib/connection/nostr.d.ts
 /**
- * Connect via a Nostr relay (placeholder).
+ * Establish a Pulsar tunnel via Nostr relay signaling.
  *
- * In the future, this will implement a Nostr-based signaling layer for
- * establishing peer connections through a Nostr relay.
+ * 1. Connects to a Nostr relay (tries nostr.data.haus first,
+ *    then kotukonostr.onrender.com)
+ * 2. Looks up the tunnel's discovery event (Kind 38000, d="pulsar-tunnel").
+ *    If `tunnelCode` is given (e.g. "a3f2"), filters to the tunnel
+ *    whose pubkey begins with those 4 hex characters.
+ * 3. Generates an ephemeral client keypair
+ * 4. Creates a WebRTC offer
+ * 5. Encrypts the offer and sends via a Kind 28000 ephemeral event
+ * 6. Waits for the encrypted answer
+ * 7. Sets the answer as remote description
+ * 8. Returns the connected PulsarClientConnection
  */
-declare function connectNostr(_relay: string, _pubkey: string): Promise<PulsarClientConnection>;
+declare function connectNostr(tunnelCode?: string): Promise<PulsarClientConnection>;
 //#endregion
 //#region lib/socket-channel.d.ts
 /**
@@ -39,9 +48,14 @@ declare function connectNostr(_relay: string, _pubkey: string): Promise<PulsarCl
  */
 /**
  * Wait for an RTCDataChannel to enter the "open" state.
- * Rejects if it closes or errors before opening.
+ *
+ * Also monitors the RTCPeerConnection for failure/closure, and
+ * accepts an optional AbortSignal for cancellation.
+ *
+ * Rejects if the channel closes, the peer connection fails, or
+ * the timeout elapses before the channel opens.
  */
-declare function waitForDataChannelOpen(channel: RTCDataChannel, timeoutMs?: number): Promise<void>;
+declare function waitForDataChannelOpen(channel: RTCDataChannel, pc: RTCPeerConnection, timeoutMs?: number, signal?: AbortSignal): Promise<void>;
 /**
  * Create a data channel on the given `pc` with the Pulsar socket label
  * convention (`socket/<hostname>:<port>`) and wait for it to open.
@@ -49,34 +63,47 @@ declare function waitForDataChannelOpen(channel: RTCDataChannel, timeoutMs?: num
  * This is the low-level primitive used by `connect()` and
  * `libcurlTransport()`.
  */
-declare function openSocketChannel(pc: RTCPeerConnection, hostname: string, port: number, timeoutMs?: number): Promise<RTCDataChannel>;
+declare function openSocketChannel(pc: RTCPeerConnection, hostname: string, port: number, timeoutMs?: number, signal?: AbortSignal): Promise<RTCDataChannel>;
 //#endregion
 //#region lib/tunnel.d.ts
 /**
- * A minimal WebSocket-like wrapper around an RTCDataChannel.
+ * WebSocket-compatible wrapper around an RTCDataChannel.
  *
- * libcurl.js expects its transport factory to return objects
- * with `send()`, `close()`, `onopen`, `onmessage`, `onclose`,
- * and `onerror` — which is exactly the RTCDataChannel API, so
- * the wrapper is thin.
+ * libcurl.js compares `readyState` against `WebSocket.OPEN` (numeric 1)
+ * and expects static constants (`CONNECTING`, `OPEN`, `CLOSING`, `CLOSED`).
+ * Using `EventTarget` ensures `addEventListener` / `removeEventListener`
+ * work, which libcurl's poll loop depends on.
  */
-declare class DataChannelSocket {
+declare class DataChannelSocket extends EventTarget {
+  static readonly CONNECTING = 0;
+  static readonly OPEN = 1;
+  static readonly CLOSING = 2;
+  static readonly CLOSED = 3;
+  readonly CONNECTING = 0;
+  readonly OPEN = 1;
+  readonly CLOSING = 2;
+  readonly CLOSED = 3;
+  readonly url: string;
+  readonly protocol = "";
+  readonly extensions = "";
+  binaryType: string;
+  onopen: ((event: Event) => void) | null;
+  onclose: ((event: CloseEvent) => void) | null;
+  onerror: ((event: Event) => void) | null;
+  onmessage: ((event: MessageEvent) => void) | null;
   private _channel;
   private _closed;
-  onopen: (() => void) | null;
-  onmessage: ((event: {
-    data: ArrayBuffer | string;
-  }) => void) | null;
-  onclose: (() => void) | null;
-  onerror: ((event: {
-    error?: string;
-  }) => void) | null;
-  constructor(channel: RTCDataChannel);
-  get readyState(): string;
-  get binaryType(): string;
-  set binaryType(_: string);
-  send(data: ArrayBuffer | string | ArrayBufferView): void;
+  private _closeDispatched;
+  private _readyState;
+  constructor(pc: RTCPeerConnection, destination: string);
+  private _open;
+  get readyState(): number;
+  get bufferedAmount(): number;
+  send(data: string | ArrayBufferLike | ArrayBufferView): void;
   close(): void;
+  private _dispatch;
+  private _dispatchError;
+  private _dispatchClose;
 }
 /**
  * Create a libcurl.js transport factory from an existing WebRTC
@@ -87,14 +114,13 @@ declare class DataChannelSocket {
  * import { connectDirect, libcurlTransport } from '@abndnce/pulsar-client';
  * import { libcurl } from 'libcurl.js';
  *
- * const tunnel = await connectDirect('216.250.119.217', 42069);
+ * const tunnel = await connectDirect('1.2.3.4', 1234);
  * libcurl.transport = libcurlTransport(tunnel.pc);
  * libcurl.set_websocket('wss://pulsar-tunnel.local/');
  * ```
  *
  * libcurl.js calls the factory with URLs like:
  *   `wss://pulsar-tunnel.local/example.com:80`
- *   `wss://pulsar-tunnel.local/216.250.119.217:443`
  *
  * The factory parses `<hostname>:<port>` from the URL path, opens a
  * Pulsar socket data channel, and returns a WebSocket-like adapter.

package/dist/index.mjs

@@ -1,3 +1,4 @@
+import { schnorr, secp256k1 } from "@noble/curves/secp256k1";
 //#region ../core/constants.ts
 const PULSAR_UFRAG = "pulsar";
 const PULSAR_PWD = "pulsarpulsarpulsarpuls";
@@ -71,15 +72,349 @@ async function connectDirect(host, port) {
 	};
 }
 //#endregion
+//#region ../core/nostr.ts
+const NOSTR_RELAYS = ["wss://nostr.data.haus", "wss://kotukonostr.onrender.com"];
+/** Ephemeral event kind used for encrypted WebRTC signaling. */
+const SIGNALING_KIND = 28e3;
+/** Parameterized replaceable event kind used for server discovery. */
+const DISCOVERY_KIND = 38e3;
+/** The `d` tag identifier for the Pulsar tunnel discovery event. */
+const D_TAG_ID = "pulsar-tunnel";
+//#endregion
 //#region lib/connection/nostr.ts
+function hexToBytes(hex) {
+	const bytes = new Uint8Array(hex.length / 2);
+	for (let i = 0; i < hex.length; i += 2) bytes[i / 2] = parseInt(hex.slice(i, i + 2), 16);
+	return bytes;
+}
+function bytesToHex(bytes) {
+	return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function generateKeypair() {
+	const seckey = secp256k1.utils.randomPrivateKey();
+	const pubkey = secp256k1.getPublicKey(seckey, true).slice(1);
+	return {
+		seckey: bytesToHex(seckey),
+		pubkey: bytesToHex(pubkey)
+	};
+}
+/**
+* Derive a shared ECDH secret between a private key and a peer's
+* 32-byte x-only public key (Nostr format).
+*
+* Schnorr public keys always have even y, so we reconstruct the
+* full point via ProjectivePoint and do scalar multiplication.
+*/
+function getSharedXOnly(seckey, pubkeyXOnly) {
+	const compressed = new Uint8Array(33);
+	compressed[0] = 2;
+	compressed.set(pubkeyXOnly, 1);
+	const pubPoint = secp256k1.ProjectivePoint.fromHex(compressed);
+	const scalar = bytesToBigInt(seckey);
+	const shared = pubPoint.multiply(scalar);
+	return new Uint8Array(shared.toRawBytes(false).slice(1, 33));
+}
+function bytesToBigInt(bytes) {
+	let hex = "";
+	for (const b of bytes) hex += b.toString(16).padStart(2, "0");
+	return BigInt("0x" + hex);
+}
+async function getConversationKey(seckeyBytes, pubkeyBytes) {
+	const sharedSecret = getSharedXOnly(seckeyBytes, pubkeyBytes);
+	const hkdfKey = await crypto.subtle.importKey("raw", sharedSecret, "HKDF", false, ["deriveBits", "deriveKey"]);
+	return crypto.subtle.deriveKey({
+		name: "HKDF",
+		hash: "SHA-256",
+		salt: new Uint8Array(0),
+		info: new TextEncoder().encode("nip44-v2")
+	}, hkdfKey, {
+		name: "AES-GCM",
+		length: 256
+	}, false, ["encrypt", "decrypt"]);
+}
+async function nip44Encrypt(plaintext, seckeyHex, pubkeyHex) {
+	const convKey = await getConversationKey(hexToBytes(seckeyHex), hexToBytes(pubkeyHex));
+	const nonce = crypto.getRandomValues(new Uint8Array(12));
+	const encoded = new TextEncoder().encode(plaintext);
+	const encrypted = await crypto.subtle.encrypt({
+		name: "AES-GCM",
+		iv: nonce,
+		tagLength: 128
+	}, convKey, encoded);
+	const result = new Uint8Array(13 + encrypted.byteLength);
+	result[0] = 2;
+	result.set(nonce, 1);
+	result.set(new Uint8Array(encrypted), 13);
+	return btoa(String.fromCharCode(...result));
+}
+async function nip44Decrypt(ciphertextB64, seckeyHex, pubkeyHex) {
+	const convKey = await getConversationKey(hexToBytes(seckeyHex), hexToBytes(pubkeyHex));
+	const raw = Uint8Array.from(atob(ciphertextB64), (c) => c.charCodeAt(0));
+	if (raw.length < 13) throw new Error("Ciphertext too short");
+	const nonce = raw.slice(1, 13);
+	const ciphertext = raw.slice(13);
+	const decrypted = await crypto.subtle.decrypt({
+		name: "AES-GCM",
+		iv: nonce,
+		tagLength: 128
+	}, convKey, ciphertext);
+	return new TextDecoder().decode(decrypted);
+}
+function serializeEvent(ev) {
+	return JSON.stringify([
+		0,
+		ev.pubkey,
+		ev.created_at,
+		ev.kind,
+		ev.tags,
+		ev.content
+	]);
+}
+async function computeEventId(ev) {
+	const hash = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(serializeEvent(ev)));
+	return bytesToHex(new Uint8Array(hash));
+}
+async function signEvent(ev, seckey) {
+	const id = await computeEventId(ev);
+	const sig = schnorr.sign(hexToBytes(id), seckey);
+	return {
+		...ev,
+		id,
+		sig: bytesToHex(sig)
+	};
+}
+function connectRelay(url, timeoutMs = 1e4) {
+	return new Promise((resolve, reject) => {
+		const ws = new WebSocket(url);
+		const timeout = setTimeout(() => {
+			ws.close();
+			reject(/* @__PURE__ */ new Error(`Connection to ${url} timed out`));
+		}, timeoutMs);
+		ws.addEventListener("open", () => {
+			clearTimeout(timeout);
+			resolve(ws);
+		});
+		ws.addEventListener("error", () => {
+			clearTimeout(timeout);
+			reject(/* @__PURE__ */ new Error(`Failed to connect to ${url}`));
+		});
+	});
+}
+/**
+* Try each relay in order until one connects successfully.
+*/
+async function connectToAnyRelay() {
+	const errors = [];
+	for (const relayUrl of NOSTR_RELAYS) try {
+		const ws = await connectRelay(relayUrl);
+		console.log(`[nostr] Connected to ${relayUrl}`);
+		return ws;
+	} catch (err) {
+		const msg = err instanceof Error ? err.message : String(err);
+		errors.push(msg);
+		console.warn(`[nostr] ${relayUrl}: ${msg}`);
+	}
+	throw new Error(`Failed to connect to any Nostr relay: ${errors.join("; ")}`);
+}
+/**
+* Wait for a single event matching a filter, with timeout.
+*/
+function waitForEvent(ws, subId, filter, timeoutMs = 15e3) {
+	return new Promise((resolve, reject) => {
+		const timeout = setTimeout(() => {
+			ws.send(JSON.stringify(["CLOSE", subId]));
+			reject(/* @__PURE__ */ new Error("Timed out waiting for Nostr event"));
+		}, timeoutMs);
+		ws.send(JSON.stringify([
+			"REQ",
+			subId,
+			filter
+		]));
+		const onMessage = (event) => {
+			let msg;
+			try {
+				msg = JSON.parse(event.data);
+			} catch {
+				return;
+			}
+			if (msg[0] === "EVENT" && msg[1] === subId) {
+				clearTimeout(timeout);
+				ws.removeEventListener("message", onMessage);
+				ws.send(JSON.stringify(["CLOSE", subId]));
+				resolve(msg[2]);
+			}
+		};
+		ws.addEventListener("message", onMessage);
+	});
+}
+const defaultIceServers = [{ urls: "stun:stun.l.google.com:19302" }, { urls: "stun:global.stun.twilio.com:3478" }];
+/**
+* Represents a Pulsar tunnel connection established via Nostr signaling.
+*/
+var NostrClientConnection = class {
+	keepalive;
+	pc;
+	_ws;
+	_seckey;
+	_serverPubkey;
+	constructor(keepalive, pc, _ws, _seckey, _serverPubkey) {
+		this.keepalive = keepalive;
+		this.pc = pc;
+		this._ws = _ws;
+		this._seckey = _seckey;
+		this._serverPubkey = _serverPubkey;
+	}
+	async close() {
+		try {
+			this.keepalive.close();
+		} catch {}
+		try {
+			this.pc.close();
+		} catch {}
+		try {
+			this._ws.close();
+		} catch {}
+	}
+};
+/**
+* Find a Pulsar server via discovery events.
+*
+* If `pubkeyPrefix` is given (4 hex chars), returns the first server
+* whose pubkey starts with that prefix. Otherwise returns any server.
+*/
+async function findServer(ws, pubkeyPrefix, timeoutMs = 15e3) {
+	return new Promise((resolve, reject) => {
+		const timeout = setTimeout(() => {
+			ws.send(JSON.stringify(["CLOSE", "pulsar-discover"]));
+			reject(/* @__PURE__ */ new Error(pubkeyPrefix ? `No Pulsar server with tunnel code "pulsar${pubkeyPrefix}" found` : "No Pulsar server found on Nostr relay"));
+		}, timeoutMs);
+		const subId = "pulsar-discover";
+		ws.send(JSON.stringify([
+			"REQ",
+			subId,
+			{
+				kinds: [DISCOVERY_KIND],
+				"#d": [D_TAG_ID],
+				limit: 0
+			}
+		]));
+		const onMessage = (event) => {
+			let msg;
+			try {
+				msg = JSON.parse(event.data);
+			} catch {
+				return;
+			}
+			if (msg[0] === "EVENT" && msg[1] === subId) {
+				const ev = msg[2];
+				if (pubkeyPrefix) {
+					if (ev.pubkey.startsWith(pubkeyPrefix)) {
+						clearTimeout(timeout);
+						ws.removeEventListener("message", onMessage);
+						ws.send(JSON.stringify(["CLOSE", subId]));
+						resolve(ev.pubkey);
+					}
+				} else {
+					clearTimeout(timeout);
+					ws.removeEventListener("message", onMessage);
+					ws.send(JSON.stringify(["CLOSE", subId]));
+					resolve(ev.pubkey);
+				}
+			}
+		};
+		ws.addEventListener("message", onMessage);
+	});
+}
 /**
-* Connect via a Nostr relay (placeholder).
+* Establish a Pulsar tunnel via Nostr relay signaling.
 *
-* In the future, this will implement a Nostr-based signaling layer for
-* establishing peer connections through a Nostr relay.
+* 1. Connects to a Nostr relay (tries nostr.data.haus first,
+*    then kotukonostr.onrender.com)
+* 2. Looks up the tunnel's discovery event (Kind 38000, d="pulsar-tunnel").
+*    If `tunnelCode` is given (e.g. "a3f2"), filters to the tunnel
+*    whose pubkey begins with those 4 hex characters.
+* 3. Generates an ephemeral client keypair
+* 4. Creates a WebRTC offer
+* 5. Encrypts the offer and sends via a Kind 28000 ephemeral event
+* 6. Waits for the encrypted answer
+* 7. Sets the answer as remote description
+* 8. Returns the connected PulsarClientConnection
 */
-async function connectNostr(_relay, _pubkey) {
-	throw new Error("Nostr mode not yet implemented");
+async function connectNostr(tunnelCode) {
+	const ws = await connectToAnyRelay();
+	const pubkeyPrefix = tunnelCode ? tunnelCode.replace(/^pulsar/, "").slice(0, 4) : void 0;
+	console.log("[nostr] Looking up Pulsar tunnel" + (pubkeyPrefix ? ` (code ${tunnelCode})` : "") + "...");
+	const serverPubkey = await findServer(ws, pubkeyPrefix);
+	console.log(`[nostr] Found server: ${serverPubkey.slice(0, 16)}...`);
+	const clientKeys = generateKeypair();
+	console.log(`[nostr] Client pubkey: ${clientKeys.pubkey.slice(0, 16)}...`);
+	const pc = new RTCPeerConnection({ iceServers: defaultIceServers });
+	const keepalive = pc.createDataChannel(KEEPALIVE_LABEL, { ordered: true });
+	keepalive.binaryType = "arraybuffer";
+	const offer = await pc.createOffer();
+	await pc.setLocalDescription(offer);
+	await new Promise((resolve) => {
+		const timeout = setTimeout(() => resolve(), 2e3);
+		const onStateChange = () => {
+			if (pc.iceGatheringState === "complete") {
+				clearTimeout(timeout);
+				resolve();
+			}
+		};
+		const onCandidate = (event) => {
+			if (!event.candidate) {
+				clearTimeout(timeout);
+				resolve();
+			}
+		};
+		pc.addEventListener("icegatheringstatechange", onStateChange);
+		pc.addEventListener("icecandidate", onCandidate);
+	});
+	const localDesc = pc.localDescription;
+	if (!localDesc) throw new Error("Failed to create local offer");
+	const offerPayload = {
+		type: "offer",
+		sdp: localDesc.sdp
+	};
+	const encryptedOffer = await nip44Encrypt(JSON.stringify(offerPayload), clientKeys.seckey, serverPubkey);
+	const offerEvent = await signEvent({
+		pubkey: clientKeys.pubkey,
+		created_at: Math.floor(Date.now() / 1e3),
+		kind: SIGNALING_KIND,
+		tags: [["p", serverPubkey]],
+		content: encryptedOffer
+	}, hexToBytes(clientKeys.seckey));
+	const answerPromise = waitForEvent(ws, "pulsar-answer", {
+		kinds: [SIGNALING_KIND],
+		"#p": [clientKeys.pubkey],
+		limit: 1
+	}, 3e4);
+	ws.send(JSON.stringify(["EVENT", offerEvent]));
+	console.log("[nostr] Sent encrypted offer, waiting for answer...");
+	const answerPlaintext = await nip44Decrypt((await answerPromise).content, clientKeys.seckey, serverPubkey);
+	const answerPayload = JSON.parse(answerPlaintext);
+	if (answerPayload.type !== "answer" || !answerPayload.sdp) throw new Error("Invalid answer from server");
+	console.log("[nostr] Received answer, connecting WebRTC...");
+	await pc.setRemoteDescription({
+		type: "answer",
+		sdp: answerPayload.sdp
+	});
+	await new Promise((resolve, reject) => {
+		const timeout = setTimeout(() => {
+			reject(/* @__PURE__ */ new Error("WebRTC connection timed out after 30s"));
+		}, 3e4);
+		pc.addEventListener("connectionstatechange", () => {
+			if (pc.connectionState === "connected") {
+				clearTimeout(timeout);
+				resolve();
+			} else if (pc.connectionState === "failed" || pc.connectionState === "disconnected") {
+				clearTimeout(timeout);
+				reject(/* @__PURE__ */ new Error(`Connection failed: ${pc.connectionState}`));
+			}
+		});
+	});
+	console.log("[nostr] WebRTC connected!");
+	return new NostrClientConnection(keepalive, pc, ws, clientKeys.seckey, serverPubkey);
 }
 //#endregion
 //#region lib/socket-channel.ts
@@ -91,10 +426,19 @@ async function connectNostr(_relay, _pubkey) {
 */
 /**
 * Wait for an RTCDataChannel to enter the "open" state.
-* Rejects if it closes or errors before opening.
+*
+* Also monitors the RTCPeerConnection for failure/closure, and
+* accepts an optional AbortSignal for cancellation.
+*
+* Rejects if the channel closes, the peer connection fails, or
+* the timeout elapses before the channel opens.
 */
-function waitForDataChannelOpen(channel, timeoutMs = 1e4) {
+function waitForDataChannelOpen(channel, pc, timeoutMs = 1e4, signal) {
 	return new Promise((resolve, reject) => {
+		if (signal?.aborted) {
+			reject(new DOMException("The operation was aborted.", "AbortError"));
+			return;
+		}
 		if (channel.readyState === "open") {
 			resolve();
 			return;
@@ -105,22 +449,39 @@ function waitForDataChannelOpen(channel, timeoutMs = 1e4) {
 		}, timeoutMs);
 		const cleanup = () => {
 			clearTimeout(timeout);
-			channel.onopen = null;
-			channel.onclose = null;
-			channel.onerror = null;
+			channel.removeEventListener("open", onOpen);
+			channel.removeEventListener("close", onClose);
+			channel.removeEventListener("error", onError);
+			pc.removeEventListener("connectionstatechange", onStateChange);
+			signal?.removeEventListener("abort", onAbort);
 		};
-		channel.onopen = () => {
+		const onOpen = () => {
 			cleanup();
 			resolve();
 		};
-		channel.onclose = () => {
+		const onClose = () => {
 			cleanup();
 			reject(/* @__PURE__ */ new Error("DataChannel closed before opening"));
 		};
-		channel.onerror = (e) => {
+		const onError = () => {
 			cleanup();
-			reject(/* @__PURE__ */ new Error(`DataChannel error before opening: ${e}`));
+			reject(/* @__PURE__ */ new Error("DataChannel error before opening"));
 		};
+		const onStateChange = () => {
+			if (pc.connectionState === "failed" || pc.connectionState === "closed") {
+				cleanup();
+				reject(/* @__PURE__ */ new Error(`Peer connection ${pc.connectionState}`));
+			}
+		};
+		const onAbort = () => {
+			cleanup();
+			reject(new DOMException("The operation was aborted.", "AbortError"));
+		};
+		channel.addEventListener("open", onOpen, { once: true });
+		channel.addEventListener("close", onClose, { once: true });
+		channel.addEventListener("error", onError, { once: true });
+		pc.addEventListener("connectionstatechange", onStateChange);
+		signal?.addEventListener("abort", onAbort, { once: true });
 	});
 }
 /**
@@ -130,60 +491,111 @@ function waitForDataChannelOpen(channel, timeoutMs = 1e4) {
 * This is the low-level primitive used by `connect()` and
 * `libcurlTransport()`.
 */
-function openSocketChannel(pc, hostname, port, timeoutMs) {
+function openSocketChannel(pc, hostname, port, timeoutMs, signal) {
 	const label = `${SOCKET_PREFIX}${hostname}:${port}`;
 	const channel = pc.createDataChannel(label, { ordered: true });
-	return waitForDataChannelOpen(channel, timeoutMs).then(() => channel);
+	return waitForDataChannelOpen(channel, pc, timeoutMs, signal).then(() => channel);
 }
 //#endregion
 //#region lib/tunnel.ts
 /**
-* A minimal WebSocket-like wrapper around an RTCDataChannel.
+* WebSocket-compatible wrapper around an RTCDataChannel.
 *
-* libcurl.js expects its transport factory to return objects
-* with `send()`, `close()`, `onopen`, `onmessage`, `onclose`,
-* and `onerror` — which is exactly the RTCDataChannel API, so
-* the wrapper is thin.
+* libcurl.js compares `readyState` against `WebSocket.OPEN` (numeric 1)
+* and expects static constants (`CONNECTING`, `OPEN`, `CLOSING`, `CLOSED`).
+* Using `EventTarget` ensures `addEventListener` / `removeEventListener`
+* work, which libcurl's poll loop depends on.
 */
-var DataChannelSocket = class {
-	_channel;
-	_closed = false;
+var DataChannelSocket = class DataChannelSocket extends EventTarget {
+	static CONNECTING = 0;
+	static OPEN = 1;
+	static CLOSING = 2;
+	static CLOSED = 3;
+	CONNECTING = 0;
+	OPEN = 1;
+	CLOSING = 2;
+	CLOSED = 3;
+	url;
+	protocol = "";
+	extensions = "";
+	binaryType = "arraybuffer";
 	onopen = null;
-	onmessage = null;
 	onclose = null;
 	onerror = null;
-	constructor(channel) {
+	onmessage = null;
+	_channel = null;
+	_closed = false;
+	_closeDispatched = false;
+	_readyState = DataChannelSocket.CONNECTING;
+	constructor(pc, destination) {
+		super();
+		this.url = `wss://pulsar-tunnel.local/${destination}`;
+		const channel = pc.createDataChannel(`${SOCKET_PREFIX}${destination}`, { ordered: true });
+		channel.binaryType = "arraybuffer";
 		this._channel = channel;
-		channel.onopen = () => {
-			if (!this._closed) this.onopen?.();
-		};
+		this._open(channel, pc);
+	}
+	async _open(channel, pc) {
+		try {
+			await waitForDataChannelOpen(channel, pc);
+		} catch (error) {
+			if (!this._closed) {
+				console.error(`[DataChannelSocket] Failed to open channel: ${error instanceof Error ? error.message : String(error)}`);
+				this._dispatchError();
+			}
+			this._dispatchClose();
+			return;
+		}
+		if (this._closed) {
+			channel.close();
+			this._dispatchClose();
+			return;
+		}
+		this._channel = channel;
+		this._readyState = DataChannelSocket.OPEN;
 		channel.onmessage = (event) => {
-			if (!this._closed) this.onmessage?.({ data: event.data });
+			this._dispatch(new MessageEvent("message", { data: event.data }));
 		};
 		channel.onclose = () => {
-			this._closed = true;
-			this.onclose?.();
+			this._readyState = DataChannelSocket.CLOSED;
+			this._dispatchClose();
 		};
-		channel.onerror = (event) => {
-			this.onerror?.({ error: String(event) });
+		channel.onerror = () => {
+			this._dispatchError();
 		};
+		this._dispatch(new Event("open"));
 	}
 	get readyState() {
-		return this._channel.readyState;
+		return this._readyState;
 	}
-	get binaryType() {
-		return "arraybuffer";
+	get bufferedAmount() {
+		return this._channel?.bufferedAmount ?? 0;
 	}
-	set binaryType(_) {}
 	send(data) {
-		if (this._closed || this._channel.readyState !== "open") return;
-		this._channel.send(data);
+		if (this._readyState !== DataChannelSocket.OPEN || !this._channel) throw new Error("DataChannelSocket is not open");
+		if (typeof data === "string") this._channel.send(data);
+		else this._channel.send(data);
 	}
 	close() {
+		if (this._closed) return;
 		this._closed = true;
-		try {
-			this._channel.close();
-		} catch {}
+		if (this._channel && this._channel.readyState !== "closed") this._channel.close();
+		else this._dispatchClose();
+	}
+	_dispatch(event) {
+		const handlerName = `on${event.type}`;
+		const handler = this[handlerName];
+		if (handler) handler(event);
+		this.dispatchEvent(event);
+	}
+	_dispatchError() {
+		this._dispatch(new Event("error"));
+	}
+	_dispatchClose() {
+		if (this._closeDispatched) return;
+		this._closeDispatched = true;
+		this._readyState = DataChannelSocket.CLOSED;
+		this._dispatch(new CloseEvent("close"));
 	}
 };
 /**
@@ -195,14 +607,13 @@ var DataChannelSocket = class {
 * import { connectDirect, libcurlTransport } from '@abndnce/pulsar-client';
 * import { libcurl } from 'libcurl.js';
 *
-* const tunnel = await connectDirect('216.250.119.217', 42069);
+* const tunnel = await connectDirect('1.2.3.4', 1234);
 * libcurl.transport = libcurlTransport(tunnel.pc);
 * libcurl.set_websocket('wss://pulsar-tunnel.local/');
 * ```
 *
 * libcurl.js calls the factory with URLs like:
 *   `wss://pulsar-tunnel.local/example.com:80`
-*   `wss://pulsar-tunnel.local/216.250.119.217:443`
 *
 * The factory parses `<hostname>:<port>` from the URL path, opens a
 * Pulsar socket data channel, and returns a WebSocket-like adapter.
@@ -218,7 +629,7 @@ function libcurlTransport(pc) {
 		}
 		if (!dest) throw new Error(`libcurl transport: no destination found in URL "${url}"`);
 		if (dest.lastIndexOf(":") === -1) throw new Error(`libcurl transport: invalid destination "${dest}" — expected "hostname:port"`);
-		return new DataChannelSocket(pc.createDataChannel(`${SOCKET_PREFIX}${dest}`, { ordered: true }));
+		return new DataChannelSocket(pc, dest);
 	};
 }
 //#endregion

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@abndnce/pulsar-client",
   "type": "module",
-  "version": "0.0.8",
+  "version": "0.0.10",
   "homepage": "https://github.com/abndnce/pulsar",
   "license": "MIT",
   "exports": {
@@ -11,6 +11,9 @@
   "files": [
     "dist"
   ],
+  "dependencies": {
+    "@noble/curves": "^1.8.1"
+  },
   "devDependencies": {
     "tsdown": "^0.22.0",
     "typescript": "^6.0.3"