@moq/web-transport 0.0.4 → 0.1.0

package/README.md

@@ -0,0 +1,97 @@
+# @moq/web-transport
+
+WebTransport for Node.js, powered by QUIC and HTTP/3.
+
+This package provides both a client-side `WebTransport` polyfill and a server implementation.
+
+## Install
+
+```bash
+npm install @moq/web-transport
+```
+
+## Client
+
+The `Session` class implements the [W3C WebTransport API](https://www.w3.org/TR/webtransport/).
+
+```ts
+import Session from "@moq/web-transport";
+
+const session = new Session("https://example.com:4443");
+await session.ready;
+
+// Bidirectional streams
+const bidi = await session.createBidirectionalStream();
+const writer = bidi.writable.getWriter();
+await writer.write(new Uint8Array([1, 2, 3]));
+await writer.close();
+
+// Unidirectional streams
+const uni = await session.createUnidirectionalStream();
+const uniWriter = uni.getWriter();
+await uniWriter.write(new Uint8Array([4, 5, 6]));
+await uniWriter.close();
+
+// Datagrams
+const dgWriter = session.datagrams.writable.getWriter();
+await dgWriter.write(new Uint8Array([7, 8, 9]));
+
+// Incoming streams
+for await (const recv of session.incomingUnidirectionalStreams) {
+	const reader = recv.getReader();
+	// read from reader...
+}
+
+session.close();
+```
+
+### Polyfill
+
+Use `install()` to register `Session` as the global `WebTransport` if one doesn't already exist:
+
+```ts
+import { install } from "@moq/web-transport";
+install();
+
+// Now use the standard WebTransport API
+const session = new WebTransport("https://example.com:4443");
+```
+
+### Certificate Options
+
+```ts
+// Skip certificate verification (testing only!)
+const session = new Session("https://localhost:4443", {
+	serverCertificateDisableVerify: true,
+});
+
+// Pin to specific certificate hashes
+const session = new Session("https://example.com:4443", {
+	serverCertificateHashes: [
+		{ algorithm: "sha-256", value: hashBuffer },
+	],
+});
+```
+
+## Server
+
+```ts
+import { Server } from "@moq/web-transport";
+import fs from "node:fs";
+
+const certPem = fs.readFileSync("cert.pem");
+const keyPem = fs.readFileSync("key.pem");
+
+const server = Server.bind("[::]:4443", certPem, keyPem);
+
+while (true) {
+	const request = await server.accept();
+	if (!request) break;
+
+	const url = await request.url;
+	console.log("incoming request:", url);
+
+	const session = await request.ok();
+	// Use session just like the client-side API
+}
+```

package/{index.d.ts → napi.d.ts}

@@ -59,6 +59,8 @@ export declare class NapiServer {
 	static bind(addr: string, certPem: Buffer, keyPem: Buffer): NapiServer;
 	/** Accept the next incoming WebTransport session request. */
 	accept(): Promise<NapiRequest | null>;
+	/** Close the server, stopping it from accepting new connections. */
+	close(): void;
 }
 
 /** An established WebTransport session. */

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@moq/web-transport",
-	"version": "0.0.4",
+	"version": "0.1.0",
 	"description": "WebTransport polyfill for Node.js via QUIC/HTTP3",
 	"type": "module",
 	"license": "(MIT OR Apache-2.0)",
@@ -21,12 +21,12 @@
 	"types": "./src/index.ts",
 	"files": [
 		"./src",
-		"index.js",
-		"index.d.ts",
+		"napi.js",
+		"napi.d.ts",
 		"*.node"
 	],
 	"scripts": {
-		"build": "napi build --platform --release --manifest-path ../../rs/web-transport-node/Cargo.toml --output-dir .",
+		"build": "napi build --platform --release --manifest-path ../../rs/web-transport-node/Cargo.toml --output-dir . --js napi.js --dts napi.d.ts",
 		"check": "tsc --noEmit",
 		"release": "bun scripts/release.ts"
 	},
@@ -36,11 +36,11 @@
 		"@types/node": "^24.3.0"
 	},
 	"optionalDependencies": {
-		"@moq/web-transport-darwin-x64": "0.0.4",
-		"@moq/web-transport-darwin-arm64": "0.0.4",
-		"@moq/web-transport-win32-x64-msvc": "0.0.4",
-		"@moq/web-transport-linux-x64-gnu": "0.0.4",
-		"@moq/web-transport-linux-arm64-gnu": "0.0.4"
+		"@moq/web-transport-darwin-x64": "0.1.0",
+		"@moq/web-transport-darwin-arm64": "0.1.0",
+		"@moq/web-transport-win32-x64-msvc": "0.1.0",
+		"@moq/web-transport-linux-x64-gnu": "0.1.0",
+		"@moq/web-transport-linux-arm64-gnu": "0.1.0"
 	},
 	"keywords": [
 		"webtransport",

package/src/datagrams.ts

@@ -1,4 +1,4 @@
-import type { NapiSession } from "../index.js";
+import type { NapiSession } from "../napi.js";
 
 export class Datagrams implements WebTransportDatagramDuplexStream {
 	readonly readable: ReadableStream<Uint8Array>;

package/src/index.ts

@@ -9,4 +9,6 @@ export function install(): boolean {
 }
 
 export default Session;
-export { NapiRequest, NapiServer } from "../index.js";
+export { Request } from "./request.ts";
+export { Server } from "./server.ts";
+export type { SessionOptions } from "./session.ts";

package/src/request.ts

@@ -0,0 +1,24 @@
+import type { NapiRequest } from "../napi.js";
+import Session from "./session.ts";
+
+export class Request {
+	#inner: NapiRequest;
+
+	/** @internal */
+	constructor(inner: NapiRequest) {
+		this.#inner = inner;
+	}
+
+	get url(): Promise<string> {
+		return this.#inner.url;
+	}
+
+	async ok(): Promise<Session> {
+		const session = await this.#inner.ok();
+		return new Session(session);
+	}
+
+	reject(status: number): Promise<void> {
+		return this.#inner.reject(status);
+	}
+}

package/src/server.ts

@@ -0,0 +1,24 @@
+import { NapiServer } from "../napi.js";
+import { Request } from "./request.ts";
+
+export class Server {
+	#inner: NapiServer;
+
+	private constructor(inner: NapiServer) {
+		this.#inner = inner;
+	}
+
+	static bind(addr: string, certPem: Buffer, keyPem: Buffer): Server {
+		return new Server(NapiServer.bind(addr, certPem, keyPem));
+	}
+
+	async accept(): Promise<Request | null> {
+		const inner = await this.#inner.accept();
+		if (!inner) return null;
+		return new Request(inner);
+	}
+
+	close(): void {
+		this.#inner.close();
+	}
+}

package/src/session.ts

@@ -1,4 +1,4 @@
-import { NapiClient, type NapiRecvStream, type NapiSendStream, type NapiSession } from "../index.js";
+import { NapiClient, type NapiRecvStream, type NapiSendStream, type NapiSession } from "../napi.js";
 import { Datagrams } from "./datagrams.ts";
 
 function wrapRecvStream(recv: NapiRecvStream): ReadableStream<Uint8Array> {