@moq/web-transport 0.0.1

package/index.d.ts

@@ -0,0 +1,90 @@
+/* auto-generated by NAPI-RS */
+/* eslint-disable */
+/** A bidirectional stream pair. */
+export declare class NapiBiStream {
+	/** Take the send stream. Can only be called once. */
+	takeSend(): NapiSendStream;
+	/** Take the recv stream. Can only be called once. */
+	takeRecv(): NapiRecvStream;
+}
+
+/** A WebTransport client that can connect to servers. */
+export declare class NapiClient {
+	/** Create a client that validates server certificates against system root CAs. */
+	static withSystemRoots(): NapiClient;
+	/**
+	 * Create a client that skips certificate verification entirely.
+	 * WARNING: Only use for testing with self-signed certificates.
+	 */
+	static disableVerify(): NapiClient;
+	/** Create a client that validates server certificates by SHA-256 hash. */
+	static withCertificateHashes(hashes: Array<Buffer>): NapiClient;
+	/** Connect to a WebTransport server at the given URL. */
+	connect(urlStr: string): Promise<NapiSession>;
+}
+
+/** A receive stream for reading data. */
+export declare class NapiRecvStream {
+	/** Read up to `max_size` bytes from the stream. Returns null on FIN. */
+	read(maxSize: number): Promise<Buffer | null>;
+	/** Tell the peer to stop sending with the given error code. */
+	stop(code: number): Promise<void>;
+}
+
+/** A pending WebTransport session request from a client. */
+export declare class NapiRequest {
+	/** Get the URL of the CONNECT request. */
+	get url(): Promise<string>;
+	/** Accept the session with 200 OK. */
+	ok(): Promise<NapiSession>;
+	/** Reject the session with the given HTTP status code. */
+	reject(status: number): Promise<void>;
+}
+
+/** A send stream for writing data. */
+export declare class NapiSendStream {
+	/** Write data to the stream. */
+	write(data: Buffer): Promise<void>;
+	/** Signal that no more data will be written. */
+	finish(): Promise<void>;
+	/** Abruptly reset the stream with an error code. */
+	reset(code: number): Promise<void>;
+	/** Set the priority of the stream. */
+	setPriority(priority: number): Promise<void>;
+}
+
+/** A WebTransport server that accepts incoming sessions. */
+export declare class NapiServer {
+	/** Create a server bound to the given address with the given TLS certificate. */
+	static bind(addr: string, certPem: Buffer, keyPem: Buffer): NapiServer;
+	/** Accept the next incoming WebTransport session request. */
+	accept(): Promise<NapiRequest | null>;
+}
+
+/** An established WebTransport session. */
+export declare class NapiSession {
+	/** Accept an incoming unidirectional stream. */
+	acceptUni(): Promise<NapiRecvStream>;
+	/** Accept an incoming bidirectional stream. */
+	acceptBi(): Promise<NapiBiStream>;
+	/** Open a new unidirectional stream. */
+	openUni(): Promise<NapiSendStream>;
+	/** Open a new bidirectional stream. */
+	openBi(): Promise<NapiBiStream>;
+	/** Send a datagram. */
+	sendDatagram(data: Buffer): void;
+	/** Receive a datagram. */
+	recvDatagram(): Promise<Buffer>;
+	/** Get the maximum datagram size. */
+	maxDatagramSize(): number;
+	/** Close the session with a code and reason. */
+	close(code: number, reason: string): void;
+	/** Wait for the session to close, returning close info matching W3C WebTransportCloseInfo. */
+	closed(): Promise<NapiCloseInfo>;
+}
+
+/** Info about why a session was closed, matching W3C WebTransportCloseInfo. */
+export interface NapiCloseInfo {
+	closeCode: number;
+	reason: string;
+}

package/index.js

@@ -0,0 +1,746 @@
+// prettier-ignore
+/* eslint-disable */
+// @ts-nocheck
+/* auto-generated by NAPI-RS */
+
+const { readFileSync } = require("node:fs");
+let nativeBinding = null;
+const loadErrors = [];
+
+const isMusl = () => {
+	let musl = false;
+	if (process.platform === "linux") {
+		musl = isMuslFromFilesystem();
+		if (musl === null) {
+			musl = isMuslFromReport();
+		}
+		if (musl === null) {
+			musl = isMuslFromChildProcess();
+		}
+	}
+	return musl;
+};
+
+const isFileMusl = (f) => f.includes("libc.musl-") || f.includes("ld-musl-");
+
+const isMuslFromFilesystem = () => {
+	try {
+		return readFileSync("/usr/bin/ldd", "utf-8").includes("musl");
+	} catch {
+		return null;
+	}
+};
+
+const isMuslFromReport = () => {
+	let report = null;
+	if (typeof process.report?.getReport === "function") {
+		process.report.excludeNetwork = true;
+		report = process.report.getReport();
+	}
+	if (!report) {
+		return null;
+	}
+	if (report.header?.glibcVersionRuntime) {
+		return false;
+	}
+	if (Array.isArray(report.sharedObjects)) {
+		if (report.sharedObjects.some(isFileMusl)) {
+			return true;
+		}
+	}
+	return false;
+};
+
+const isMuslFromChildProcess = () => {
+	try {
+		return require("child_process").execSync("ldd --version", { encoding: "utf8" }).includes("musl");
+	} catch (_e) {
+		// If we reach this case, we don't know if the system is musl or not, so is better to just fallback to false
+		return false;
+	}
+};
+
+function requireNative() {
+	if (process.env.NAPI_RS_NATIVE_LIBRARY_PATH) {
+		try {
+			return require(process.env.NAPI_RS_NATIVE_LIBRARY_PATH);
+		} catch (err) {
+			loadErrors.push(err);
+		}
+	} else if (process.platform === "android") {
+		if (process.arch === "arm64") {
+			try {
+				return require("./web-transport.android-arm64.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = require("@moq/web-transport-android-arm64");
+				const bindingPackageVersion = require("@moq/web-transport-android-arm64/package.json").version;
+				if (
+					bindingPackageVersion !== "0.0.1" &&
+					process.env.NAPI_RS_ENFORCE_VERSION_CHECK &&
+					process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0"
+				) {
+					throw new Error(
+						`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
+					);
+				}
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else if (process.arch === "arm") {
+			try {
+				return require("./web-transport.android-arm-eabi.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = require("@moq/web-transport-android-arm-eabi");
+				const bindingPackageVersion = require("@moq/web-transport-android-arm-eabi/package.json").version;
+				if (
+					bindingPackageVersion !== "0.0.1" &&
+					process.env.NAPI_RS_ENFORCE_VERSION_CHECK &&
+					process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0"
+				) {
+					throw new Error(
+						`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
+					);
+				}
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else {
+			loadErrors.push(new Error(`Unsupported architecture on Android ${process.arch}`));
+		}
+	} else if (process.platform === "win32") {
+		if (process.arch === "x64") {
+			if (
+				process.config?.variables?.shlib_suffix === "dll.a" ||
+				process.config?.variables?.node_target_type === "shared_library"
+			) {
+				try {
+					return require("./web-transport.win32-x64-gnu.node");
+				} catch (e) {
+					loadErrors.push(e);
+				}
+				try {
+					const binding = require("@moq/web-transport-win32-x64-gnu");
+					const bindingPackageVersion = require("@moq/web-transport-win32-x64-gnu/package.json").version;
+					if (
+						bindingPackageVersion !== "0.0.1" &&
+						process.env.NAPI_RS_ENFORCE_VERSION_CHECK &&
+						process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0"
+					) {
+						throw new Error(
+							`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
+						);
+					}
+					return binding;
+				} catch (e) {
+					loadErrors.push(e);
+				}
+			} else {
+				try {
+					return require("./web-transport.win32-x64-msvc.node");
+				} catch (e) {
+					loadErrors.push(e);
+				}
+				try {
+					const binding = require("@moq/web-transport-win32-x64-msvc");
+					const bindingPackageVersion = require("@moq/web-transport-win32-x64-msvc/package.json").version;
+					if (
+						bindingPackageVersion !== "0.0.1" &&
+						process.env.NAPI_RS_ENFORCE_VERSION_CHECK &&
+						process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0"
+					) {
+						throw new Error(
+							`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
+						);
+					}
+					return binding;
+				} catch (e) {
+					loadErrors.push(e);
+				}
+			}
+		} else if (process.arch === "ia32") {
+			try {
+				return require("./web-transport.win32-ia32-msvc.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = require("@moq/web-transport-win32-ia32-msvc");
+				const bindingPackageVersion = require("@moq/web-transport-win32-ia32-msvc/package.json").version;
+				if (
+					bindingPackageVersion !== "0.0.1" &&
+					process.env.NAPI_RS_ENFORCE_VERSION_CHECK &&
+					process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0"
+				) {
+					throw new Error(
+						`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
+					);
+				}
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else if (process.arch === "arm64") {
+			try {
+				return require("./web-transport.win32-arm64-msvc.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = require("@moq/web-transport-win32-arm64-msvc");
+				const bindingPackageVersion = require("@moq/web-transport-win32-arm64-msvc/package.json").version;
+				if (
+					bindingPackageVersion !== "0.0.1" &&
+					process.env.NAPI_RS_ENFORCE_VERSION_CHECK &&
+					process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0"
+				) {
+					throw new Error(
+						`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
+					);
+				}
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else {
+			loadErrors.push(new Error(`Unsupported architecture on Windows: ${process.arch}`));
+		}
+	} else if (process.platform === "darwin") {
+		try {
+			return require("./web-transport.darwin-universal.node");
+		} catch (e) {
+			loadErrors.push(e);
+		}
+		try {
+			const binding = require("@moq/web-transport-darwin-universal");
+			const bindingPackageVersion = require("@moq/web-transport-darwin-universal/package.json").version;
+			if (
+				bindingPackageVersion !== "0.0.1" &&
+				process.env.NAPI_RS_ENFORCE_VERSION_CHECK &&
+				process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0"
+			) {
+				throw new Error(
+					`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
+				);
+			}
+			return binding;
+		} catch (e) {
+			loadErrors.push(e);
+		}
+		if (process.arch === "x64") {
+			try {
+				return require("./web-transport.darwin-x64.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = require("@moq/web-transport-darwin-x64");
+				const bindingPackageVersion = require("@moq/web-transport-darwin-x64/package.json").version;
+				if (
+					bindingPackageVersion !== "0.0.1" &&
+					process.env.NAPI_RS_ENFORCE_VERSION_CHECK &&
+					process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0"
+				) {
+					throw new Error(
+						`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
+					);
+				}
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else if (process.arch === "arm64") {
+			try {
+				return require("./web-transport.darwin-arm64.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = require("@moq/web-transport-darwin-arm64");
+				const bindingPackageVersion = require("@moq/web-transport-darwin-arm64/package.json").version;
+				if (
+					bindingPackageVersion !== "0.0.1" &&
+					process.env.NAPI_RS_ENFORCE_VERSION_CHECK &&
+					process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0"
+				) {
+					throw new Error(
+						`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
+					);
+				}
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else {
+			loadErrors.push(new Error(`Unsupported architecture on macOS: ${process.arch}`));
+		}
+	} else if (process.platform === "freebsd") {
+		if (process.arch === "x64") {
+			try {
+				return require("./web-transport.freebsd-x64.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = require("@moq/web-transport-freebsd-x64");
+				const bindingPackageVersion = require("@moq/web-transport-freebsd-x64/package.json").version;
+				if (
+					bindingPackageVersion !== "0.0.1" &&
+					process.env.NAPI_RS_ENFORCE_VERSION_CHECK &&
+					process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0"
+				) {
+					throw new Error(
+						`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
+					);
+				}
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else if (process.arch === "arm64") {
+			try {
+				return require("./web-transport.freebsd-arm64.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = require("@moq/web-transport-freebsd-arm64");
+				const bindingPackageVersion = require("@moq/web-transport-freebsd-arm64/package.json").version;
+				if (
+					bindingPackageVersion !== "0.0.1" &&
+					process.env.NAPI_RS_ENFORCE_VERSION_CHECK &&
+					process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0"
+				) {
+					throw new Error(
+						`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
+					);
+				}
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else {
+			loadErrors.push(new Error(`Unsupported architecture on FreeBSD: ${process.arch}`));
+		}
+	} else if (process.platform === "linux") {
+		if (process.arch === "x64") {
+			if (isMusl()) {
+				try {
+					return require("./web-transport.linux-x64-musl.node");
+				} catch (e) {
+					loadErrors.push(e);
+				}
+				try {
+					const binding = require("@moq/web-transport-linux-x64-musl");
+					const bindingPackageVersion = require("@moq/web-transport-linux-x64-musl/package.json").version;
+					if (
+						bindingPackageVersion !== "0.0.1" &&
+						process.env.NAPI_RS_ENFORCE_VERSION_CHECK &&
+						process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0"
+					) {
+						throw new Error(
+							`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
+						);
+					}
+					return binding;
+				} catch (e) {
+					loadErrors.push(e);
+				}
+			} else {
+				try {
+					return require("./web-transport.linux-x64-gnu.node");
+				} catch (e) {
+					loadErrors.push(e);
+				}
+				try {
+					const binding = require("@moq/web-transport-linux-x64-gnu");
+					const bindingPackageVersion = require("@moq/web-transport-linux-x64-gnu/package.json").version;
+					if (
+						bindingPackageVersion !== "0.0.1" &&
+						process.env.NAPI_RS_ENFORCE_VERSION_CHECK &&
+						process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0"
+					) {
+						throw new Error(
+							`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
+						);
+					}
+					return binding;
+				} catch (e) {
+					loadErrors.push(e);
+				}
+			}
+		} else if (process.arch === "arm64") {
+			if (isMusl()) {
+				try {
+					return require("./web-transport.linux-arm64-musl.node");
+				} catch (e) {
+					loadErrors.push(e);
+				}
+				try {
+					const binding = require("@moq/web-transport-linux-arm64-musl");
+					const bindingPackageVersion = require("@moq/web-transport-linux-arm64-musl/package.json").version;
+					if (
+						bindingPackageVersion !== "0.0.1" &&
+						process.env.NAPI_RS_ENFORCE_VERSION_CHECK &&
+						process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0"
+					) {
+						throw new Error(
+							`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
+						);
+					}
+					return binding;
+				} catch (e) {
+					loadErrors.push(e);
+				}
+			} else {
+				try {
+					return require("./web-transport.linux-arm64-gnu.node");
+				} catch (e) {
+					loadErrors.push(e);
+				}
+				try {
+					const binding = require("@moq/web-transport-linux-arm64-gnu");
+					const bindingPackageVersion = require("@moq/web-transport-linux-arm64-gnu/package.json").version;
+					if (
+						bindingPackageVersion !== "0.0.1" &&
+						process.env.NAPI_RS_ENFORCE_VERSION_CHECK &&
+						process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0"
+					) {
+						throw new Error(
+							`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
+						);
+					}
+					return binding;
+				} catch (e) {
+					loadErrors.push(e);
+				}
+			}
+		} else if (process.arch === "arm") {
+			if (isMusl()) {
+				try {
+					return require("./web-transport.linux-arm-musleabihf.node");
+				} catch (e) {
+					loadErrors.push(e);
+				}
+				try {
+					const binding = require("@moq/web-transport-linux-arm-musleabihf");
+					const bindingPackageVersion =
+						require("@moq/web-transport-linux-arm-musleabihf/package.json").version;
+					if (
+						bindingPackageVersion !== "0.0.1" &&
+						process.env.NAPI_RS_ENFORCE_VERSION_CHECK &&
+						process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0"
+					) {
+						throw new Error(
+							`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
+						);
+					}
+					return binding;
+				} catch (e) {
+					loadErrors.push(e);
+				}
+			} else {
+				try {
+					return require("./web-transport.linux-arm-gnueabihf.node");
+				} catch (e) {
+					loadErrors.push(e);
+				}
+				try {
+					const binding = require("@moq/web-transport-linux-arm-gnueabihf");
+					const bindingPackageVersion =
+						require("@moq/web-transport-linux-arm-gnueabihf/package.json").version;
+					if (
+						bindingPackageVersion !== "0.0.1" &&
+						process.env.NAPI_RS_ENFORCE_VERSION_CHECK &&
+						process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0"
+					) {
+						throw new Error(
+							`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
+						);
+					}
+					return binding;
+				} catch (e) {
+					loadErrors.push(e);
+				}
+			}
+		} else if (process.arch === "loong64") {
+			if (isMusl()) {
+				try {
+					return require("./web-transport.linux-loong64-musl.node");
+				} catch (e) {
+					loadErrors.push(e);
+				}
+				try {
+					const binding = require("@moq/web-transport-linux-loong64-musl");
+					const bindingPackageVersion = require("@moq/web-transport-linux-loong64-musl/package.json").version;
+					if (
+						bindingPackageVersion !== "0.0.1" &&
+						process.env.NAPI_RS_ENFORCE_VERSION_CHECK &&
+						process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0"
+					) {
+						throw new Error(
+							`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
+						);
+					}
+					return binding;
+				} catch (e) {
+					loadErrors.push(e);
+				}
+			} else {
+				try {
+					return require("./web-transport.linux-loong64-gnu.node");
+				} catch (e) {
+					loadErrors.push(e);
+				}
+				try {
+					const binding = require("@moq/web-transport-linux-loong64-gnu");
+					const bindingPackageVersion = require("@moq/web-transport-linux-loong64-gnu/package.json").version;
+					if (
+						bindingPackageVersion !== "0.0.1" &&
+						process.env.NAPI_RS_ENFORCE_VERSION_CHECK &&
+						process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0"
+					) {
+						throw new Error(
+							`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
+						);
+					}
+					return binding;
+				} catch (e) {
+					loadErrors.push(e);
+				}
+			}
+		} else if (process.arch === "riscv64") {
+			if (isMusl()) {
+				try {
+					return require("./web-transport.linux-riscv64-musl.node");
+				} catch (e) {
+					loadErrors.push(e);
+				}
+				try {
+					const binding = require("@moq/web-transport-linux-riscv64-musl");
+					const bindingPackageVersion = require("@moq/web-transport-linux-riscv64-musl/package.json").version;
+					if (
+						bindingPackageVersion !== "0.0.1" &&
+						process.env.NAPI_RS_ENFORCE_VERSION_CHECK &&
+						process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0"
+					) {
+						throw new Error(
+							`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
+						);
+					}
+					return binding;
+				} catch (e) {
+					loadErrors.push(e);
+				}
+			} else {
+				try {
+					return require("./web-transport.linux-riscv64-gnu.node");
+				} catch (e) {
+					loadErrors.push(e);
+				}
+				try {
+					const binding = require("@moq/web-transport-linux-riscv64-gnu");
+					const bindingPackageVersion = require("@moq/web-transport-linux-riscv64-gnu/package.json").version;
+					if (
+						bindingPackageVersion !== "0.0.1" &&
+						process.env.NAPI_RS_ENFORCE_VERSION_CHECK &&
+						process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0"
+					) {
+						throw new Error(
+							`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
+						);
+					}
+					return binding;
+				} catch (e) {
+					loadErrors.push(e);
+				}
+			}
+		} else if (process.arch === "ppc64") {
+			try {
+				return require("./web-transport.linux-ppc64-gnu.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = require("@moq/web-transport-linux-ppc64-gnu");
+				const bindingPackageVersion = require("@moq/web-transport-linux-ppc64-gnu/package.json").version;
+				if (
+					bindingPackageVersion !== "0.0.1" &&
+					process.env.NAPI_RS_ENFORCE_VERSION_CHECK &&
+					process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0"
+				) {
+					throw new Error(
+						`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
+					);
+				}
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else if (process.arch === "s390x") {
+			try {
+				return require("./web-transport.linux-s390x-gnu.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = require("@moq/web-transport-linux-s390x-gnu");
+				const bindingPackageVersion = require("@moq/web-transport-linux-s390x-gnu/package.json").version;
+				if (
+					bindingPackageVersion !== "0.0.1" &&
+					process.env.NAPI_RS_ENFORCE_VERSION_CHECK &&
+					process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0"
+				) {
+					throw new Error(
+						`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
+					);
+				}
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else {
+			loadErrors.push(new Error(`Unsupported architecture on Linux: ${process.arch}`));
+		}
+	} else if (process.platform === "openharmony") {
+		if (process.arch === "arm64") {
+			try {
+				return require("./web-transport.openharmony-arm64.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = require("@moq/web-transport-openharmony-arm64");
+				const bindingPackageVersion = require("@moq/web-transport-openharmony-arm64/package.json").version;
+				if (
+					bindingPackageVersion !== "0.0.1" &&
+					process.env.NAPI_RS_ENFORCE_VERSION_CHECK &&
+					process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0"
+				) {
+					throw new Error(
+						`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
+					);
+				}
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else if (process.arch === "x64") {
+			try {
+				return require("./web-transport.openharmony-x64.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = require("@moq/web-transport-openharmony-x64");
+				const bindingPackageVersion = require("@moq/web-transport-openharmony-x64/package.json").version;
+				if (
+					bindingPackageVersion !== "0.0.1" &&
+					process.env.NAPI_RS_ENFORCE_VERSION_CHECK &&
+					process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0"
+				) {
+					throw new Error(
+						`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
+					);
+				}
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else if (process.arch === "arm") {
+			try {
+				return require("./web-transport.openharmony-arm.node");
+			} catch (e) {
+				loadErrors.push(e);
+			}
+			try {
+				const binding = require("@moq/web-transport-openharmony-arm");
+				const bindingPackageVersion = require("@moq/web-transport-openharmony-arm/package.json").version;
+				if (
+					bindingPackageVersion !== "0.0.1" &&
+					process.env.NAPI_RS_ENFORCE_VERSION_CHECK &&
+					process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== "0"
+				) {
+					throw new Error(
+						`Native binding package version mismatch, expected 0.0.1 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`,
+					);
+				}
+				return binding;
+			} catch (e) {
+				loadErrors.push(e);
+			}
+		} else {
+			loadErrors.push(new Error(`Unsupported architecture on OpenHarmony: ${process.arch}`));
+		}
+	} else {
+		loadErrors.push(new Error(`Unsupported OS: ${process.platform}, architecture: ${process.arch}`));
+	}
+}
+
+nativeBinding = requireNative();
+
+if (!nativeBinding || process.env.NAPI_RS_FORCE_WASI) {
+	let wasiBinding = null;
+	let wasiBindingError = null;
+	try {
+		wasiBinding = require("./web-transport.wasi.cjs");
+		nativeBinding = wasiBinding;
+	} catch (err) {
+		if (process.env.NAPI_RS_FORCE_WASI) {
+			wasiBindingError = err;
+		}
+	}
+	if (!nativeBinding || process.env.NAPI_RS_FORCE_WASI) {
+		try {
+			wasiBinding = require("@moq/web-transport-wasm32-wasi");
+			nativeBinding = wasiBinding;
+		} catch (err) {
+			if (process.env.NAPI_RS_FORCE_WASI) {
+				if (!wasiBindingError) {
+					wasiBindingError = err;
+				} else {
+					wasiBindingError.cause = err;
+				}
+				loadErrors.push(err);
+			}
+		}
+	}
+	if (process.env.NAPI_RS_FORCE_WASI === "error" && !wasiBinding) {
+		const error = new Error("WASI binding not found and NAPI_RS_FORCE_WASI is set to error");
+		error.cause = wasiBindingError;
+		throw error;
+	}
+}
+
+if (!nativeBinding) {
+	if (loadErrors.length > 0) {
+		throw new Error(
+			`Cannot find native binding. ` +
+				`npm has a bug related to optional dependencies (https://github.com/npm/cli/issues/4828). ` +
+				"Please try `npm i` again after removing both package-lock.json and node_modules directory.",
+			{
+				cause: loadErrors.reduce((err, cur) => {
+					cur.cause = err;
+					return cur;
+				}),
+			},
+		);
+	}
+	throw new Error(`Failed to load native binding`);
+}
+
+module.exports = nativeBinding;
+module.exports.NapiBiStream = nativeBinding.NapiBiStream;
+module.exports.NapiClient = nativeBinding.NapiClient;
+module.exports.NapiRecvStream = nativeBinding.NapiRecvStream;
+module.exports.NapiRequest = nativeBinding.NapiRequest;
+module.exports.NapiSendStream = nativeBinding.NapiSendStream;
+module.exports.NapiServer = nativeBinding.NapiServer;
+module.exports.NapiSession = nativeBinding.NapiSession;

package/package.json

@@ -0,0 +1,52 @@
+{
+	"name": "@moq/web-transport",
+	"version": "0.0.1",
+	"description": "WebTransport polyfill for Node.js via QUIC/HTTP3",
+	"type": "module",
+	"license": "(MIT OR Apache-2.0)",
+	"repository": "github:moq-dev/web-transport",
+	"napi": {
+		"binaryName": "web-transport",
+		"targets": [
+			"x86_64-apple-darwin",
+			"aarch64-apple-darwin",
+			"x86_64-pc-windows-msvc",
+			"x86_64-unknown-linux-gnu",
+			"aarch64-unknown-linux-gnu"
+		]
+	},
+	"exports": {
+		".": "./src/index.ts"
+	},
+	"types": "./src/index.ts",
+	"files": [
+		"./src",
+		"index.js",
+		"index.d.ts",
+		"*.node"
+	],
+	"scripts": {
+		"build": "napi build --platform --release --manifest-path ../../rs/web-transport-node/Cargo.toml --output-dir .",
+		"check": "tsc --noEmit",
+		"release": "bun scripts/release.ts"
+	},
+	"devDependencies": {
+		"@napi-rs/cli": "^3",
+		"typescript": "^5.9.2",
+		"@types/node": "^24.3.0"
+	},
+	"optionalDependencies": {
+		"@moq/web-transport-darwin-x64": "0.0.1",
+		"@moq/web-transport-darwin-arm64": "0.0.1",
+		"@moq/web-transport-win32-x64-msvc": "0.0.1",
+		"@moq/web-transport-linux-x64-gnu": "0.0.1",
+		"@moq/web-transport-linux-arm64-gnu": "0.0.1"
+	},
+	"keywords": [
+		"webtransport",
+		"quic",
+		"http3",
+		"polyfill",
+		"napi"
+	]
+}

package/src/datagrams.ts

@@ -0,0 +1,39 @@
+import type { NapiSession } from "../index.js";
+
+export class Datagrams implements WebTransportDatagramDuplexStream {
+	readonly readable: ReadableStream<Uint8Array>;
+	readonly writable: WritableStream<Uint8Array>;
+
+	// Required by the interface but not meaningfully configurable here.
+	incomingHighWaterMark = 1;
+	incomingMaxAge: number | null = null;
+	outgoingHighWaterMark = 1;
+	outgoingMaxAge: number | null = null;
+
+	#session: NapiSession;
+
+	constructor(session: NapiSession) {
+		this.#session = session;
+
+		this.readable = new ReadableStream({
+			async pull(controller) {
+				try {
+					const data = await session.recvDatagram();
+					controller.enqueue(new Uint8Array(data));
+				} catch {
+					controller.close();
+				}
+			},
+		});
+
+		this.writable = new WritableStream({
+			write(chunk) {
+				session.sendDatagram(Buffer.from(chunk));
+			},
+		});
+	}
+
+	get maxDatagramSize(): number {
+		return this.#session.maxDatagramSize();
+	}
+}

package/src/index.ts

@@ -0,0 +1,12 @@
+import Session from "./session.ts";
+
+// Install polyfill if WebTransport is not available, returning true if installed
+export function install(): boolean {
+	if ("WebTransport" in globalThis) return false;
+	// biome-ignore lint/suspicious/noExplicitAny: polyfill
+	(globalThis as any).WebTransport = Session;
+	return true;
+}
+
+export default Session;
+export { NapiRequest, NapiServer } from "../index.js";

package/src/session.ts

@@ -0,0 +1,264 @@
+import { NapiClient, type NapiRecvStream, type NapiSendStream, type NapiSession } from "../index.js";
+import { Datagrams } from "./datagrams.ts";
+
+function wrapRecvStream(recv: NapiRecvStream): ReadableStream<Uint8Array> {
+	return new ReadableStream({
+		async pull(controller) {
+			const chunk = await recv.read(65536);
+			if (chunk) {
+				controller.enqueue(new Uint8Array(chunk));
+			} else {
+				controller.close();
+			}
+		},
+		cancel() {
+			recv.stop(0).catch(() => {});
+		},
+	});
+}
+
+function wrapSendStream(send: NapiSendStream): WritableStream<Uint8Array> {
+	return new WritableStream({
+		async write(chunk) {
+			await send.write(Buffer.from(chunk));
+		},
+		async close() {
+			await send.finish();
+		},
+		async abort() {
+			await send.reset(0);
+		},
+	});
+}
+
+export interface SessionOptions extends WebTransportOptions {
+	/** Skip all certificate verification. Only use for testing. */
+	serverCertificateDisableVerify?: boolean;
+}
+
+export default class Session implements WebTransport {
+	readonly ready: Promise<void>;
+	readonly closed: Promise<WebTransportCloseInfo>;
+	readonly datagrams: WebTransportDatagramDuplexStream;
+
+	#session: NapiSession | undefined;
+	#pendingClose: { closeCode: number; reason: string } | undefined;
+	#incomingBidirectionalStreams: ReadableStream<WebTransportBidirectionalStream> | undefined;
+	#incomingUnidirectionalStreams: ReadableStream<ReadableStream<Uint8Array>> | undefined;
+
+	// Construct from URL (client-side polyfill)
+	constructor(url: string | URL, options?: SessionOptions);
+	// Construct from existing NapiSession (server-side)
+	constructor(session: NapiSession);
+	constructor(urlOrSession: string | URL | NapiSession, options?: SessionOptions) {
+		const ready = Promise.withResolvers<void>();
+		const closed = Promise.withResolvers<WebTransportCloseInfo>();
+		this.ready = ready.promise;
+		this.closed = closed.promise;
+
+		// Check if we got an existing NapiSession (server-side path)
+		if (typeof urlOrSession === "object" && !(urlOrSession instanceof URL)) {
+			this.#session = urlOrSession;
+			this.datagrams = new Datagrams(urlOrSession);
+
+			ready.resolve();
+
+			urlOrSession.closed().then((info) => {
+				closed.resolve({ closeCode: info.closeCode, reason: info.reason });
+			});
+		} else {
+			// Client-side: create NapiClient and connect
+			const url = typeof urlOrSession === "string" ? urlOrSession : urlOrSession.toString();
+
+			// Provide a deferred Datagrams that works before connect resolves.
+			// The real session will be bound once connect succeeds.
+			this.datagrams = new DeferredDatagrams();
+
+			const hashes = options?.serverCertificateHashes;
+			if (options?.serverCertificateDisableVerify && hashes && hashes.length > 0) {
+				throw new Error("serverCertificateDisableVerify and serverCertificateHashes cannot be used together");
+			}
+
+			let client: NapiClient;
+			if (options?.serverCertificateDisableVerify) {
+				client = NapiClient.disableVerify();
+			} else if (hashes && hashes.length > 0) {
+				const buffers = hashes
+					.filter((h): h is WebTransportHash & { value: BufferSource } => h.value != null)
+					.map((h) => Buffer.from(h.value as ArrayBuffer));
+				client = NapiClient.withCertificateHashes(buffers);
+			} else {
+				client = NapiClient.withSystemRoots();
+			}
+
+			client
+				.connect(url)
+				.then((session) => {
+					// Check if close() was called before connect completed.
+					if (this.#pendingClose) {
+						session.close(this.#pendingClose.closeCode, this.#pendingClose.reason);
+						(this.datagrams as DeferredDatagrams).fail(new Error("session closed before connect"));
+						closed.resolve(this.#pendingClose);
+						ready.reject(new Error("session closed before connect"));
+						return;
+					}
+
+					this.#session = session;
+					(this.datagrams as DeferredDatagrams).bind(session);
+					ready.resolve();
+
+					session.closed().then((info) => {
+						closed.resolve({ closeCode: info.closeCode, reason: info.reason });
+					});
+				})
+				.catch((err) => {
+					(this.datagrams as DeferredDatagrams).fail(err instanceof Error ? err : new Error(String(err)));
+					ready.reject(err instanceof Error ? err : new Error(String(err)));
+					closed.resolve({ closeCode: 0, reason: String(err) });
+				});
+		}
+	}
+
+	get incomingBidirectionalStreams(): ReadableStream<WebTransportBidirectionalStream> {
+		if (!this.#incomingBidirectionalStreams) {
+			this.#incomingBidirectionalStreams = new ReadableStream({
+				pull: async (controller) => {
+					await this.ready;
+					const session = this.#session;
+					if (!session) {
+						controller.close();
+						return;
+					}
+					try {
+						const bi = await session.acceptBi();
+						const stream: WebTransportBidirectionalStream = {
+							readable: wrapRecvStream(bi.takeRecv()),
+							writable: wrapSendStream(bi.takeSend()),
+						};
+						controller.enqueue(stream);
+					} catch {
+						controller.close();
+					}
+				},
+			});
+		}
+		return this.#incomingBidirectionalStreams;
+	}
+
+	get incomingUnidirectionalStreams(): ReadableStream<ReadableStream<Uint8Array>> {
+		if (!this.#incomingUnidirectionalStreams) {
+			this.#incomingUnidirectionalStreams = new ReadableStream({
+				pull: async (controller) => {
+					await this.ready;
+					const session = this.#session;
+					if (!session) {
+						controller.close();
+						return;
+					}
+					try {
+						const recv = await session.acceptUni();
+						controller.enqueue(wrapRecvStream(recv));
+					} catch {
+						controller.close();
+					}
+				},
+			});
+		}
+		return this.#incomingUnidirectionalStreams;
+	}
+
+	async createBidirectionalStream(): Promise<WebTransportBidirectionalStream> {
+		await this.ready;
+		if (!this.#session) throw new Error("session not connected");
+		const bi = await this.#session.openBi();
+		return {
+			readable: wrapRecvStream(bi.takeRecv()),
+			writable: wrapSendStream(bi.takeSend()),
+		};
+	}
+
+	async createUnidirectionalStream(): Promise<WritableStream<Uint8Array>> {
+		await this.ready;
+		if (!this.#session) throw new Error("session not connected");
+		const send = await this.#session.openUni();
+		return wrapSendStream(send);
+	}
+
+	close(info?: { closeCode?: number; reason?: string }): void {
+		const closeCode = info?.closeCode ?? 0;
+		const reason = info?.reason ?? "";
+		if (this.#session) {
+			this.#session.close(closeCode, reason);
+		} else {
+			// Connect hasn't completed yet — flag for when it does.
+			this.#pendingClose = { closeCode, reason };
+		}
+	}
+
+	get congestionControl(): WebTransportCongestionControl {
+		return "default";
+	}
+}
+
+/**
+ * A WebTransportDatagramDuplexStream that works before the session is connected.
+ * Readable/writable block until bind() is called with the real session.
+ */
+class DeferredDatagrams implements WebTransportDatagramDuplexStream {
+	readonly readable: ReadableStream<Uint8Array>;
+	readonly writable: WritableStream<Uint8Array>;
+
+	incomingHighWaterMark = 1;
+	incomingMaxAge: number | null = null;
+	outgoingHighWaterMark = 1;
+	outgoingMaxAge: number | null = null;
+
+	#session: NapiSession | undefined;
+	#bound = Promise.withResolvers<void>();
+
+	constructor() {
+		this.readable = new ReadableStream({
+			pull: async (controller) => {
+				// Wait for session to be bound
+				if (!this.#session) {
+					try {
+						await this.#bound.promise;
+					} catch {
+						controller.close();
+						return;
+					}
+				}
+				if (!this.#session) {
+					controller.close();
+					return;
+				}
+				try {
+					const data = await this.#session.recvDatagram();
+					controller.enqueue(new Uint8Array(data));
+				} catch {
+					controller.close();
+				}
+			},
+		});
+
+		this.writable = new WritableStream({
+			write: (chunk) => {
+				if (!this.#session) throw new Error("session not connected");
+				this.#session.sendDatagram(Buffer.from(chunk));
+			},
+		});
+	}
+
+	bind(session: NapiSession) {
+		this.#session = session;
+		this.#bound.resolve();
+	}
+
+	fail(_error: Error) {
+		this.#bound.reject(_error);
+	}
+
+	get maxDatagramSize(): number {
+		return this.#session?.maxDatagramSize() ?? 0;
+	}
+}