ventiws 1.0.0-alpha

package/dist/index.mjs

@@ -0,0 +1,2977 @@
+import { createRequire } from "node:module";
+import { STATUS_CODES, createServer, request } from "node:http";
+import { existsSync } from "node:fs";
+import { arch, platform } from "node:process";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { inspect } from "node:util";
+import { createHash, randomBytes } from "node:crypto";
+import { request as request$1 } from "node:https";
+import { Duplex } from "node:stream";
+//#region src/binding/addon-error.ts
+function unloadableAddonMessage(path, platform, arch) {
+	return `ventiws: the native addon at ${path} was found but could not be loaded, so it was built for a different ${platform}-${arch} or against a different libc. In a checkout the fix is "pnpm build:binding"; in an install, a package built for this platform. The loader's own error is the cause.`;
+}
+function missingAddonMessage(root, platform, arch) {
+	const target = `${platform}-${arch}`;
+	if (root === void 0) return `ventiws: the package layout is broken -- there is no package.json above the native addon, so the artifact for ${target} cannot be located. Reinstalling ventiws should restore it.`;
+	return `ventiws: no native addon for ${target} was found under ${root}. An install ships the addon for one platform, so a ${target} machine needs ventiws built for ${target}, which needs the Zig toolchain (zig 0.16.0). If you are working in a checkout, the command is "pnpm build:binding".`;
+}
+//#endregion
+//#region src/binding/load.ts
+const require = createRequire(import.meta.url);
+const candidatePaths = [[
+	"zig-out",
+	"lib",
+	"ventiws.node"
+], ["dist", "ventiws.node"]];
+function findPackageRoot(start) {
+	let current = start;
+	while (current !== void 0) {
+		if (existsSync(join(current, "package.json"))) return current;
+		const parent = dirname(current);
+		current = parent === current ? void 0 : parent;
+	}
+}
+function resolveAddonPath() {
+	const root = findPackageRoot(dirname(fileURLToPath(import.meta.url)));
+	for (const parts of candidatePaths) {
+		if (root === void 0) continue;
+		const candidate = join(root, ...parts);
+		if (existsSync(candidate)) return candidate;
+	}
+	throw new Error(missingAddonMessage(root, platform, arch));
+}
+let addon;
+function loadAddon() {
+	if (addon !== void 0) return addon;
+	const path = resolveAddonPath();
+	try {
+		addon = require(path);
+	} catch (cause) {
+		throw Object.assign(new Error(unloadableAddonMessage(path, platform, arch)), { cause });
+	}
+	return addon;
+}
+//#endregion
+//#region src/compat/events/registry.ts
+function createRegistry() {
+	return {};
+}
+function listenerCount$1(registry, event) {
+	return registry[event]?.length ?? 0;
+}
+function subscribe(registry, event, handler) {
+	const bucket = registry[event] ?? [];
+	return {
+		...registry,
+		[event]: [...bucket, handler]
+	};
+}
+function prepend(registry, event, handler) {
+	const bucket = registry[event] ?? [];
+	return {
+		...registry,
+		[event]: [handler, ...bucket]
+	};
+}
+function unsubscribeMatching(registry, event, matches) {
+	const bucket = registry[event];
+	if (bucket === void 0) return registry;
+	let index = bucket.length - 1;
+	while (index >= 0) {
+		if (matches(bucket[index])) return {
+			...registry,
+			[event]: bucket.toSpliced(index, 1)
+		};
+		index -= 1;
+	}
+	return registry;
+}
+function removeAll(registry, event) {
+	if (event === void 0) return {};
+	return {
+		...registry,
+		[event]: []
+	};
+}
+function eventNames(registry) {
+	const names = [];
+	for (const key of Object.keys(registry)) if ((registry[key]?.length ?? 0) > 0) names.push(key);
+	return names;
+}
+function dispatchWith(registry, target, event, ...args) {
+	const bucket = registry[event];
+	if (bucket === void 0) return 0;
+	for (let index = 0; index < bucket.length; index += 1) Reflect.apply(bucket[index], target, args);
+	return bucket.length;
+}
+//#endregion
+//#region src/compat/errors.ts
+const STATUS_ERROR_CODES = {
+	closed: "ERR_SOCKET_CLOSED",
+	"invalid-handle": "ERR_INVALID_HANDLE",
+	"payload-too-large": "ERR_MAX_PAYLOAD",
+	"invalid-close-code": "ERR_INVALID_CLOSE_CODE",
+	"invalid-close-reason": "ERR_INVALID_CLOSE_REASON",
+	"protocol-error": "ERR_PROTOCOL",
+	"policy-violation": "ERR_POLICY_VIOLATION"
+};
+function createError(code, message, constructor = Error) {
+	return Object.assign(new constructor(message), { code });
+}
+function createStatusError(status, message) {
+	return createError(STATUS_ERROR_CODES[status], message);
+}
+//#endregion
+//#region src/compat/events/limits.ts
+function warnOnOverflow(state, event) {
+	if (state.maxListeners <= 0) return;
+	const count = listenerCount$1(state.listeners, event);
+	if (count <= state.maxListeners) return;
+	const name = String(event);
+	if (state.warned.has(name)) return;
+	state.warned.add(name);
+	process.emitWarning(createOverflowWarning(count, name, state.maxListeners));
+}
+function forgetWarning(state, event) {
+	if (event === void 0) {
+		state.warned.clear();
+		return;
+	}
+	state.warned.delete(String(event));
+}
+function createOverflowWarning(count, event, limit) {
+	const warning = /* @__PURE__ */ new Error(`Possible EventEmitter memory leak detected. ${count} ${event} listeners added to the emitter. MaxListeners is ${limit}. Use emitter.setMaxListeners() to increase limit`);
+	warning.name = "MaxListenersExceededWarning";
+	return warning;
+}
+function assertListenerLimit(count) {
+	if (typeof count !== "number") throw createError("ERR_INVALID_OPTION", "The \"setMaxListeners\" argument must be of type number. Received " + String(count), TypeError);
+	if (count < 0 || Number.isNaN(count)) throw createError("ERR_INVALID_OPTION", `The value of "setMaxListeners" is out of range. It must be >= 0. Received ${count}`, RangeError);
+	return count;
+}
+//#endregion
+//#region src/compat/events/tags.ts
+const MAX_WRAPPER_DEPTH = 3;
+const DOM_WRAPPER = Symbol("ventiws.domWrapper");
+function asTagged(entry) {
+	return entry;
+}
+function originalOf(entry) {
+	let current = entry;
+	for (let depth = 0; depth < MAX_WRAPPER_DEPTH; depth += 1) {
+		if (typeof current !== "function") return current;
+		const next = asTagged(current).listener;
+		if (next === void 0) return current;
+		current = next;
+	}
+	return current;
+}
+function isDomEntry(entry) {
+	const tagged = asTagged(entry);
+	if (tagged[DOM_WRAPPER] === true) return true;
+	const inner = tagged.listener;
+	if (inner === void 0) return false;
+	return asTagged(inner)[DOM_WRAPPER] === true;
+}
+function listenerView(entry) {
+	const inner = asTagged(entry).listener;
+	if (inner === void 0) return entry;
+	if (isDomEntry(entry)) return asTagged(inner)[DOM_WRAPPER] === true ? inner : entry;
+	return inner;
+}
+function removeTagged(state, event, handler) {
+	state.listeners = unsubscribeMatching(state.listeners, event, (entry) => entry === handler || !isDomEntry(entry) && originalOf(entry) === handler);
+}
+function onceWrapper(state, event, raw) {
+	const wrapper = (...args) => {
+		state.listeners = unsubscribeMatching(state.listeners, event, (entry) => entry === wrapper);
+		Reflect.apply(raw, state.target, args);
+	};
+	return Object.assign(wrapper, { listener: raw });
+}
+function onceEvent(state, event, handler) {
+	state.listeners = subscribe(state.listeners, event, onceWrapper(state, event, handler));
+}
+//#endregion
+//#region src/compat/events/emitter.ts
+const ERROR_EVENT = "error";
+function emitEvent(state, event, ...args) {
+	if (event === ERROR_EVENT && listenerCount$1(state.listeners, event) === 0) {
+		const failure = args[0];
+		if (failure instanceof Error) throw failure;
+		const wrapped = /* @__PURE__ */ new Error(`Unhandled error. (${inspect(failure)})`);
+		Object.assign(wrapped, { context: failure });
+		throw wrapped;
+	}
+	return dispatchWith(state.listeners, state.target, event, ...args) > 0;
+}
+function createEmitter(state) {
+	const addListener = (event, handler) => {
+		state.listeners = subscribe(state.listeners, event, handler);
+		warnOnOverflow(state, event);
+		return state.target;
+	};
+	const once = (event, handler) => {
+		state.listeners = subscribe(state.listeners, event, onceWrapper(state, event, handler));
+		warnOnOverflow(state, event);
+		return state.target;
+	};
+	const prependListener = (event, handler) => {
+		state.listeners = prepend(state.listeners, event, handler);
+		warnOnOverflow(state, event);
+		return state.target;
+	};
+	const prependOnceListener = (event, handler) => {
+		state.listeners = prepend(state.listeners, event, onceWrapper(state, event, handler));
+		warnOnOverflow(state, event);
+		return state.target;
+	};
+	const removeListener = (event, handler) => {
+		removeTagged(state, event, handler);
+		return state.target;
+	};
+	const emit = (event, ...args) => emitEvent(state, event, ...args);
+	return {
+		on: addListener,
+		addListener,
+		once,
+		prependListener,
+		prependOnceListener,
+		off: removeListener,
+		removeListener,
+		removeAllListeners: (event) => {
+			state.listeners = removeAll(state.listeners, event);
+			forgetWarning(state, event);
+			return state.target;
+		},
+		emit,
+		listeners: (event) => {
+			return (state.listeners[event] ?? []).map((entry) => listenerView(entry));
+		},
+		rawListeners: (event) => [...state.listeners[event] ?? []],
+		eventNames: () => eventNames(state.listeners),
+		listenerCount: (event) => listenerCount$1(state.listeners, event),
+		getMaxListeners: () => state.maxListeners,
+		setMaxListeners: (count) => {
+			state.maxListeners = assertListenerLimit(count);
+			state.warned.clear();
+			return state.target;
+		}
+	};
+}
+//#endregion
+//#region src/compat/server/clients.ts
+function clientCount(state) {
+	return state.clients?.size ?? 0;
+}
+function trackClient(state, socket) {
+	const clients = state.clients;
+	if (clients === void 0) return;
+	clients.add(socket);
+	socket.once("close", () => {
+		clients.delete(socket);
+		if (state.shouldEmitClose && clients.size === 0) process.nextTick(() => emitClose(state));
+	});
+}
+//#endregion
+//#region src/compat/server/close.ts
+function emitClose(state) {
+	if (state.lifecycle === "closed") return;
+	state.lifecycle = "closed";
+	emitEvent(state, "close");
+}
+function emitCloseAgain(state) {
+	emitEvent(state, "close");
+}
+function detachServer(state) {
+	if (state.removeListeners !== null) state.removeListeners();
+	state.removeListeners = null;
+	state.server = null;
+}
+function addressOf(state) {
+	if (state.normalizedOptions.noServer) throw createError("ERR_INVALID_STATE", "The server is operating in \"noServer\" mode");
+	if (state.server === null) return null;
+	return state.server.address();
+}
+function closeWebSocketServer(state, callback) {
+	if (state.lifecycle === "closed") {
+		if (callback) onceEvent(state, "close", () => {
+			callback(createError("ERR_SOCKET_CLOSED", "The server is not running"));
+		});
+		process.nextTick(() => {
+			emitCloseAgain(state);
+		});
+		return;
+	}
+	if (callback) onceEvent(state, "close", () => {
+		callback();
+	});
+	if (state.lifecycle === "closing") return;
+	state.lifecycle = "closing";
+	if (state.normalizedOptions.noServer || state.normalizedOptions.server !== null) {
+		detachServer(state);
+		if (!state.normalizedOptions.clientTracking || clientCount(state) === 0) {
+			process.nextTick(() => {
+				emitClose(state);
+			});
+			return;
+		}
+		state.shouldEmitClose = true;
+		return;
+	}
+	const httpServer = state.server;
+	detachServer(state);
+	httpServer?.close(() => {
+		emitClose(state);
+	});
+}
+//#endregion
+//#region src/compat/options/shared.ts
+const DEFAULT_MAX_PAYLOAD = 104857600;
+const DEFAULT_MAX_FRAGMENTS = 16384;
+const DEFAULT_MAX_BUFFERED_CHUNKS = 262144;
+const DEFAULT_CLOSE_TIMEOUT = 3e4;
+const SUBPROTOCOL_PATTERN = /^[!#$%&'*+\-.0-9A-Z^_`|a-z~]+$/;
+function isProtocolToken(value) {
+	return typeof value === "string" && SUBPROTOCOL_PATTERN.test(value);
+}
+function invalidOption(message, constructor = TypeError) {
+	throw createError("ERR_INVALID_OPTION", message, constructor);
+}
+function normalizeProtocols$1(protocols) {
+	if (protocols === void 0) return [];
+	const list = typeof protocols === "string" ? [protocols] : protocols;
+	const candidates = Array.isArray(list) ? list : [list];
+	const seen = /* @__PURE__ */ new Set();
+	const result = [];
+	for (const protocol of candidates) {
+		if (typeof protocol !== "string" || !SUBPROTOCOL_PATTERN.test(protocol) || seen.has(protocol)) invalidOption("An invalid or duplicated subprotocol was specified", SyntaxError);
+		seen.add(protocol);
+		result.push(protocol);
+	}
+	return result;
+}
+function parseProtocolHeader(header) {
+	return normalizeProtocols$1(header.split(",").map((protocol) => protocol.trim()));
+}
+function normalizePerMessageDeflate(value, fallback) {
+	if (value !== void 0 && !value) return false;
+	const resolved = value ?? fallback;
+	if (!resolved) return false;
+	const options = resolved === true ? {} : resolved;
+	return {
+		serverNoContextTakeover: options.serverNoContextTakeover,
+		clientNoContextTakeover: options.clientNoContextTakeover,
+		serverMaxWindowBits: options.serverMaxWindowBits,
+		clientMaxWindowBits: options.clientMaxWindowBits,
+		threshold: options.threshold ?? 1024,
+		concurrencyLimit: options.concurrencyLimit ?? 10,
+		zlibDeflateOptions: options.zlibDeflateOptions,
+		zlibInflateOptions: options.zlibInflateOptions
+	};
+}
+function closeTimeoutOf(source) {
+	const raw = source.closeTimeout;
+	if (raw === void 0) return DEFAULT_CLOSE_TIMEOUT;
+	if (typeof raw !== "number" || !Number.isFinite(raw) || raw < 0) invalidOption(`The closeTimeout option must be a non-negative number (received ${String(raw)})`, RangeError);
+	return raw;
+}
+//#endregion
+//#region src/compat/server/handshake.ts
+const KEY_PATTERN = /^[+/0-9A-Za-z]{22}==$/;
+const GUID$1 = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
+const STATUS_MIN = 100;
+const STATUS_MAX = 599;
+function hasControlCharacters(value) {
+	return value.includes("\0") || value.includes("\r") || value.includes("\n");
+}
+function socketAccept(key) {
+	return createHash("sha1").update(key + GUID$1).digest("base64");
+}
+function requestHeader(request, name) {
+	const value = request.headers[name];
+	return Array.isArray(value) ? value[0] : value;
+}
+function isSecure(request) {
+	const socket = request.socket;
+	return Boolean(socket.authorized || socket.encrypted);
+}
+function parseProtocols(state, request, socket) {
+	const header = request.headers["sec-websocket-protocol"];
+	if (header === void 0) return [];
+	try {
+		return parseProtocolHeader(Array.isArray(header) ? header.join(",") : header);
+	} catch {
+		abortOrEmit(state, request, socket, 400, "Invalid Sec-WebSocket-Protocol header");
+		return;
+	}
+}
+function selectProtocol(state, protocols, request) {
+	if (protocols.length === 0) return false;
+	const offered = new Set(protocols);
+	const handleProtocols = state.options.handleProtocols;
+	const selected = handleProtocols ? handleProtocols(offered, request) : protocols[0] ?? false;
+	if (!isProtocolToken(selected)) return false;
+	return selected;
+}
+function abortOrEmit(state, request, socket, code, message, headers) {
+	if (listenerCount$1(state.listeners, "wsClientError") > 0) {
+		emitEvent(state, "wsClientError", createError("ERR_PROTOCOL", message), socket, request);
+		return;
+	}
+	abortHandshake(socket, code, message, headers);
+}
+function abortHandshake(socket, code, message, headers) {
+	const status = Number.isInteger(code) && code >= STATUS_MIN && code <= STATUS_MAX ? code : 500;
+	const body = message || STATUS_CODES[status] || "";
+	const merged = {
+		Connection: "close",
+		"Content-Type": "text/html",
+		"Content-Length": Buffer.byteLength(body),
+		...sanitizeHeaders(headers)
+	};
+	const lines = Object.keys(merged).map((name) => `${name}: ${String(merged[name])}`).join("\r\n");
+	socket.once("finish", () => {
+		socket.destroy();
+	});
+	socket.end(`HTTP/1.1 ${status} ${STATUS_CODES[status] ?? ""}\r\n${lines}\r\n\r\n${body}`);
+}
+function sanitizeHeaders(headers) {
+	const safe = {};
+	for (const [name, value] of Object.entries(headers ?? {})) {
+		if (hasControlCharacters(name)) continue;
+		if ((Array.isArray(value) ? value : [value]).some((entry) => entry !== void 0 && hasControlCharacters(String(entry)))) continue;
+		safe[name] = value;
+	}
+	return safe;
+}
+//#endregion
+//#region src/binding/codec-status.ts
+const CODEC_ROLE = {
+	client: 0,
+	server: 1
+};
+const CODEC_OUTCOME = {
+	backpressure: 1,
+	failed: 2,
+	staleHandle: 3
+};
+const CODEC_KINDS = [
+	"text",
+	"binary",
+	"ping",
+	"pong",
+	"close",
+	"rejected",
+	"continuation"
+];
+const CODEC_FAILURES = [
+	"protocolError",
+	"expectedFin",
+	"expectedMask",
+	"invalidCloseCode",
+	"invalidControlPayloadLength",
+	"invalidOpcode",
+	"invalidUtf8",
+	"unexpectedMask",
+	"unexpectedRsv1",
+	"unexpectedRsv2or3",
+	"tooManyBufferedParts",
+	"unsupportedDataPayloadLength",
+	"unsupportedMessageLength",
+	"invalidCompressedData",
+	"invalidMask"
+];
+function decodeOutcome(value) {
+	if (value >= 0) return {
+		kind: "consumed",
+		bytes: value
+	};
+	const ordinal = -value;
+	if (ordinal === CODEC_OUTCOME.backpressure) return { kind: "backpressure" };
+	if (ordinal === CODEC_OUTCOME.failed) return { kind: "failed" };
+	return { kind: "stale-handle" };
+}
+//#endregion
+//#region src/binding/codec-limits.ts
+function codecLimits() {
+	return loadAddon().engineLimits();
+}
+//#endregion
+//#region src/binding/errors.ts
+const NATIVE_ERROR_CODES = {
+	UnknownServer: "ERR_INVALID_HANDLE",
+	InvalidServerState: "ERR_INVALID_STATE",
+	ServerNotClosed: "ERR_INVALID_STATE",
+	EventsPending: "ERR_INVALID_STATE",
+	EnvCleanupUnavailable: "ERR_INVALID_STATE",
+	InvalidHost: "ERR_INVALID_OPTION",
+	InvalidPort: "ERR_INVALID_OPTION",
+	InvalidBacklog: "ERR_INVALID_OPTION",
+	InvalidPath: "ERR_INVALID_OPTION",
+	InvalidConnectionCapacity: "ERR_INVALID_OPTION",
+	InvalidMessageCapacity: "ERR_INVALID_OPTION",
+	InvalidFrameCapacity: "ERR_INVALID_OPTION",
+	ThreadsafeFunctionUnavailable: "ERR_PROTOCOL",
+	CapacityExhausted: "ERR_INVALID_STATE",
+	ServerCapacityExhausted: "ERR_INVALID_STATE",
+	EngineWorkerMissing: "ERR_INVALID_STATE",
+	AddressInUse: "ERR_INVALID_STATE",
+	SystemResources: "ERR_INVALID_STATE",
+	ThreadQuotaExceeded: "ERR_INVALID_STATE",
+	OutOfMemory: "ERR_INVALID_STATE"
+};
+function nativeError(error) {
+	const name = error instanceof Error ? error.message : String(error);
+	const code = NATIVE_ERROR_CODES[name] ?? "ERR_PROTOCOL";
+	return Object.assign(new Error(name), { code });
+}
+function guardError(message, code, constructor = RangeError) {
+	return Object.assign(new constructor(message), { code });
+}
+function callNative(call) {
+	try {
+		return call();
+	} catch (error) {
+		throw nativeError(error);
+	}
+}
+//#endregion
+//#region src/binding/codec-create.ts
+function createCodec(role, options) {
+	const limits = codecLimits();
+	assertCeiling("maxPayload", options.maxPayload, limits.maxPayloadBytes);
+	assertCeiling("maxFragments", options.maxFragments, limits.maxFragments);
+	const addon = loadAddon();
+	return callNative(() => addon.codecCreate(role, options.validateUtf8 ? 1 : 0, options.maxPayload, options.maxFragments, options.permessageDeflate ? 1 : 0));
+}
+function assertCeiling(name, value, ceiling) {
+	if (Number.isSafeInteger(value) && value >= 0 && value <= ceiling) return;
+	throw createError("ERR_INVALID_OPTION", `ventiws: ${name} must be an integer in [0, ${ceiling}] (received ${String(value)})`, RangeError);
+}
+//#endregion
+//#region src/binding/codec-encode.ts
+function encodeCodecFrame(handle, kind, fin, payload, compress, maskFrame = true, mask = EMPTY$3) {
+	const addon = loadAddon();
+	return callNative(() => addon.codecEncode(handle, kind, fin ? 1 : 0, payload, compress ? 1 : 0, maskFrame ? 1 : 0, mask));
+}
+const EMPTY$3 = /* @__PURE__ */ new Uint8Array(0);
+function codecOutbound(handle) {
+	const addon = loadAddon();
+	return callNative(() => addon.codecOutbound(handle));
+}
+//#endregion
+//#region src/binding/codec-state.ts
+function codecFailureCode(handle) {
+	const addon = loadAddon();
+	return callNative(() => addon.codecFailureCode(handle));
+}
+function codecFailure(handle) {
+	const addon = loadAddon();
+	const ordinal = callNative(() => addon.codecFailure(handle));
+	return CODEC_FAILURES[ordinal - 1] ?? null;
+}
+//#endregion
+//#region src/binding/codec.ts
+function destroyCodec(handle) {
+	const addon = loadAddon();
+	callNative(() => addon.codecDestroy(handle));
+}
+function feedCodec(handle, bytes) {
+	const addon = loadAddon();
+	return decodeOutcome(callNative(() => addon.codecFeed(handle, bytes)));
+}
+function codecFeedResume(handle) {
+	const addon = loadAddon();
+	return callNative(() => addon.codecResume(handle));
+}
+function pendingCodecEvents(handle) {
+	const addon = loadAddon();
+	return callNative(() => addon.codecPending(handle));
+}
+function selectCodecEvent(handle) {
+	const addon = loadAddon();
+	return callNative(() => addon.codecSelect(handle));
+}
+function selectedCodecEvent(handle) {
+	const addon = loadAddon();
+	const event = callNative(() => addon.codecEvent(handle));
+	if (event === null) return null;
+	return {
+		kind: CODEC_KINDS[event[0]] ?? "rejected",
+		code: event[1],
+		payload: event[2]
+	};
+}
+function takeCodecEvent(handle) {
+	const addon = loadAddon();
+	callNative(() => addon.codecTake(handle));
+}
+function codecFragmentEnds(handle) {
+	const addon = loadAddon();
+	return callNative(() => addon.codecFragments(handle));
+}
+//#endregion
+//#region src/compat/socket/codec-handle.ts
+function codecOf(state) {
+	return state.codec;
+}
+function openCodec(state, role) {
+	if (state.codec !== null) return state.codec;
+	const handle = createCodec(role, {
+		maxPayload: state.maxPayload,
+		maxFragments: state.maxFragments,
+		validateUtf8: state.validateUtf8,
+		permessageDeflate: state.compressible
+	});
+	state.codec = handle;
+	return handle;
+}
+function closeCodec(state) {
+	if (state.codec === null) return;
+	destroyCodec(state.codec);
+	state.codec = null;
+}
+function isWritable(state) {
+	return state.codec !== null && state.transport !== null && !state.transport.writableEnded;
+}
+function noTransportError() {
+	return createError("ERR_INVALID_STATE", "ventiws: the socket has no transport to write to");
+}
+//#endregion
+//#region src/compat/socket/codec-deferral.ts
+function isDeliveryPaused(state) {
+	return state.deliveryPaused;
+}
+function pauseUntilNextTick(state, resume) {
+	if (state.deliveryPaused) return true;
+	state.deliveryPaused = true;
+	setImmediate(() => {
+		state.deliveryPaused = false;
+		resume();
+	});
+	return true;
+}
+//#endregion
+//#region src/binding/native.ts
+const NATIVE_SOCKET_STATUSES = [
+	"ok",
+	"closing",
+	"closed",
+	"backpressure",
+	"invalidHandle",
+	"payloadTooLarge",
+	"invalidCloseCode",
+	"invalidCloseReason",
+	"protocolError",
+	"policyViolation"
+];
+//#endregion
+//#region src/binding/handle.ts
+const MAX_HANDLE_BIG = 18446744073709551615n;
+function assertConnectionHandle(handle) {
+	if (typeof handle !== "bigint" || handle < 0n || handle > MAX_HANDLE_BIG) throw guardError(`ventiws: connection handle out of range: ${String(handle)}`, "ERR_INVALID_HANDLE");
+}
+//#endregion
+//#region src/binding/server.ts
+const MAX_SERVER_HANDLE = 2 ** 40 - 1;
+function assertServerHandle(handle) {
+	if (!Number.isSafeInteger(handle) || handle < 0 || handle > MAX_SERVER_HANDLE) throw guardError(`ventiws: server handle must be a uint40, got ${handle}`, "ERR_INVALID_HANDLE");
+}
+function engineLimits() {
+	return loadAddon().engineLimits();
+}
+//#endregion
+//#region src/binding/socket.ts
+const MAX_UINT16 = 65535;
+const ENGINE_STATUS_BY_NATIVE = {
+	ok: "ok",
+	closing: "closing",
+	closed: "closed",
+	backpressure: "backpressure",
+	invalidHandle: "invalid-handle",
+	payloadTooLarge: "payload-too-large",
+	invalidCloseCode: "invalid-close-code",
+	invalidCloseReason: "invalid-close-reason",
+	protocolError: "protocol-error",
+	policyViolation: "policy-violation"
+};
+function assertPayload(data) {
+	if (!(data instanceof Uint8Array)) throw guardError("ventiws: socket payload must be a Uint8Array", "ERR_INVALID_OPTION", TypeError);
+}
+function statusFromOrdinal(ordinal) {
+	const status = NATIVE_SOCKET_STATUSES[ordinal];
+	if (status === void 0) throw guardError(`ventiws: unknown native socket status ${ordinal}`, "ERR_PROTOCOL", RangeError);
+	return ENGINE_STATUS_BY_NATIVE[status];
+}
+function assertCloseCode$1(code) {
+	if (!Number.isInteger(code) || code < 0 || code > MAX_UINT16) throw guardError(`ventiws: close code must be a uint16, got ${code}`, "ERR_INVALID_CLOSE_CODE");
+}
+function sendSocket(server, connection, data, binary = false) {
+	assertServerHandle(server);
+	assertConnectionHandle(connection);
+	assertPayload(data);
+	const addon = loadAddon();
+	return statusFromOrdinal(callNative(() => addon.sendSocket(server, connection, data, binary)));
+}
+function closeSocket(server, connection, code, reason) {
+	assertServerHandle(server);
+	assertConnectionHandle(connection);
+	assertCloseCode$1(code);
+	assertPayload(reason);
+	const addon = loadAddon();
+	return statusFromOrdinal(callNative(() => addon.closeSocket(server, connection, code, reason)));
+}
+function pauseSocket(server, connection) {
+	assertServerHandle(server);
+	assertConnectionHandle(connection);
+	const addon = loadAddon();
+	return statusFromOrdinal(callNative(() => addon.pauseSocket(server, connection)));
+}
+function resumeSocket(server, connection) {
+	assertServerHandle(server);
+	assertConnectionHandle(connection);
+	const addon = loadAddon();
+	return statusFromOrdinal(callNative(() => addon.resumeSocket(server, connection)));
+}
+function socketBufferedAmount(server, connection) {
+	assertServerHandle(server);
+	assertConnectionHandle(connection);
+	const addon = loadAddon();
+	return callNative(() => addon.socketBufferedAmount(server, connection));
+}
+//#endregion
+//#region src/compat/socket/queued.ts
+function queuedBytes(state) {
+	if (state.transport === null) return 0;
+	return state.transport.writableLength;
+}
+//#endregion
+//#region src/compat/socket/payload.ts
+const READY_STATE_NAMES = [
+	"CONNECTING",
+	"OPEN",
+	"CLOSING",
+	"CLOSED"
+];
+function toPayload(data) {
+	if (typeof data === "number") return {
+		bytes: Buffer.from(String(data), "utf8"),
+		binary: false
+	};
+	if (typeof data === "string") return data.length === 0 ? {
+		bytes: Buffer.alloc(0),
+		binary: false
+	} : {
+		bytes: Buffer.from(data, "utf8"),
+		binary: false
+	};
+	if (!data) return {
+		bytes: Buffer.alloc(0),
+		binary: true
+	};
+	return {
+		bytes: toBytes(data),
+		binary: true
+	};
+}
+function toBytes(data) {
+	if (ArrayBuffer.isView(data)) return Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+	if (data instanceof ArrayBuffer) return Buffer.from(data);
+	return Buffer.from(data);
+}
+function notOpenError(readyState) {
+	return createError("ERR_SOCKET_NOT_OPEN", `WebSocket is not open: readyState ${readyState} (${READY_STATE_NAMES[readyState] ?? "UNKNOWN"})`);
+}
+function statusError(status) {
+	return createStatusError(status, `ventiws: socket operation failed with status "${status}"`);
+}
+function bufferedAmountOf(state) {
+	if (state.attachment === null) return queuedBytes(state);
+	return socketBufferedAmount(state.attachment.server, state.attachment.connection);
+}
+function defer(callback, error) {
+	if (typeof callback !== "function") return;
+	process.nextTick(callback, error);
+}
+//#endregion
+//#region src/compat/socket/codec-outbound.ts
+function ordinalOf(kind) {
+	return CODEC_KINDS.indexOf(kind);
+}
+function maskFor(state, mask) {
+	if (state.isServer || !mask || state.generateMask === null) return NO_MASK;
+	state.generateMask(state.maskScratch);
+	return state.maskScratch;
+}
+const NO_MASK = /* @__PURE__ */ new Uint8Array(0);
+function writeFrame(state, kind, payload, fin = true, compress = false, mask = true) {
+	const handle = state.codec;
+	if (handle === null) return "closed";
+	if (!isWritable(state)) return state.transport?.writableEnded === true ? "closed" : "closing";
+	const length = encodeCodecFrame(handle, ordinalOf(kind), fin, payload, compress, mask, maskFor(state, mask));
+	if (length < 0) return encodeFailure(-length);
+	const framed = codecOutbound(handle);
+	if (state.transport === null) return "closed";
+	state.transport.write(framed.subarray(0, length));
+	return "ok";
+}
+function writePong(state, payload) {
+	writeFrame(state, "pong", payload);
+}
+function writeCloseFrame(state, code, reason) {
+	if (state.closeFrameSent) return;
+	if (writeFrame(state, "close", closePayload(code, reason)) !== "ok") return;
+	state.closeFrameSent = true;
+}
+function closePayload(code, reason) {
+	if (code === void 0) return Buffer.alloc(0);
+	const payload = Buffer.alloc(2 + reason.length);
+	payload.writeUInt16BE(code, 0);
+	reason.copy(payload, 2);
+	return payload;
+}
+function encodeFailure(ordinal) {
+	switch (ordinal) {
+		case 1: return "protocol-error";
+		case 2: return "payload-too-large";
+		case 3: return "protocol-error";
+		case 4: return "invalid-handle";
+		default: return "protocol-error";
+	}
+}
+function frameError(status) {
+	if (status === "closed" || status === "closing") return noTransportError();
+	if (status === "backpressure") return createError("ERR_BACKPRESSURE", "ventiws: the codec's event queue is full");
+	return statusError(status);
+}
+const CLOSE_NO_STATUS = 1005;
+const CLOSE_ABNORMAL$1 = 1006;
+function isValidControlPayload(payload) {
+	return Buffer.byteLength(payload) <= 125;
+}
+function isValidStatusCode(code) {
+	if (code >= 3e3 && code <= 4999) return true;
+	return code >= 1e3 && code <= 1014 && code !== 1004 && code !== 1005 && code !== 1006;
+}
+//#endregion
+//#region src/compat/socket/close-code.ts
+function closeCodeOf(code) {
+	if (code === void 0) return void 0;
+	return Math.trunc(assertCloseCode(code));
+}
+function assertCloseCode(code) {
+	if (typeof code !== "number" || !isValidStatusCode(code)) throw createError("ERR_INVALID_CLOSE_CODE", "First argument must be a valid error code number", TypeError);
+	return code;
+}
+//#endregion
+//#region src/compat/socket/close-reason.ts
+const EMPTY$2 = Buffer.alloc(0);
+function toCloseReason(reason) {
+	if (reason === void 0) return EMPTY$2;
+	if (reason === null) return EMPTY$2;
+	if (!hasReasonData(reason)) return EMPTY$2;
+	assertReasonLength(Buffer.byteLength(reason));
+	if (typeof reason === "string") return Buffer.from(reason, "utf8");
+	if (reason instanceof Uint8Array) return Buffer.from(reason);
+	throw createError("ERR_INVALID_OPTION", "Second argument must be a string or a Uint8Array", TypeError);
+}
+function hasReasonData(reason) {
+	const length = reason.length;
+	return typeof length === "number" && length > 0;
+}
+function assertReasonLength(length) {
+	if (length <= 123) return;
+	throw createError("ERR_INVALID_CLOSE_REASON", "The message must not be greater than 123 bytes", RangeError);
+}
+//#endregion
+//#region src/compat/socket/close-failure.ts
+function closeFailure(status) {
+	switch (status) {
+		case "backpressure": return createError("ERR_BACKPRESSURE", "ventiws: the outbound staging ring is full");
+		case "invalid-handle": return createError("ERR_INVALID_HANDLE", "ventiws: the connection handle is stale");
+		case "ok":
+		case "closing":
+		case "closed": return createError("ERR_INVALID_STATE", "ventiws: the connection is already closing");
+		case "payload-too-large":
+		case "invalid-close-code":
+		case "invalid-close-reason":
+		case "protocol-error":
+		case "policy-violation": return statusError(status);
+	}
+}
+//#endregion
+//#region src/compat/socket/state.ts
+const SOCKET_BRAND = Symbol("ventiws.socket");
+const SOCKET_STATE = Symbol("ventiws.socket.state");
+function brandSocket(socket, state) {
+	Object.defineProperties(socket, {
+		[SOCKET_BRAND]: { value: true },
+		[SOCKET_STATE]: { value: state }
+	});
+}
+function isSocket(value) {
+	if (typeof value !== "object" || value === null) return false;
+	return value[SOCKET_BRAND] === true;
+}
+function socketStateOf(socket) {
+	if (typeof socket !== "object" || socket === null) return void 0;
+	return socket[SOCKET_STATE];
+}
+function createSocketState() {
+	return {
+		url: "",
+		protocol: "",
+		extensions: "",
+		binaryType: "nodebuffer",
+		readyState: 0,
+		isPaused: false,
+		isServer: true,
+		closeCode: 1006,
+		closeReason: Buffer.alloc(0),
+		closeFrameSent: false,
+		closeFrameReceived: false,
+		fragmentsOpen: false,
+		errorEmitted: false,
+		attachment: null,
+		transport: null,
+		codec: null,
+		closeTimer: null,
+		closeTimeout: DEFAULT_CLOSE_TIMEOUT,
+		allowSynchronousEvents: true,
+		deliveryPaused: false,
+		pendingInput: [],
+		maxBufferedChunks: DEFAULT_MAX_BUFFERED_CHUNKS,
+		validateUtf8: true,
+		maxPayload: DEFAULT_MAX_PAYLOAD,
+		maxFragments: DEFAULT_MAX_FRAGMENTS,
+		cancelHandshake: null,
+		pendingSend: null,
+		compressible: false,
+		threshold: 0,
+		autoPong: true,
+		generateMask: null,
+		maskScratch: Buffer.alloc(4),
+		listeners: createRegistry(),
+		maxListeners: 10,
+		warned: /* @__PURE__ */ new Set(),
+		target: void 0
+	};
+}
+//#endregion
+//#region src/compat/socket/lifecycle.ts
+const EMPTY$1 = Buffer.alloc(0);
+function closeFrameWritten(socket) {
+	return socketStateOf(socket)?.closeFrameSent === true;
+}
+function finishConnection(state, code, reason) {
+	if (state.readyState === 3) return;
+	if (state.closeTimer !== null) {
+		clearTimeout(state.closeTimer);
+		state.closeTimer = null;
+	}
+	state.readyState = 3;
+	state.closeCode = code;
+	state.closeReason = reason;
+	emitEvent(state, "close", code, reason);
+}
+function failConnection(state, error) {
+	if (state.readyState === 3) return;
+	if (!state.errorEmitted) {
+		state.errorEmitted = true;
+		state.readyState = 2;
+		try {
+			emitEvent(state, "error", error);
+		} finally {
+			finishConnection(state, CLOSE_ABNORMAL$1, EMPTY$1);
+		}
+		return;
+	}
+	finishConnection(state, CLOSE_ABNORMAL$1, EMPTY$1);
+}
+function reportWithoutClosing(state, error) {
+	if (state.errorEmitted) return;
+	if (state.readyState === 3) return;
+	state.errorEmitted = true;
+	emitEvent(state, "error", error);
+}
+function closeConnection(state, code, reason) {
+	if (state.readyState === 3) return;
+	if (state.readyState === 0) {
+		failConnection(state, createError("ERR_INVALID_STATE", "WebSocket was closed before the connection was established"));
+		return;
+	}
+	if (state.readyState === 2) return;
+	state.readyState = 2;
+	const closeCode = closeCodeOf(code);
+	const closeReason = toCloseReason(reason);
+	if (state.codec !== null) {
+		closeFramed(state, closeCode, closeReason);
+		armCloseTimeout(state, state.closeTimeout);
+		return;
+	}
+	if (state.attachment === null) {
+		closeUnattached(state);
+		return;
+	}
+	const status = closeSocket(state.attachment.server, state.attachment.connection, closeCode ?? 1e3, closeReason);
+	if (status === "ok") {
+		state.closeFrameSent = true;
+		return;
+	}
+	if (status === "closing" || status === "closed") {
+		finishConnection(state, CLOSE_ABNORMAL$1, EMPTY$1);
+		return;
+	}
+	failConnection(state, closeFailure(status));
+}
+function closeUnattached(state) {
+	state.cancelHandshake?.();
+	if (state.transport === null) {
+		finishConnection(state, CLOSE_ABNORMAL$1, EMPTY$1);
+		return;
+	}
+	state.transport.destroy();
+}
+//#endregion
+//#region src/compat/socket/codec-close.ts
+const CLOSE_ABNORMAL = 1006;
+function closeFramed(state, code, reason) {
+	writeCloseFrame(state, code, reason);
+}
+function refuseFramed(state, refusal) {
+	if (state.readyState === 3) return;
+	state.readyState = 2;
+	writeCloseFrame(state, refusal.closeCode, Buffer.from(refusal.reason, "utf8"));
+	try {
+		if (!state.errorEmitted) {
+			state.errorEmitted = true;
+			emitEvent(state, "error", createError(refusal.code, refusal.message, refusal.ctor));
+		}
+	} finally {
+		finishConnection(state, refusal.closeCode, Buffer.from(refusal.reason, "utf8"));
+		closeCodec(state);
+		state.transport?.end();
+	}
+}
+function armCloseTimeout(state, milliseconds) {
+	clearCloseTimeout(state);
+	state.closeTimer = setTimeout(() => {
+		state.closeTimer = null;
+		if (state.readyState !== 2) return;
+		state.transport?.destroy();
+		finishConnection(state, CLOSE_ABNORMAL, Buffer.alloc(0));
+	}, Math.max(milliseconds, 0));
+	state.closeTimer.unref?.();
+}
+function clearCloseTimeout(state) {
+	if (state.closeTimer === null) return;
+	clearTimeout(state.closeTimer);
+	state.closeTimer = null;
+}
+//#endregion
+//#region src/compat/socket/refusal-table.ts
+const REFUSALS = {
+	expectedFin: refused(1002, "WS_ERR_EXPECTED_FIN", "protocol error", "FIN must be set"),
+	expectedMask: refused(1002, "WS_ERR_EXPECTED_MASK", "protocol error", "MASK must be set"),
+	invalidCloseCode: refused(1002, "WS_ERR_INVALID_CLOSE_CODE", "protocol error", "invalid status code"),
+	invalidControlPayloadLength: refused(1002, "WS_ERR_INVALID_CONTROL_PAYLOAD_LENGTH", "protocol error", "invalid payload length"),
+	invalidOpcode: refused(1002, "WS_ERR_INVALID_OPCODE", "protocol error", "invalid opcode"),
+	unexpectedMask: refused(1002, "WS_ERR_UNEXPECTED_MASK", "protocol error", "MASK must be clear"),
+	unexpectedRsv1: refused(1002, "WS_ERR_UNEXPECTED_RSV_1", "protocol error", "RSV1 must be clear"),
+	unexpectedRsv2or3: refused(1002, "WS_ERR_UNEXPECTED_RSV_2_3", "protocol error", "RSV2 and RSV3 must be clear"),
+	unsupportedDataPayloadLength: {
+		closeCode: 1009,
+		code: "WS_ERR_UNSUPPORTED_DATA_PAYLOAD_LENGTH",
+		reason: "message too big",
+		message: "Unsupported WebSocket frame: payload length > 2^53 - 1",
+		ctor: RangeError
+	},
+	invalidUtf8: {
+		closeCode: 1007,
+		code: "WS_ERR_INVALID_UTF8",
+		reason: "invalid payload",
+		message: "Invalid WebSocket frame: invalid UTF-8 sequence",
+		ctor: Error
+	},
+	invalidCompressedData: {
+		closeCode: 1007,
+		code: "ERR_INVALID_COMPRESSED_DATA",
+		reason: "invalid payload",
+		message: "Invalid WebSocket frame: invalid compressed data",
+		ctor: Error
+	},
+	tooManyBufferedParts: {
+		closeCode: 1008,
+		code: "WS_ERR_TOO_MANY_BUFFERED_PARTS",
+		reason: "too many message fragments",
+		message: "Too many message fragments",
+		ctor: RangeError
+	},
+	unsupportedMessageLength: {
+		closeCode: 1009,
+		code: "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH",
+		reason: "message too big",
+		message: "Max payload size exceeded",
+		ctor: RangeError
+	},
+	invalidMask: {
+		closeCode: 1002,
+		code: "ERR_INVALID_OPTION",
+		reason: "protocol error",
+		message: "ventiws: generateMask must fill all four bytes of the masking key",
+		ctor: RangeError
+	},
+	protocolError: {
+		closeCode: 1002,
+		code: "ERR_PROTOCOL",
+		reason: "protocol error",
+		message: "Invalid WebSocket frame",
+		ctor: RangeError
+	}
+};
+function refused(closeCode, code, reason, detail) {
+	return {
+		closeCode,
+		code,
+		reason,
+		message: `Invalid WebSocket frame: ${detail}`,
+		ctor: RangeError
+	};
+}
+//#endregion
+//#region src/compat/socket/codec-refusal.ts
+function refusalOf(failure) {
+	return REFUSALS[failure] ?? REFUSALS.protocolError;
+}
+function failureByCode(code) {
+	switch (code) {
+		case 1007: return "invalidUtf8";
+		case 1008: return "tooManyBufferedParts";
+		case 1009: return "unsupportedMessageLength";
+		default: return "protocolError";
+	}
+}
+function refuseByCodec(state, failure) {
+	refuseFramed(state, refusalOf(failure));
+}
+//#endregion
+//#region src/compat/socket/payload-shape.ts
+function shapeBinary(binaryType, payload, ends) {
+	switch (binaryType) {
+		case "arraybuffer": return slicedArrayBuffer(payload);
+		case "blob": return new Blob([new Uint8Array(payload)]);
+		case "fragments": return sliceFragments(payload, ends);
+		case "nodebuffer": return payload;
+	}
+}
+function slicedArrayBuffer(payload) {
+	return payload.buffer.slice(payload.byteOffset, payload.byteOffset + payload.byteLength);
+}
+function sliceFragments(payload, ends) {
+	if (ends === null || ends.length === 0) return [payload];
+	const pieces = [];
+	let start = 0;
+	for (const end of ends) {
+		const at = Math.min(end, payload.length);
+		if (at > start) pieces.push(payload.subarray(start, at));
+		start = at;
+	}
+	if (start < payload.length) pieces.push(payload.subarray(start));
+	return pieces.length > 0 ? pieces : [payload];
+}
+//#endregion
+//#region src/compat/socket/codec-peer-close.ts
+function closeFromPeer(state, event) {
+	if (state.readyState !== 2) state.readyState = 2;
+	state.closeFrameReceived = true;
+	if (!state.closeFrameSent) writeCloseFrame(state, event.code === 0 ? void 0 : event.code, event.payload);
+	finishConnection(state, event.code === 0 ? CLOSE_NO_STATUS : event.code, event.payload);
+	closeCodec(state);
+	state.transport?.end();
+}
+//#endregion
+//#region src/compat/socket/codec-events.ts
+function deliver(state, resume) {
+	drain(state, false, resume);
+}
+function drainReleased(state, resume) {
+	drain(state, true, resume);
+}
+function drain(state, released, resume) {
+	const handle = codecOf(state);
+	if (handle === null) return;
+	if (isDeliveryPaused(state)) return;
+	let honoured = released;
+	while (pendingCodecEvents(handle) > 0 && selectCodecEvent(handle)) {
+		const event = selectedCodecEvent(handle);
+		if (!honoured && state.allowSynchronousEvents === false && isDeferrable(event)) {
+			pauseUntilNextTick(state, resume);
+			return;
+		}
+		honoured = false;
+		const ends = codecFragmentEnds(handle);
+		takeCodecEvent(handle);
+		if (event === null) continue;
+		dispatch(state, handle, event, ends);
+		if (state.readyState === 3) return;
+	}
+}
+function isDeferrable(event) {
+	if (event === null) return false;
+	return event.kind === "text" || event.kind === "binary" || event.kind === "ping" || event.kind === "pong";
+}
+function dispatch(state, handle, event, ends) {
+	switch (event.kind) {
+		case "text":
+			emitEvent(state, "message", event.payload, false);
+			return;
+		case "binary":
+			emitBinary(state, event, ends);
+			return;
+		case "ping":
+			if (state.autoPong) writePong(state, event.payload);
+			emitEvent(state, "ping", event.payload);
+			return;
+		case "pong":
+			emitEvent(state, "pong", event.payload);
+			return;
+		case "close":
+			closeFromPeer(state, event);
+			return;
+		case "rejected":
+			refuseByCodec(state, codecFailure(handle) ?? failureByCode(codecFailureCode(handle)));
+			return;
+	}
+}
+function emitBinary(state, event, ends) {
+	emitEvent(state, "message", shapeBinary(state.binaryType, event.payload, ends), true);
+}
+//#endregion
+//#region src/compat/socket/codec-inbound.ts
+function driveInbound(state, transport, pending) {
+	if (pending !== void 0 && pending.length > 0) ingest(state, pending);
+	transport.on("data", (chunk) => {
+		ingest(state, chunk);
+	});
+}
+function ingest(state, chunk) {
+	const handle = codecOf(state);
+	if (handle === null) return;
+	if (state.pendingInput.length > 0) {
+		enqueue(state, chunk);
+		return;
+	}
+	consume(state, handle, chunk);
+}
+function enqueue(state, chunk) {
+	if (state.maxBufferedChunks > 0 && state.pendingInput.length >= state.maxBufferedChunks) refuseByCodec(state, "tooManyBufferedParts");
+	else state.pendingInput.push(chunk);
+}
+function consume(state, handle, chunk) {
+	let rest = chunk;
+	while (rest.length > 0) {
+		const outcome = feedCodec(handle, rest);
+		try {
+			deliver(state, () => {
+				guardedResume(state);
+			});
+		} catch (error) {
+			failOnThrow(state, error);
+			throw error;
+		}
+		if (outcome.kind === "failed") {
+			refuseByCodec(state, codecFailure(handle) ?? failureByCode(codecFailureCode(handle)));
+			return;
+		}
+		if (outcome.kind === "stale-handle") return;
+		const consumed = outcome.kind === "consumed" ? outcome.bytes : codecFeedResume(handle);
+		if (consumed <= 0) return;
+		rest = rest.subarray(consumed);
+		if (outcome.kind === "consumed") return;
+		if (isDeliveryPaused(state)) {
+			enqueue(state, rest);
+			return;
+		}
+	}
+}
+function failOnThrow(state, error) {
+	if (state.readyState === 3) return;
+	try {
+		failConnection(state, error instanceof Error ? error : createError("ERR_PROTOCOL", String(error)));
+	} finally {
+		closeCodec(state);
+		state.transport?.destroy();
+	}
+}
+function guardedResume(state) {
+	try {
+		resume(state);
+	} catch (error) {
+		failOnThrow(state, error);
+		throw error;
+	}
+}
+function resume(state) {
+	drainReleased(state, () => {
+		guardedResume(state);
+	});
+	const queued = state.pendingInput;
+	const handle = codecOf(state);
+	state.pendingInput = [];
+	if (handle === null) return;
+	for (const [index, chunk] of queued.entries()) {
+		if (codecOf(state) === null) return;
+		consume(state, handle, chunk);
+		if (!isDeliveryPaused(state)) continue;
+		state.pendingInput = state.pendingInput.concat(queued.slice(index + 1));
+		return;
+	}
+}
+//#endregion
+//#region src/compat/socket/transport.ts
+const EMPTY = Buffer.alloc(0);
+function failTransport(state, error) {
+	if (state.readyState === 3) return;
+	state.readyState = 2;
+	emitEvent(state, "error", error);
+}
+function terminateConnection(state) {
+	if (state.readyState === 3) return;
+	if (state.readyState === 0) {
+		failConnection(state, createError("ERR_INVALID_STATE", "WebSocket was closed before the connection was established"));
+		return;
+	}
+	state.readyState = 2;
+	if (state.transport !== null) {
+		state.transport.destroy();
+		return;
+	}
+	finishConnection(state, CLOSE_ABNORMAL$1, EMPTY);
+}
+//#endregion
+//#region src/compat/socket/attach.ts
+function attachSocket(socket, transport, role, pending) {
+	const state = socketStateOf(socket);
+	if (state === void 0) throw createError("ERR_INVALID_HANDLE", "ventiws: attachSocket requires a ventiws socket record");
+	if (!transport.readable || !transport.writable) {
+		const gone = createError("ERR_INVALID_STATE", "ventiws: the transport was closed before the connection was established");
+		process.nextTick(() => {
+			failConnection(state, gone);
+		});
+		transport.destroy();
+		return;
+	}
+	state.transport = transport;
+	openCodec(state, role ?? CODEC_ROLE.server);
+	transport.on("end", () => {
+		if (state.readyState !== 3) state.readyState = 2;
+		transport.end();
+	});
+	transport.on("error", (error) => {
+		try {
+			failTransport(state, asCodedError(error));
+		} finally {
+			transport.destroy();
+		}
+	});
+	transport.on("close", () => {
+		closeCodec(state);
+		finishConnection(state, state.closeCode, state.closeReason);
+	});
+	openSocket(state);
+	driveInbound(state, transport, pending);
+}
+function openSocket(state) {
+	if (state.readyState === 1) return;
+	state.readyState = 1;
+	emitEvent(state, "open");
+}
+function asCodedError(error) {
+	if (error instanceof Error) return error;
+	return createError("ERR_PROTOCOL", `ventiws: the transport failed: ${String(error)}`);
+}
+//#endregion
+//#region src/compat/server/handshake-error.ts
+const HANDSHAKE_ERROR = Symbol("ventiws.handshakeError");
+function attachHandshakeError(socket) {
+	const handler = () => {
+		socket.destroy();
+	};
+	socket[HANDSHAKE_ERROR] = handler;
+	socket.on("error", handler);
+}
+function detachHandshakeError(socket) {
+	const record = socket;
+	const handler = record[HANDSHAKE_ERROR];
+	if (handler === void 0) return;
+	socket.removeListener("error", handler);
+	delete record[HANDSHAKE_ERROR];
+}
+//#endregion
+//#region src/compat/extensions/format.ts
+function formatExtension(name, parameters) {
+	const parts = [name];
+	for (const [key, value] of Object.entries(parameters)) parts.push(value === "" ? key : `${key}=${value}`);
+	return parts.join("; ");
+}
+//#endregion
+//#region src/compat/extensions/negotiated.ts
+const PERMESSAGE_DEFLATE = "permessage-deflate";
+const NO_CONTEXT_TAKEOVER = {
+	server_no_context_takeover: "",
+	client_no_context_takeover: ""
+};
+//#endregion
+//#region src/compat/extensions/params.ts
+const MIN_WINDOW_BITS = 8;
+const MAX_WINDOW_BITS = 15;
+function normalizeParameters(parameters, isServer) {
+	const out = {};
+	for (const [key, values] of Object.entries(parameters)) {
+		if (values.length > 1) return null;
+		const parsed = parseParameter(key, values[0] ?? "", isServer);
+		if (parsed === null) return null;
+		out[key] = parsed;
+	}
+	return {
+		server_no_context_takeover: out.server_no_context_takeover === true,
+		client_no_context_takeover: out.client_no_context_takeover === true,
+		server_max_window_bits: numberOf(out.server_max_window_bits),
+		client_max_window_bits: windowOf(out.client_max_window_bits)
+	};
+}
+function parseParameter(key, value, isServer) {
+	if (key === "server_no_context_takeover" || key === "client_no_context_takeover") return value === "" ? true : null;
+	if (key === "client_max_window_bits") {
+		if (value === "") return isServer ? true : null;
+		return windowSize(value);
+	}
+	if (key === "server_max_window_bits") return value === "" ? null : windowSize(value);
+	return null;
+}
+function windowSize(value) {
+	const parsed = Number(value);
+	if (!Number.isInteger(parsed) || parsed < MIN_WINDOW_BITS || parsed > MAX_WINDOW_BITS) return null;
+	return parsed;
+}
+function windowOf(value) {
+	return typeof value === "number" || value === true ? value : void 0;
+}
+function numberOf(value) {
+	return typeof value === "number" ? value : void 0;
+}
+//#endregion
+//#region src/compat/extensions/window.ts
+function narrowed(parameters, name, option) {
+	if (typeof option !== "number" || option >= 15) return;
+	parameters[name] = String(option);
+}
+//#endregion
+//#region src/compat/extensions/offer-window.ts
+function serverWindowUsable(options, offer) {
+	const asked = offer.server_max_window_bits;
+	if (asked === void 0) return true;
+	if (options.serverMaxWindowBits === false) return false;
+	if (typeof options.serverMaxWindowBits === "number") {
+		if (options.serverMaxWindowBits > asked) return false;
+		return options.serverMaxWindowBits >= 15;
+	}
+	return asked >= 15;
+}
+//#endregion
+//#region src/compat/extensions/decline.ts
+function declines(options, offer) {
+	if (options.serverNoContextTakeover === false && offer.server_no_context_takeover) return true;
+	if (offer.server_max_window_bits !== void 0 && !serverWindowUsable(options, offer)) return true;
+	if (offer.client_max_window_bits === true && options.clientMaxWindowBits === false) return true;
+	if (typeof options.clientMaxWindowBits === "number") {
+		if (offer.client_max_window_bits === void 0) return true;
+		const asked = offer.client_max_window_bits;
+		if (typeof asked === "number" && options.clientMaxWindowBits > asked) return true;
+	}
+	return false;
+}
+//#endregion
+//#region src/compat/extensions/deflate.ts
+function acceptAsServer(offers, options) {
+	if (options === false) return null;
+	if (offers.length === 0) return null;
+	for (const offer of offers) {
+		const normalized = normalizeParameters(offer.parameters, true);
+		if (normalized === null) return { refusal: "Invalid or unacceptable Sec-WebSocket-Extensions header" };
+		if (declines(options, normalized)) continue;
+		return { accepted: answer(options, normalized) };
+	}
+	return { refusal: "Invalid or unacceptable Sec-WebSocket-Extensions header" };
+}
+function acceptAsClient(response, options) {
+	if (options === false) return null;
+	const normalized = normalizeParameters(response.parameters, false);
+	if (normalized === null) return { refusal: "Invalid Sec-WebSocket-Extensions header" };
+	if (normalized.client_no_context_takeover && options.clientNoContextTakeover === false) return { refusal: "Unexpected parameter \"client_no_context_takeover\"" };
+	const asked = normalized.client_max_window_bits;
+	if (asked === void 0) return { accepted: answer(options, normalized) };
+	if (asked === true) return { refusal: "Value must be specified for \"client_max_window_bits\"" };
+	const wanted = options.clientMaxWindowBits;
+	if (wanted === false) return { refusal: "Unexpected or invalid parameter \"client_max_window_bits\"" };
+	if (typeof wanted === "number" && asked > wanted) return { refusal: "Unexpected or invalid parameter \"client_max_window_bits\"" };
+	if (typeof asked === "number" && asked < 15) return { refusal: "Server requested a window this implementation cannot use" };
+	return { accepted: answer(options, normalized) };
+}
+function answer(options, offer) {
+	const parameters = { ...NO_CONTEXT_TAKEOVER };
+	if (offer.server_no_context_takeover) parameters.server_no_context_takeover = "";
+	narrowed(parameters, "server_max_window_bits", options.serverMaxWindowBits);
+	narrowed(parameters, "client_max_window_bits", options.clientMaxWindowBits);
+	return {
+		name: PERMESSAGE_DEFLATE,
+		parameters,
+		header: formatExtension(PERMESSAGE_DEFLATE, parameters)
+	};
+}
+//#endregion
+//#region src/compat/extensions/scan.ts
+const TOKEN$1 = /^[!#$%&'*+\-.0-9A-Z^_`|a-z~]+$/;
+const COMMA$1 = 44;
+const SEMICOLON = 59;
+const EQUALS = 61;
+const QUOTE = 34;
+const isWhitespace = (code) => code === 32 || code === 9;
+function scanConfiguration(header, start) {
+	const name = readToken(header, start, "an extension name");
+	if (name === null) throw unexpectedEnd(header, start);
+	const parameters = {};
+	let index = start + name.length;
+	for (;;) {
+		index = skipWhitespace(header, index);
+		if (index >= header.length || header.charCodeAt(index) === COMMA$1) break;
+		if (header.charCodeAt(index) !== SEMICOLON) throw syntax(header, index, "expected ';' or ','");
+		const afterSemicolon = skipWhitespace(header, index + 1);
+		if (afterSemicolon >= header.length) {
+			index = afterSemicolon;
+			break;
+		}
+		index = readParameter(header, index, parameters);
+	}
+	return {
+		name,
+		parameters,
+		rest: index
+	};
+}
+function readParameter(header, start, into) {
+	const nameStart = skipWhitespace(header, start + 1);
+	const name = readToken(header, nameStart, "a parameter name");
+	if (name === null) throw unexpectedEnd(header, nameStart);
+	const afterEquals = skipWhitespace(header, nameStart + name.length);
+	if (header.charCodeAt(afterEquals) !== EQUALS) {
+		push(into, name, "");
+		return afterEquals;
+	}
+	const value = readValue(header, skipWhitespace(header, afterEquals + 1));
+	push(into, name, value.value);
+	return value.end;
+}
+function push(into, name, value) {
+	const existing = into[name];
+	if (existing === void 0) into[name] = [value];
+	else existing.push(value);
+}
+function readValue(header, start) {
+	if (header.charCodeAt(start) !== QUOTE) {
+		const token = readToken(header, start, "a parameter value");
+		if (token === null) throw unexpectedEnd(header, start);
+		if (!TOKEN$1.test(token)) throw syntax(header, start, "invalid parameter value");
+		return {
+			value: token,
+			end: start + token.length
+		};
+	}
+	let index = start + 1;
+	let value = "";
+	for (;;) {
+		if (index >= header.length) throw unexpectedEnd(header, start);
+		const char = header[index];
+		if (char === "\\") {
+			const escaped = header[index + 1];
+			if (escaped === void 0) throw unexpectedEnd(header, index);
+			value += escaped;
+			index += 2;
+			continue;
+		}
+		if (char === "\"") return {
+			value,
+			end: index + 1
+		};
+		value += char;
+		index += 1;
+	}
+}
+function readToken(header, start, what) {
+	let index = start;
+	while (index < header.length) {
+		const code = header.charCodeAt(index);
+		if (isWhitespace(code) || code === SEMICOLON || code === COMMA$1 || code === EQUALS) break;
+		if (code === QUOTE) throw syntax(header, index, `expected ${what}`);
+		index += 1;
+	}
+	if (index === start) return null;
+	return header.slice(start, index);
+}
+function skipWhitespace(header, start) {
+	let index = start;
+	while (index < header.length && isWhitespace(header.charCodeAt(index))) index += 1;
+	return index;
+}
+function syntax(header, at, detail) {
+	return /* @__PURE__ */ new SyntaxError(`Invalid Sec-WebSocket-Extensions header at ${at}: ${detail}`);
+}
+function unexpectedEnd(header, at) {
+	return /* @__PURE__ */ new SyntaxError(`Unexpected end of Sec-WebSocket-Extensions header at ${at}`);
+}
+//#endregion
+//#region src/compat/extensions/grammar.ts
+function parseExtensions(header) {
+	const out = /* @__PURE__ */ new Map();
+	let index = 0;
+	while (index < header.length) {
+		const scanned = scanConfiguration(header, index);
+		const extension = {
+			name: scanned.name,
+			parameters: scanned.parameters
+		};
+		index = skipWhitespace(header, scanned.rest);
+		if (index < header.length) {
+			if (header.charCodeAt(index) !== COMMA) throw syntax(header, index, "expected ',' between extensions");
+			index = skipWhitespace(header, index + 1);
+		}
+		const existing = out.get(extension.name);
+		if (existing === void 0) out.set(extension.name, [extension]);
+		else existing.push(extension);
+	}
+	if (out.size === 0) throw unexpectedEnd(header, 0);
+	return out;
+}
+const COMMA = 44;
+//#endregion
+//#region src/compat/server/negotiate.ts
+function negotiateExtensions(state, request, socket) {
+	const options = state.normalizedOptions.perMessageDeflate;
+	if (options === false) return { outcome: "none" };
+	const header = request.headers["sec-websocket-extensions"];
+	if (header === void 0) return { outcome: "none" };
+	let offers;
+	try {
+		offers = parseExtensions(Array.isArray(header) ? header.join(", ") : header).get("permessage-deflate") ?? [];
+	} catch {
+		abortOrEmit(state, request, socket, 400, "Invalid Sec-WebSocket-Extensions header");
+		return { outcome: "refused" };
+	}
+	const outcome = acceptAsServer(offers, options);
+	if (outcome === null) return { outcome: "none" };
+	if ("refusal" in outcome) {
+		abortOrEmit(state, request, socket, 400, outcome.refusal);
+		return { outcome: "refused" };
+	}
+	return {
+		outcome: "accepted",
+		accepted: outcome.accepted
+	};
+}
+//#endregion
+//#region src/compat/extensions/threshold.ts
+function thresholdOf(options) {
+	if (options === false) return 0;
+	return options.threshold;
+}
+//#endregion
+//#region src/compat/server/accept.ts
+const UPGRADED = Symbol("ventiws.upgraded");
+function completeUpgrade(state, request, socket, head, key, protocols, callback) {
+	if (!socket.readable || !socket.writable) {
+		socket.destroy();
+		return;
+	}
+	if (socket[UPGRADED] === true) throw createError("ERR_INVALID_STATE", "server.handleUpgrade() was called more than once with the same socket, possibly due to a misconfiguration");
+	if (state.lifecycle !== "running") {
+		abortHandshake(socket, 503);
+		return;
+	}
+	const headers = [
+		"HTTP/1.1 101 Switching Protocols",
+		"Upgrade: websocket",
+		"Connection: Upgrade",
+		`Sec-WebSocket-Accept: ${socketAccept(key)}`
+	];
+	const negotiation = negotiateExtensions(state, request, socket);
+	if (negotiation.outcome === "refused") return;
+	const extensions = negotiation.outcome === "accepted" ? negotiation.accepted : null;
+	const SocketClass = state.options.WebSocket ?? state.webSocket;
+	const accepted = Reflect.construct(SocketClass, [
+		null,
+		void 0,
+		state.options
+	]);
+	const protocol = selectProtocol(state, protocols, request);
+	if (protocol) headers.push(`Sec-WebSocket-Protocol: ${protocol}`);
+	if (extensions) headers.push(`Sec-WebSocket-Extensions: ${extensions.header}`);
+	emitEvent(state, "headers", headers, request);
+	Object.defineProperty(socket, UPGRADED, { value: true });
+	detachHandshakeError(socket);
+	socket.write(headers.concat("\r\n").join("\r\n"));
+	const acceptedState = socketStateOf(accepted);
+	if (acceptedState !== void 0 && protocol) acceptedState.protocol = protocol;
+	if (acceptedState !== void 0) {
+		acceptedState.closeTimeout = state.normalizedOptions.closeTimeout;
+		acceptedState.autoPong = state.normalizedOptions.autoPong;
+		acceptedState.allowSynchronousEvents = state.normalizedOptions.allowSynchronousEvents;
+		acceptedState.validateUtf8 = !state.normalizedOptions.skipUTF8Validation;
+		acceptedState.maxPayload = state.normalizedOptions.maxPayload;
+		acceptedState.maxFragments = state.normalizedOptions.maxFragments;
+		acceptedState.maxBufferedChunks = state.normalizedOptions.maxBufferedChunks;
+		acceptedState.compressible = extensions !== null;
+		if (extensions) acceptedState.extensions = extensions.header;
+		acceptedState.threshold = thresholdOf(state.normalizedOptions.perMessageDeflate);
+	}
+	attachSocket(accepted, socket);
+	if (state.normalizedOptions.clientTracking) trackClient(state, accepted);
+	callback(accepted, request);
+}
+//#endregion
+//#region src/compat/server/upgrade.ts
+function defaultShouldHandle(state, request) {
+	const path = state.options.path;
+	if (!path) return true;
+	const url = request.url ?? "";
+	const index = url.indexOf("?");
+	return (index !== -1 ? url.slice(0, index) : url) === path;
+}
+function shouldHandle(state, request) {
+	const assigned = state.record?.shouldHandle;
+	if (typeof assigned === "function") return assigned(request);
+	return defaultShouldHandle(state, request);
+}
+function handleUpgrade(state, request, socket, head, callback) {
+	attachHandshakeError(socket);
+	const key = request.headers["sec-websocket-key"];
+	const upgrade = request.headers.upgrade;
+	const version = Number(request.headers["sec-websocket-version"]);
+	if (request.method !== "GET") {
+		abortOrEmit(state, request, socket, 405, "Invalid HTTP method");
+		return;
+	}
+	if (typeof upgrade !== "string" || upgrade.toLowerCase() !== "websocket") {
+		abortOrEmit(state, request, socket, 400, "Invalid Upgrade header");
+		return;
+	}
+	if (typeof key !== "string" || !KEY_PATTERN.test(key)) {
+		abortOrEmit(state, request, socket, 400, "Missing or invalid Sec-WebSocket-Key header");
+		return;
+	}
+	if (version !== 13 && version !== 8) {
+		abortOrEmit(state, request, socket, 400, "Missing or invalid Sec-WebSocket-Version header", { "Sec-WebSocket-Version": "13, 8" });
+		return;
+	}
+	if (!shouldHandle(state, request)) {
+		abortHandshake(socket, 400);
+		return;
+	}
+	const protocols = parseProtocols(state, request, socket);
+	if (protocols === void 0) return;
+	const verify = state.options.verifyClient ?? null;
+	if (verify === null) {
+		completeUpgrade(state, request, socket, head, key, protocols, callback);
+		return;
+	}
+	const info = {
+		origin: requestHeader(request, version === 8 ? "sec-websocket-origin" : "origin"),
+		secure: isSecure(request),
+		req: request
+	};
+	if (verify.length === 2) {
+		verify(info, (verified, code, message, headers) => {
+			if (!verified) {
+				abortHandshake(socket, code || 401, message, headers);
+				return;
+			}
+			completeUpgrade(state, request, socket, head, key, protocols, callback);
+		});
+		return;
+	}
+	if (!verify(info)) {
+		abortHandshake(socket, 401);
+		return;
+	}
+	completeUpgrade(state, request, socket, head, key, protocols, callback);
+}
+//#endregion
+//#region src/compat/server/listeners.ts
+function wireServer(state) {
+	const httpServer = state.server;
+	if (httpServer === null) return;
+	const handlers = {
+		onListening: () => {
+			emitEvent(state, "listening");
+		},
+		onError: (error) => {
+			emitEvent(state, "error", error);
+		},
+		onUpgrade: (request, socket, head) => {
+			handleUpgrade(state, request, socket, head, (accepted, incoming) => {
+				emitEvent(state, "connection", accepted, incoming);
+			});
+		}
+	};
+	httpServer.on("listening", handlers.onListening);
+	httpServer.on("error", handlers.onError);
+	httpServer.on("upgrade", handlers.onUpgrade);
+	state.removeListeners = () => {
+		httpServer.removeListener("listening", handlers.onListening);
+		httpServer.removeListener("error", handlers.onError);
+		httpServer.removeListener("upgrade", handlers.onUpgrade);
+	};
+}
+//#endregion
+//#region src/compat/options/bounded.ts
+function maxPayloadOf(source, ceiling) {
+	return boundedOption("maxPayload", source, DEFAULT_MAX_PAYLOAD, ceiling);
+}
+function maxFragmentsOf(source, ceiling) {
+	return boundedOption("maxFragments", source, DEFAULT_MAX_FRAGMENTS, ceiling);
+}
+function maxBufferedChunksOf(source) {
+	const raw = source.maxBufferedChunks;
+	if (raw === void 0) return DEFAULT_MAX_BUFFERED_CHUNKS;
+	if (typeof raw !== "number" || !Number.isSafeInteger(raw) || raw < 0) invalidOption(`The maxBufferedChunks option must be an integer in [0, ${Number.MAX_SAFE_INTEGER}] (received ${String(raw)})`, RangeError);
+	return raw;
+}
+function boundedOption(name, source, fallback, readCeiling) {
+	const raw = source[name];
+	if (raw === void 0) return fallback;
+	if (typeof raw === "number" && Number.isSafeInteger(raw) && raw >= 0 && raw === 0) return readCeiling();
+	const ceiling = readCeiling();
+	if (typeof raw !== "number" || !Number.isSafeInteger(raw) || raw < 0 || raw > ceiling) invalidOption(`The ${name} option must be an integer in [0, ${ceiling}] (received ${String(raw)})`, RangeError);
+	return raw;
+}
+//#endregion
+//#region src/compat/options/server.ts
+function normalizeServerOptions(options) {
+	const source = { ...options };
+	const port = source.port ?? null;
+	const server = source.server ?? null;
+	const noServer = source.noServer ?? false;
+	if (isAmbiguousListenTarget(port, server, noServer)) invalidOption("One and only one of the \"port\", \"server\", or \"noServer\" options must be specified");
+	return {
+		host: source.host ?? null,
+		port,
+		backlog: source.backlog ?? null,
+		path: source.path ?? null,
+		server,
+		noServer,
+		clientTracking: source.clientTracking === void 0 ? true : Boolean(source.clientTracking),
+		allowSynchronousEvents: source.allowSynchronousEvents ?? true,
+		autoPong: source.autoPong ?? true,
+		maxPayload: maxPayloadOf(source, () => codecLimits().maxPayloadBytes),
+		maxFragments: maxFragmentsOf(source, () => codecLimits().maxFragments),
+		maxBufferedChunks: maxBufferedChunksOf(source),
+		skipUTF8Validation: source.skipUTF8Validation ?? false,
+		perMessageDeflate: normalizePerMessageDeflate(source.perMessageDeflate, false),
+		closeTimeout: closeTimeoutOf(source),
+		verifyClient: source.verifyClient ?? null,
+		handleProtocols: source.handleProtocols ?? null,
+		WebSocket: source.WebSocket
+	};
+}
+function isAmbiguousListenTarget(port, server, noServer) {
+	const hasPort = port !== null;
+	const hasServer = Boolean(server);
+	if (hasPort && (hasServer || noServer)) return true;
+	if (hasServer && noServer) return true;
+	return !hasPort && !hasServer && !noServer;
+}
+//#endregion
+//#region src/compat/server/server.ts
+const SERVER_BRAND = Symbol("ventiws.server");
+function requireAddon() {
+	loadAddon();
+}
+function isServer(value) {
+	if (typeof value !== "object" || value === null) return false;
+	return value[SERVER_BRAND] === true;
+}
+function createWebSocketServer(socketClass, options, callback) {
+	requireAddon();
+	const resolved = {
+		allowSynchronousEvents: true,
+		autoPong: true,
+		maxBufferedChunks: 262144,
+		maxFragments: 16384,
+		closeTimeout: 3e4,
+		maxPayload: 104857600,
+		skipUTF8Validation: false,
+		perMessageDeflate: false,
+		handleProtocols: null,
+		clientTracking: true,
+		verifyClient: null,
+		noServer: false,
+		backlog: null,
+		server: null,
+		host: null,
+		path: null,
+		port: null,
+		WebSocket: socketClass,
+		...options
+	};
+	if (resolved.perMessageDeflate === true) resolved.perMessageDeflate = {};
+	const normalized = normalizeServerOptions(resolved);
+	const state = {
+		options: resolved,
+		normalizedOptions: normalized,
+		path: resolved.path ?? "",
+		clients: normalized.clientTracking ? /* @__PURE__ */ new Set() : void 0,
+		webSocket: resolved.WebSocket ?? socketClass,
+		server: null,
+		lifecycle: "running",
+		record: null,
+		shouldEmitClose: false,
+		removeListeners: null,
+		listeners: createRegistry(),
+		maxListeners: 10,
+		warned: /* @__PURE__ */ new Set(),
+		target: void 0
+	};
+	if (resolved.port !== null && resolved.port !== void 0) {
+		const httpServer = createServer((_request, response) => {
+			const body = STATUS_CODES[426] ?? "Upgrade Required";
+			response.writeHead(426, {
+				"Content-Length": Buffer.byteLength(body),
+				"Content-Type": "text/plain"
+			});
+			response.end(body);
+		});
+		state.server = httpServer;
+		httpServer.listen(resolved.port, resolved.host ?? void 0, resolved.backlog ?? void 0, callback);
+	} else if (resolved.server) state.server = resolved.server;
+	if (state.server !== null) wireServer(state);
+	const server = {
+		...createEmitter(state),
+		options: resolved,
+		path: state.path,
+		...state.clients === void 0 ? {} : { clients: state.clients },
+		address: () => addressOf(state),
+		close: (closeCallback) => {
+			closeWebSocketServer(state, closeCallback);
+		},
+		handleUpgrade: (request, socket, head, upgradeCallback) => {
+			handleUpgrade(state, request, socket, head, upgradeCallback);
+		},
+		shouldHandle: (request) => defaultShouldHandle(state, request)
+	};
+	state.target = server;
+	state.record = server;
+	Object.defineProperty(server, SERVER_BRAND, { value: true });
+	return server;
+}
+//#endregion
+//#region src/compat/client/protocols.ts
+const TOKEN = /^[!#$%&'*+\-.^_`|~\dA-Za-z]+$/;
+function normalizeProtocols(protocols) {
+	if (protocols === void 0) return [];
+	const list = typeof protocols === "string" ? [protocols] : protocols;
+	if (!Array.isArray(list)) throw createError("ERR_INVALID_OPTION", "An invalid or duplicated subprotocol was specified", SyntaxError);
+	const seen = /* @__PURE__ */ new Set();
+	for (const protocol of list) {
+		if (typeof protocol !== "string" || !TOKEN.test(protocol) || seen.has(protocol)) throw createError("ERR_INVALID_OPTION", "An invalid or duplicated subprotocol was specified", SyntaxError);
+		seen.add(protocol);
+	}
+	return [...list];
+}
+function protocolSet(protocols) {
+	return new Set(protocols);
+}
+function promoteOptions(protocols, options) {
+	if (typeof protocols !== "object" || protocols === null || Array.isArray(protocols)) return {
+		protocols,
+		options
+	};
+	return {
+		protocols: void 0,
+		options: protocols
+	};
+}
+function protocolRejection(chosen, offered) {
+	if (chosen === void 0) return offered.size > 0 ? "Server sent no subprotocol" : null;
+	if (offered.size === 0) return "Server sent a subprotocol but none was requested";
+	if (!offered.has(chosen)) return "Server sent an invalid subprotocol";
+	return null;
+}
+//#endregion
+//#region src/compat/events/dom-events.ts
+function createOpenEvent(target) {
+	return {
+		type: "open",
+		target
+	};
+}
+function createMessageEvent(target, data) {
+	return {
+		type: "message",
+		target,
+		data
+	};
+}
+function createCloseEvent(target, code, reason, wasClean) {
+	return {
+		type: "close",
+		target,
+		code,
+		reason: reason.toString(),
+		wasClean
+	};
+}
+function createErrorEvent(target, error) {
+	return {
+		type: "error",
+		target,
+		error,
+		message: error.message
+	};
+}
+function callListener(handler, target, event) {
+	if (typeof handler === "function") {
+		Reflect.apply(handler, target, [event]);
+		return;
+	}
+	if (typeof handler === "object" && handler !== null) {
+		const handleEvent = handler.handleEvent;
+		if (typeof handleEvent === "function") {
+			Reflect.apply(handleEvent, handler, [event]);
+			return;
+		}
+	}
+	throw new TypeError("EventListener must be a function or an object with a handleEvent method");
+}
+//#endregion
+//#region src/compat/events/dom-listeners.ts
+const DOM_TYPES = [
+	"open",
+	"error",
+	"close",
+	"message"
+];
+const ATTRIBUTES = [
+	["onopen", "open"],
+	["onerror", "error"],
+	["onclose", "close"],
+	["onmessage", "message"]
+];
+function isDomType(type) {
+	return DOM_TYPES.includes(type);
+}
+function isAttribute(entry) {
+	const tagged = asTagged(entry);
+	return tagged[DOM_WRAPPER] === true && tagged.attribute === true;
+}
+function wrapperFor(state, type, handler) {
+	const socket = state.target;
+	switch (type) {
+		case "open": return (() => {
+			callListener(handler, socket, createOpenEvent(socket));
+		});
+		case "message": return ((data, isBinary) => {
+			callListener(handler, socket, createMessageEvent(socket, isBinary ? data : data.toString()));
+		});
+		case "close": return ((code, reason) => {
+			const clean = state.closeFrameReceived && state.closeFrameSent;
+			callListener(handler, socket, createCloseEvent(socket, code, reason, clean));
+		});
+		case "error": return ((error) => {
+			callListener(handler, socket, createErrorEvent(socket, error));
+		});
+	}
+}
+function addEventListener(state, type, handler, options = {}) {
+	if (!isDomType(type)) return;
+	const attributed = options.attribute === true;
+	const duplicate = (state.listeners[type] ?? []).some((entry) => isDomEntry(entry) && originalOf(entry) === handler && !isAttribute(entry));
+	if (!attributed && duplicate) return;
+	const wrapper = wrapperFor(state, type, handler);
+	wrapper.attribute = attributed;
+	wrapper.listener = handler;
+	wrapper[DOM_WRAPPER] = true;
+	const entry = options.once ? onceWrapper(state, type, wrapper) : wrapper;
+	state.listeners = subscribe(state.listeners, type, entry);
+}
+function removeEventListener(state, type, handler) {
+	if (!isDomType(type)) return;
+	state.listeners = unsubscribeMatching(state.listeners, type, (entry) => isDomEntry(entry) && originalOf(entry) === handler && !isAttribute(entry));
+}
+function findAttributeListener(state, type) {
+	for (const entry of state.listeners[type] ?? []) if (isAttribute(entry)) return originalOf(entry);
+	return null;
+}
+function defineDomAttributes(socket, state) {
+	for (const [attribute, type] of ATTRIBUTES) Object.defineProperty(socket, attribute, {
+		enumerable: true,
+		configurable: true,
+		get: () => findAttributeListener(state, type),
+		set: (handler) => {
+			state.listeners = unsubscribeMatching(state.listeners, type, (entry) => isAttribute(entry));
+			if (typeof handler !== "function") return;
+			addEventListener(state, type, handler, { attribute: true });
+		}
+	});
+}
+//#endregion
+//#region src/compat/socket/gating.ts
+function pauseConnection(state) {
+	if (state.readyState === 0 || state.readyState === 3) return;
+	state.isPaused = true;
+	if (state.attachment === null) {
+		state.transport?.pause();
+		return;
+	}
+	pauseSocket(state.attachment.server, state.attachment.connection);
+}
+function resumeConnection(state) {
+	if (state.readyState === 0 || state.readyState === 3) return;
+	state.isPaused = false;
+	if (state.attachment === null) {
+		state.transport?.resume();
+		return;
+	}
+	resumeSocket(state.attachment.server, state.attachment.connection);
+}
+//#endregion
+//#region src/compat/socket/control.ts
+function controlFrame(state, kind, data, mask, callback) {
+	if (state.readyState === 0) throw notOpenError(0);
+	let payload = data;
+	let failure = callback;
+	if (typeof payload === "function") {
+		failure = payload;
+		payload = void 0;
+	} else if (typeof mask === "function") {
+		failure = mask;
+		mask = void 0;
+	}
+	if (typeof payload === "number") payload = String(payload);
+	if (state.readyState !== 1) {
+		defer(failure, notOpenError(state.readyState));
+		return;
+	}
+	const bytes = toPayload(payload).bytes;
+	if (!isValidControlPayload(bytes)) throw createError("ERR_INVALID_OPTION", "The data size must not be greater than 125 bytes", RangeError);
+	const status = writeFrame(state, kind, bytes, true, false, mask !== false);
+	if (status === "ok") {
+		defer(failure);
+		return;
+	}
+	defer(failure, frameError(status));
+}
+//#endregion
+//#region src/compat/socket/send-failure.ts
+const NOT_ATTACHED = "ventiws: the socket has no native transport attached; engine socket adoption is not implemented yet";
+function notAttachedError() {
+	return createError("ERR_INVALID_STATE", NOT_ATTACHED);
+}
+function reportFailure(state, callback, error) {
+	if (typeof callback === "function") {
+		defer(callback, error);
+		return;
+	}
+	reportWithoutClosing(state, error);
+}
+//#endregion
+//#region src/compat/socket/codec-send.ts
+function sendFramed(state, payload, options, callback) {
+	const framing = frameOptions(options, payload.binary, state.isServer);
+	const status = writeFrame(state, state.fragmentsOpen ? "continuation" : framing.binary ? "binary" : "text", payload.bytes, framing.fin, mayCompress(state, framing, payload.bytes.length), framing.mask);
+	if (status === "ok") state.fragmentsOpen = !framing.fin;
+	switch (status) {
+		case "ok":
+			defer(callback);
+			return;
+		case "backpressure":
+		case "closing":
+		case "closed":
+			defer(callback, notOpenError(state.readyState));
+			return;
+		case "invalid-handle":
+		case "payload-too-large":
+		case "protocol-error":
+			reportFailure(state, callback, frameError(status));
+			return;
+	}
+	throw unhandledFrameStatus(status);
+}
+function mayCompress(state, framing, length) {
+	if (!framing.compress || !state.compressible || !framing.fin || state.fragmentsOpen) return false;
+	return length >= state.threshold;
+}
+function frameOptions(options, autodetected, isServer) {
+	const source = typeof options === "object" && options !== null ? options : {};
+	return {
+		binary: booleanOr$1(source.binary, autodetected),
+		fin: booleanOr$1(source.fin, true),
+		compress: booleanOr$1(source.compress, true),
+		mask: booleanOr$1(source.mask, !isServer)
+	};
+}
+function booleanOr$1(value, fallback) {
+	return typeof value === "boolean" ? value : fallback;
+}
+function unhandledFrameStatus(status) {
+	return createError("ERR_INVALID_STATE", `ventiws: the codec reported an unknown frame status "${String(status)}"`);
+}
+//#endregion
+//#region src/compat/socket/send-blob.ts
+function isBlob(value) {
+	return typeof value === "object" && value !== null && typeof value.arrayBuffer === "function" && typeof value.size === "number";
+}
+function sendBlob(state, blob, options, callback) {
+	if (state.readyState !== 1) {
+		defer(callback, notOpenError(state.readyState));
+		return;
+	}
+	const reading = blob.arrayBuffer().then((buffer) => {
+		if (state.readyState !== 1) {
+			defer(callback, notOpenError(state.readyState));
+			return;
+		}
+		framePayload(state, Buffer.from(buffer), {
+			...asOptions(options),
+			binary: true
+		}, callback);
+	}).catch((error) => {
+		defer(callback, error instanceof Error ? error : createError("ERR_INVALID_OPTION", String(error)));
+	}).finally(() => {
+		if (state.pendingSend === reading) state.pendingSend = null;
+	});
+	state.pendingSend = reading;
+}
+function afterPendingSend(state, work) {
+	const pending = state.pendingSend;
+	if (pending === null) {
+		work();
+		return;
+	}
+	state.pendingSend = pending.then(work, work);
+}
+function asOptions(options) {
+	return typeof options === "object" && options !== null ? { ...options } : {};
+}
+//#endregion
+//#region src/compat/socket/send.ts
+function sendData(state, data, options, callback) {
+	if (state.readyState === 0) throw notOpenError(0);
+	afterPendingSend(state, () => framePayload(state, data, options, callback));
+}
+function framePayload(state, data, options, callback) {
+	const failure = resolveCallback(options, callback);
+	if (isBlob(data)) {
+		sendBlob(state, data, options, failure);
+		return;
+	}
+	const payload = toPayload(data);
+	if (state.readyState !== 1) {
+		defer(failure, notOpenError(state.readyState));
+		return;
+	}
+	if (state.codec !== null) {
+		sendFramed(state, payload, options, failure);
+		return;
+	}
+	if (state.attachment === null) {
+		if (typeof failure === "function") defer(failure, notAttachedError());
+		else reportWithoutClosing(state, notAttachedError());
+		return;
+	}
+	const binary = sendBinary(options, payload.binary);
+	applySendStatus(state, sendSocket(state.attachment.server, state.attachment.connection, payload.bytes, binary), payload.bytes.length, failure);
+}
+function resolveCallback(options, callback) {
+	if (typeof options === "function") return options;
+	return callback;
+}
+function sendBinary(options, fallback) {
+	if (typeof options !== "object" || options === null) return fallback;
+	const binary = options.binary;
+	return typeof binary === "boolean" ? binary : fallback;
+}
+function applySendStatus(state, status, length, callback) {
+	switch (status) {
+		case "ok":
+			defer(callback);
+			return;
+		case "backpressure":
+			reportFailure(state, callback, createError("ERR_BACKPRESSURE", "ventiws: the outbound staging ring is full"));
+			return;
+		case "closing":
+		case "closed":
+			defer(callback, notOpenError(state.readyState));
+			return;
+		case "invalid-handle":
+			reportFailure(state, callback, createError("ERR_INVALID_HANDLE", "ventiws: the connection handle is stale"));
+			return;
+		case "payload-too-large":
+		case "invalid-close-code":
+		case "invalid-close-reason":
+		case "protocol-error":
+		case "policy-violation":
+			reportFailure(state, callback, statusError(status));
+			return;
+	}
+	throw unhandledStatus(status);
+}
+function unhandledStatus(status) {
+	return createError("ERR_INVALID_STATE", `ventiws: the engine reported an unknown socket status "${String(status)}"`);
+}
+//#endregion
+//#region src/compat/socket/record.ts
+const BINARY_TYPE_VALUES = [
+	"nodebuffer",
+	"arraybuffer",
+	"fragments",
+	"blob"
+];
+function buildSocketRecord(state) {
+	const socket = {
+		CONNECTING: 0,
+		OPEN: 1,
+		CLOSING: 2,
+		CLOSED: 3,
+		get binaryType() {
+			return state.binaryType;
+		},
+		set binaryType(value) {
+			if (!BINARY_TYPE_VALUES.includes(value)) return;
+			state.binaryType = value;
+		},
+		get bufferedAmount() {
+			return bufferedAmountOf(state);
+		},
+		get extensions() {
+			return state.extensions;
+		},
+		get isPaused() {
+			return state.isPaused;
+		},
+		get protocol() {
+			return state.protocol;
+		},
+		get readyState() {
+			return state.readyState;
+		},
+		get url() {
+			return state.url;
+		},
+		...createEmitter(state),
+		send: (data, sendOptions, callback) => {
+			sendData(state, data, sendOptions, callback);
+		},
+		ping: (data, mask, callback) => {
+			controlFrame(state, "ping", data, mask, callback);
+		},
+		pong: (data, mask, callback) => {
+			controlFrame(state, "pong", data, mask, callback);
+		},
+		close: (code, reason) => {
+			closeConnection(state, code, reason);
+		},
+		terminate: () => {
+			terminateConnection(state);
+		},
+		pause: () => {
+			pauseConnection(state);
+		},
+		resume: () => {
+			resumeConnection(state);
+		},
+		addEventListener: (type, handler, listenerOptions) => {
+			addEventListener(state, type, handler, listenerOptions);
+		},
+		removeEventListener: (type, handler) => {
+			removeEventListener(state, type, handler);
+		}
+	};
+	state.target = socket;
+	defineDomAttributes(socket, state);
+	brandSocket(socket, state);
+	return socket;
+}
+//#endregion
+//#region src/compat/options/client.ts
+function normalizeClientOptions(options) {
+	const source = { ...options };
+	const protocolVersion = source.protocolVersion ?? 13;
+	if (protocolVersion !== 8 && protocolVersion !== 13) invalidOption(`Unsupported protocol version: ${protocolVersion} (supported versions: 8, 13)`, RangeError);
+	return {
+		protocolVersion,
+		followRedirects: source.followRedirects ?? false,
+		maxRedirects: source.maxRedirects ?? 10,
+		handshakeTimeout: source.handshakeTimeout,
+		maxPayload: maxPayloadOf(source, () => codecLimits().maxPayloadBytes),
+		maxFragments: maxFragmentsOf(source, () => codecLimits().maxFragments),
+		maxBufferedChunks: maxBufferedChunksOf(source),
+		skipUTF8Validation: source.skipUTF8Validation ?? false,
+		allowSynchronousEvents: source.allowSynchronousEvents ?? true,
+		autoPong: source.autoPong ?? true,
+		closeTimeout: closeTimeoutOf(source),
+		perMessageDeflate: normalizePerMessageDeflate(source.perMessageDeflate, true),
+		origin: source.origin,
+		headers: source.headers === void 0 ? void 0 : { ...source.headers },
+		requestOptions: { ...source },
+		finishRequest: source.finishRequest,
+		generateMask: source.generateMask
+	};
+}
+//#endregion
+//#region src/compat/client/address.ts
+const DEFAULT_PORTS = {
+	"ws:": 80,
+	"wss:": 443
+};
+const WS_SCHEMES = {
+	"http:": "ws:",
+	"https:": "wss:",
+	"ws:": "ws:",
+	"wss:": "wss:",
+	"ws+unix:": "ws:"
+};
+const IPC_SCHEME = "ws+unix:";
+function parseAddress(address) {
+	const parsed = toUrl(address);
+	const scheme = parsed.protocol;
+	if (scheme === IPC_SCHEME) return buildIpc(parsed);
+	const resolved = WS_SCHEMES[scheme];
+	if (resolved === void 0) throw createError("ERR_INVALID_OPTION", "The URL's protocol must be one of \"ws:\", \"wss:\", \"http:\", \"https:\", or \"ws+unix:\"", SyntaxError);
+	if (parsed.hash) throw createError("ERR_INVALID_OPTION", "The URL contains a fragment identifier", SyntaxError);
+	return build(parsed, resolved);
+}
+function toUrl(address) {
+	if (address instanceof URL) return address;
+	try {
+		return new URL(address);
+	} catch {
+		throw createError("ERR_INVALID_OPTION", `Invalid URL: ${address}`, SyntaxError);
+	}
+}
+function build(parsed, scheme) {
+	parsed.protocol = scheme;
+	const hasCredentials = parsed.username !== "" || parsed.password !== "";
+	const host = parsed.hostname.startsWith("[") ? parsed.hostname.slice(1, -1) : parsed.hostname;
+	const port = parsed.port === "" ? DEFAULT_PORTS[scheme] : Number(parsed.port);
+	return {
+		url: parsed.href,
+		secure: scheme === "wss:",
+		host,
+		authority: parsed.host,
+		port,
+		path: `${parsed.pathname}${parsed.search}`,
+		auth: hasCredentials ? `${parsed.username}:${parsed.password}` : void 0,
+		socketPath: void 0
+	};
+}
+function buildIpc(parsed) {
+	if (parsed.pathname === "") throw createError("ERR_INVALID_OPTION", "The URL's pathname is empty", SyntaxError);
+	if (parsed.hash) throw createError("ERR_INVALID_OPTION", "The URL contains a fragment identifier", SyntaxError);
+	const parts = parsed.pathname.split(":");
+	const socketPath = parts[0] ?? "";
+	const target = parts.length > 1 ? parts.slice(1).join(":") : "";
+	return {
+		url: parsed.href,
+		secure: false,
+		host: "",
+		authority: socketPath,
+		port: DEFAULT_PORTS["ws:"],
+		path: target === "" ? "/" : `/${target.replace(/^\/+/, "")}${parsed.search}`,
+		auth: void 0,
+		socketPath
+	};
+}
+//#endregion
+//#region src/compat/extensions/offer.ts
+function offer(options) {
+	if (options === false) return void 0;
+	return formatExtension(PERMESSAGE_DEFLATE, NO_CONTEXT_TAKEOVER);
+}
+//#endregion
+//#region src/compat/client/handshake-headers.ts
+function buildHeaders(options, protocols, key, credentials) {
+	const headers = {
+		"Sec-WebSocket-Version": String(options.protocolVersion),
+		"Sec-WebSocket-Key": key,
+		Connection: "Upgrade",
+		Upgrade: "websocket"
+	};
+	if (protocols.length > 0) headers["Sec-WebSocket-Protocol"] = protocols.join(",");
+	const extension = offer(options.perMessageDeflate);
+	if (extension !== void 0) headers["Sec-WebSocket-Extensions"] = extension;
+	if (options.origin) {
+		if (options.protocolVersion < 13) headers["Sec-WebSocket-Origin"] = options.origin;
+		else headers.Origin = options.origin;
+	}
+	const merged = {
+		...lowerCased(options.headers),
+		...headers
+	};
+	if (credentials !== void 0 && merged.authorization === void 0) merged.authorization = `Basic ${Buffer.from(credentials, "utf8").toString("base64")}`;
+	return {
+		key,
+		headers: merged
+	};
+}
+function lowerCased(headers) {
+	const out = {};
+	for (const [name, value] of Object.entries(headers ?? {})) out[name.toLowerCase()] = value;
+	return out;
+}
+//#endregion
+//#region src/compat/client/transport-options.ts
+const FORWARDED = [
+	"ca",
+	"cert",
+	"key",
+	"pfx",
+	"passphrase",
+	"secureContext",
+	"rejectUnauthorized",
+	"checkServerIdentity",
+	"servername",
+	"agent",
+	"createConnection",
+	"localAddress",
+	"family",
+	"lookup",
+	"insecureHTTPParser",
+	"maxHeaderSize",
+	"joinDuplicateHeaders",
+	"signal"
+];
+function transportOptions(address, options) {
+	const carried = {};
+	for (const key of FORWARDED) {
+		const value = options.requestOptions[key];
+		if (value !== void 0) carried[key] = value;
+	}
+	if (address.socketPath !== void 0) return {
+		...carried,
+		socketPath: address.socketPath
+	};
+	if (!address.secure) return carried;
+	return {
+		...carried,
+		servername: stringOr(carried.servername, address.host),
+		rejectUnauthorized: booleanOr(carried.rejectUnauthorized, true)
+	};
+}
+function stringOr(value, fallback) {
+	return typeof value === "string" ? value : fallback;
+}
+function booleanOr(value, fallback) {
+	return typeof value === "boolean" ? value : fallback;
+}
+//#endregion
+//#region src/compat/client/request.ts
+const GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
+function expectedAccept(key) {
+	return createHash("sha1").update(key + GUID).digest("base64");
+}
+function newKey() {
+	return randomBytes(16).toString("base64");
+}
+function buildRequest(address, options, protocols, key, carriedAuth) {
+	const built = buildHeaders(options, protocols, key, address.auth ?? carriedAuth);
+	return {
+		key: built.key,
+		headers: built.headers,
+		request: {
+			hostname: address.host,
+			port: address.port,
+			path: address.path,
+			method: "GET",
+			headers: {
+				host: hostHeader(address),
+				...built.headers
+			},
+			setHost: false,
+			...transportOptions(address, options)
+		}
+	};
+}
+function hostHeader(address) {
+	if (address.socketPath !== void 0) return address.socketPath;
+	return `${address.host.includes(":") ? `[${address.host}]` : address.host}:${address.port}`;
+}
+//#endregion
+//#region src/compat/client/extension.ts
+function acceptExtension(response, options) {
+	const claimed = response.headers["sec-websocket-extensions"];
+	if (claimed === void 0) return { accepted: null };
+	const value = Array.isArray(claimed) ? claimed.join(", ") : claimed;
+	if (options === false) return { refusal: "Server sent an extension but none was requested" };
+	let offered;
+	try {
+		offered = parseExtensions(value).get("permessage-deflate") ?? [];
+	} catch {
+		return { refusal: "Invalid Sec-WebSocket-Extensions header" };
+	}
+	if (offered.length === 0) return { refusal: "Server sent an extension but none was requested" };
+	return acceptAsClient(offered[0], options) ?? { accepted: null };
+}
+//#endregion
+//#region src/compat/client/open.ts
+function onUpgrade(attempt, response, socket, head) {
+	const { state } = attempt;
+	socket.on("error", () => void 0);
+	emitEvent(state, "upgrade", response);
+	if (state.readyState === 3) {
+		discard(socket);
+		return;
+	}
+	const refused = reject(response, attempt);
+	if (refused !== null) {
+		abort(attempt, createError("ERR_PROTOCOL", refused));
+		return;
+	}
+	const extension = acceptExtension(response, attempt.options.perMessageDeflate);
+	if ("refusal" in extension) {
+		abort(attempt, createError("ERR_PROTOCOL", extension.refusal));
+		return;
+	}
+	state.protocol = response.headers["sec-websocket-protocol"] ?? "";
+	state.extensions = response.headers["sec-websocket-extensions"] ?? "";
+	state.compressible = extension.accepted !== null;
+	socket.setTimeout(0);
+	const target = state.target ?? null;
+	if (target === null) {
+		abort(attempt, createError("ERR_INVALID_STATE", "ventiws: the socket record is missing"));
+		return;
+	}
+	attempt.transport = socket;
+	state.cancelHandshake = null;
+	attachSocket(target, socket, CODEC_ROLE.client, head);
+}
+function reject(response, attempt) {
+	const upgrade = response.headers.upgrade;
+	if (upgrade === void 0 || upgrade.toLowerCase() !== "websocket") return "Invalid Upgrade header";
+	if (response.headers["sec-websocket-accept"] !== expectedAccept(attempt.handshake.key)) return "Invalid Sec-WebSocket-Accept header";
+	return protocolRejection(response.headers["sec-websocket-protocol"], attempt.offered);
+}
+//#endregion
+//#region src/compat/client/unexpected.ts
+function reportUnexpected(attempt, request, response) {
+	if (emitEvent(attempt.state, "unexpected-response", request, response)) return;
+	request.abort();
+	abort(attempt, createError("ERR_PROTOCOL", `Unexpected server response: ${response.statusCode ?? 0}`));
+}
+//#endregion
+//#region src/compat/client/credentials.ts
+function stripCredentials(headers) {
+	if (typeof headers !== "object" || headers === null) return;
+	const map = headers;
+	for (const name of Object.keys(map)) {
+		const lower = name.toLowerCase();
+		if (lower === "authorization" || lower === "cookie") delete map[name];
+	}
+}
+//#endregion
+//#region src/compat/client/redirect.ts
+function isRedirect(status, location) {
+	return location !== void 0 && status >= 300 && status < 400;
+}
+function onResponse(attempt, request, response) {
+	const location = response.headers.location;
+	if (isRedirect(response.statusCode ?? 0, location) && attempt.options.followRedirects) {
+		follow(attempt, request, response, location ?? "");
+		return;
+	}
+	reportUnexpected(attempt, request, response);
+}
+function follow(attempt, request, response, location) {
+	if (attempt.redirects + 1 > attempt.options.maxRedirects) {
+		request.abort();
+		abort(attempt, createError("ERR_PROTOCOL", "Maximum redirects exceeded"));
+		return;
+	}
+	const target = resolve(location, attempt.state.url);
+	let next;
+	try {
+		next = parseAddress(target);
+	} catch (error) {
+		request.abort();
+		abort(attempt, createError("ERR_PROTOCOL", error instanceof Error ? error.message : `Invalid URL: ${target}`));
+		return;
+	}
+	if (attempt.address.secure && !next.secure) {
+		request.abort();
+		abort(attempt, createError("ERR_PROTOCOL", "Cannot follow a redirect from wss: to ws:"));
+		return;
+	}
+	if (next.authority !== attempt.address.authority && listenerCount(attempt) === 0) {
+		stripCredentials(attempt.handshake.request.headers);
+		attempt.auth = void 0;
+	}
+	request.abort();
+	attempt.state.url = next.url;
+	attempt.address = next;
+	attempt.redirects += 1;
+	attempt.handshake = buildRequest(next, attempt.options, attempt.requested, newKey(), attempt.auth);
+	const hop = create(attempt);
+	if (hop === null) return;
+	emitEvent(attempt.state, "redirect", next.url, hop);
+	finish(attempt, hop);
+}
+function resolve(location, base) {
+	try {
+		return new URL(location, base).href;
+	} catch {
+		return location;
+	}
+}
+function listenerCount(attempt) {
+	return listenerCount$1(attempt.state.listeners, "redirect");
+}
+//#endregion
+//#region src/compat/client/dial.ts
+function dial(attempt) {
+	const request = create(attempt);
+	if (request === null) return null;
+	finish(attempt, request);
+	return request;
+}
+function finish(attempt, request) {
+	const callback = attempt.options.finishRequest;
+	if (callback === void 0) {
+		request.end();
+		return;
+	}
+	const target = attempt.state.target;
+	if (target === void 0) {
+		request.end();
+		return;
+	}
+	callback(request, target);
+}
+function create(attempt) {
+	const { options, handshake } = attempt;
+	if (attempt.state.readyState === 3) return null;
+	const request = issue(attempt, handshake.request);
+	attempt.request = request;
+	attempt.state.cancelHandshake = () => {
+		request.abort();
+	};
+	request.on("error", (error) => {
+		if (attempt.request !== request) return;
+		attempt.request = null;
+		failConnection(attempt.state, error);
+	});
+	if (options.handshakeTimeout) request.setTimeout(options.handshakeTimeout, () => {
+		refuse(attempt, request, "Opening handshake has timed out");
+	});
+	request.on("upgrade", (response, socket, head) => {
+		if (attempt.request !== request) return;
+		attempt.request = null;
+		onUpgrade(attempt, response, socket, head);
+	});
+	request.on("response", (response) => {
+		if (attempt.request !== request) return;
+		attempt.request = null;
+		onResponse(attempt, request, response);
+	});
+	return request;
+}
+function issue(attempt, options) {
+	return attempt.address.secure ? request$1(options) : request(options);
+}
+function refuse(attempt, request, message) {
+	request?.abort();
+	abort(attempt, createError("ERR_PROTOCOL", message));
+}
+function abort(attempt, error) {
+	const { state } = attempt;
+	if (state.readyState === 3) return;
+	state.cancelHandshake = null;
+	attempt.request?.destroy();
+	attempt.request = null;
+	if (attempt.transport !== null) discard(attempt.transport);
+	failConnection(state, error);
+}
+function discard(socket) {
+	socket.on("error", () => void 0);
+	socket.destroy();
+}
+//#endregion
+//#region src/compat/client/connect.ts
+function connectSocket(address, protocols, options) {
+	const normalized = normalizeClientOptions(options);
+	const parsed = parseAddress(address);
+	const requested = normalizeProtocols(protocols);
+	const state = createSocketState();
+	state.isServer = false;
+	state.url = parsed.url;
+	state.closeTimeout = normalized.closeTimeout;
+	state.autoPong = normalized.autoPong;
+	state.generateMask = normalized.generateMask ?? null;
+	state.allowSynchronousEvents = normalized.allowSynchronousEvents;
+	state.validateUtf8 = !normalized.skipUTF8Validation;
+	state.maxPayload = normalized.maxPayload;
+	state.maxFragments = normalized.maxFragments;
+	state.maxBufferedChunks = normalized.maxBufferedChunks;
+	state.threshold = thresholdOf(normalized.perMessageDeflate);
+	const socket = buildSocketRecord(state);
+	dial({
+		state,
+		options: normalized,
+		requested,
+		offered: protocolSet(requested),
+		request: null,
+		transport: null,
+		handshake: buildRequest(parsed, normalized, requested, newKey()),
+		address: parsed,
+		auth: parsed.auth,
+		redirects: 0
+	});
+	return socket;
+}
+//#endregion
+//#region src/compat/socket/socket.ts
+function createSocket(address, protocols, options) {
+	if (address === null) return buildSocketRecord(createSocketState());
+	const promoted = promoteOptions(protocols, options);
+	return connectSocket(address, promoted.protocols, promoted.options);
+}
+//#endregion
+//#region src/compat/stream.ts
+function createWebSocketStream(ws, options) {
+	let terminateOnDestroy = true;
+	const duplex = new Duplex({
+		...options,
+		autoDestroy: false,
+		emitClose: false,
+		objectMode: false,
+		writableObjectMode: false
+	});
+	const onEnd = () => {
+		if (!duplex.destroyed && duplex.writableFinished) duplex.destroy();
+	};
+	const onError = (error) => {
+		duplex.removeListener("error", onError);
+		duplex.destroy();
+		if (duplex.listenerCount("error") === 0) duplex.emit("error", error);
+	};
+	ws.on("message", (message, isBinary) => {
+		const data = !isBinary && duplex.readableObjectMode ? message.toString() : message;
+		if (!duplex.push(data)) ws.pause();
+	});
+	ws.once("error", (error) => {
+		if (duplex.destroyed) return;
+		terminateOnDestroy = false;
+		duplex.destroy(error);
+	});
+	ws.once("close", () => {
+		if (!duplex.destroyed) duplex.push(null);
+	});
+	duplex._destroy = (error, callback) => {
+		if (ws.readyState === ws.CLOSED) {
+			callback(error);
+			process.nextTick(() => {
+				duplex.emit("close");
+			});
+			return;
+		}
+		let called = false;
+		ws.once("error", (failure) => {
+			called = true;
+			callback(failure);
+		});
+		ws.once("close", () => {
+			if (!called) callback(error);
+			process.nextTick(() => {
+				duplex.emit("close");
+			});
+		});
+		if (terminateOnDestroy) ws.terminate();
+	};
+	duplex._final = (callback) => {
+		if (ws.readyState === ws.CONNECTING) {
+			ws.once("open", () => {
+				duplex._final?.(callback);
+			});
+			return;
+		}
+		if (ws.readyState === ws.CLOSED) {
+			callback();
+			return;
+		}
+		ws.close();
+		if (!closeFrameWritten(ws)) {
+			ws.once("close", () => {
+				callback();
+			});
+			return;
+		}
+		callback();
+		if (duplex.readableEnded) duplex.destroy();
+	};
+	duplex._read = () => {
+		if (ws.isPaused) ws.resume();
+	};
+	duplex._write = (chunk, encoding, callback) => {
+		if (ws.readyState === ws.CONNECTING) {
+			ws.once("open", () => {
+				duplex._write?.(chunk, encoding, callback);
+			});
+			return;
+		}
+		ws.send(chunk, callback);
+	};
+	duplex.on("end", onEnd);
+	duplex.on("error", onError);
+	return duplex;
+}
+//#endregion
+//#region src/compat/constructors.ts
+function buildSocket(address, protocols, options) {
+	if (new.target === void 0) throw new TypeError("Class constructor WebSocket cannot be invoked without 'new'");
+	return createSocket(address, protocols, options);
+}
+function buildServer(options, callback) {
+	if (new.target === void 0) throw new TypeError("Class constructor WebSocketServer cannot be invoked without 'new'");
+	return createWebSocketServer(WebSocket, options, callback);
+}
+const WebSocket = buildSocket;
+const WebSocketServer = buildServer;
+Object.defineProperty(WebSocket, Symbol.hasInstance, { value: isSocket });
+Object.defineProperty(WebSocketServer, Symbol.hasInstance, { value: isServer });
+Object.defineProperties(WebSocket, {
+	CONNECTING: {
+		value: 0,
+		enumerable: true
+	},
+	OPEN: {
+		value: 1,
+		enumerable: true
+	},
+	CLOSING: {
+		value: 2,
+		enumerable: true
+	},
+	CLOSED: {
+		value: 3,
+		enumerable: true
+	}
+});
+Object.assign(WebSocket, {
+	WebSocket,
+	WebSocketServer,
+	Server: WebSocketServer,
+	createWebSocketStream
+});
+//#endregion
+export { WebSocket, WebSocket as default, WebSocketServer, createWebSocketStream, engineLimits };
+