@vscode/component-explorer-cli 0.2.1-17 → 0.2.1-171

package/dist/external/linkrpc/typescript/packages/linkrpc/dist/node.js

@@ -0,0 +1,721 @@
+import { H as parseEndpointUri, B as formatEndpointUri, at as JsonRpcChannel, q as traceMessageTransport } from './chunks/src-DYVSK_tz.js';
+export { ot as Channel, Ot as HUBRPC_META_KEY, kt as HUBRPC_SIGNATURE_KEY, At as HUBRPC_UNSIGNED_KEY, et as LinkRpcConnection, Xt as NonCompliantServerError, st as RpcError, tt as ServiceHandle, G as TransportPair, nt as defaultInterfaceTarget, xt as defaultsInterface, St as directoryInterface, it as isInterfaceTarget, Vt as parseMethodName, wt as schemasInterface, Dt as stripLinkRpcWireMeta, Tt as zServiceIdPattern } from './chunks/src-DYVSK_tz.js';
+import { t as WebSocketTransport, s as runInitializeHandshake, r as openWebSocket$1 } from './chunks/webSocketTransport-Ct4OIdG9.js';
+export { i as INITIALIZE_METHOD } from './chunks/webSocketTransport-Ct4OIdG9.js';
+import { timingSafeEqual } from 'node:crypto';
+import * as http from 'node:http';
+import * as net from 'node:net';
+import 'node:fs/promises';
+import 'node:os';
+import 'node:path';
+import 'node:child_process';
+
+/*---------------------------------------------------------------------------------------------
+*  Copyright (c) Microsoft Corporation. All rights reserved.
+*  Licensed under the MIT License. See License.txt in the project root for license information.
+*--------------------------------------------------------------------------------------------*/
+//#region src/node/ndjsonTransport.ts
+/**
+* Newline-delimited JSON transport over a Node Readable/Writable pair.
+* One JSON value per line, both directions.
+*
+* Not LSP-style headers — those add no value for a private link between two
+* cooperating processes and require a length-prefixed framer.
+*/
+var NdjsonTransport = class {
+	_input;
+	_output;
+	_onClose;
+	_listener;
+	_buffer = [];
+	_residual = "";
+	_closed = false;
+	_onDataEvent = (chunk) => this._onData(chunk);
+	_onEndEvent = () => this.dispose();
+	constructor(_input, _output, _onClose) {
+		this._input = _input;
+		this._output = _output;
+		this._onClose = _onClose;
+		this._input.setEncoding?.("utf8");
+		this._input.on("data", this._onDataEvent);
+		this._input.on("end", this._onEndEvent);
+		this._input.on("close", this._onEndEvent);
+		this._input.on("error", this._onEndEvent);
+		if (!Object.is(this._output, this._input)) this._output.on("error", this._onEndEvent);
+	}
+	send(message) {
+		if (this._closed) return;
+		this._output.write(JSON.stringify(message) + "\n");
+	}
+	setListener(listener) {
+		this._listener = listener;
+		if (listener) while (this._buffer.length > 0 && this._listener) {
+			const m = this._buffer.shift();
+			this._listener(m);
+		}
+	}
+	dispose() {
+		if (this._closed) return;
+		this._closed = true;
+		this._input.removeListener("data", this._onDataEvent);
+		this._input.removeListener("end", this._onEndEvent);
+		this._input.removeListener("close", this._onEndEvent);
+		this._input.removeListener("error", this._onEndEvent);
+		this._output.removeListener("error", this._onEndEvent);
+		this._listener = void 0;
+		this._buffer.length = 0;
+		this._residual = "";
+		this._onClose?.();
+	}
+	_onData(chunk) {
+		this._residual += chunk;
+		let nl;
+		while ((nl = this._residual.indexOf("\n")) >= 0) {
+			const line = this._residual.slice(0, nl).trim();
+			this._residual = this._residual.slice(nl + 1);
+			if (!line) continue;
+			let parsed;
+			try {
+				parsed = JSON.parse(line);
+			} catch {
+				continue;
+			}
+			this._deliver(parsed);
+		}
+	}
+	_deliver(m) {
+		if (this._listener) this._listener(m);
+		else this._buffer.push(m);
+	}
+};
+//#endregion
+//#region src/node/initialize.ts
+/** Construct NDJSON and complete the shared transport initialization handshake. */
+async function connectNdjson(opts) {
+	const role = opts.initialize;
+	const closed = new AbortController();
+	const baseTransport = new NdjsonTransport(opts.input, opts.output, () => {
+		try {
+			opts.onClose?.();
+		} finally {
+			closed.abort(/* @__PURE__ */ new Error("hubrpc::initialize: transport closed during handshake"));
+		}
+	});
+	const transport = opts.trace === void 0 ? baseTransport : traceMessageTransport(baseTransport, opts.trace);
+	if (!role) return { transport };
+	try {
+		const { token } = await runInitializeHandshake(transport, role, {
+			handshakeTimeoutMs: opts.handshakeTimeoutMs,
+			signal: opts.signal ? AbortSignal.any([closed.signal, opts.signal]) : closed.signal
+		});
+		return {
+			transport,
+			...token !== void 0 ? { token } : {}
+		};
+	} catch (err) {
+		transport.dispose();
+		throw err;
+	}
+}
+//#endregion
+//#region src/node/webSocketClientTransport.ts
+/** Node-only header extension. The web entry exposes the standard overload. */
+function openWebSocket(url, opts = {}) {
+	if (!opts.headers || Object.keys(opts.headers).length === 0) return openWebSocket$1(url);
+	return new Promise((resolve, reject) => {
+		const ws = new WebSocket(url, { headers: opts.headers });
+		const onOpen = () => {
+			ws.removeEventListener("error", onError);
+			resolve(ws);
+		};
+		const onError = () => {
+			ws.removeEventListener("open", onOpen);
+			reject(/* @__PURE__ */ new Error("WebSocket connection failed"));
+		};
+		ws.addEventListener("open", onOpen, { once: true });
+		ws.addEventListener("error", onError, { once: true });
+	});
+}
+//#endregion
+//#region src/node/hubClient.ts
+/** Env var the hub publishes for its endpoint (named pipe / UDS path). */
+const LINKRPC_ENDPOINT_VAR = "LINKRPC_ENDPOINT";
+/**
+* Open the hub socket and send the preamble, returning the raw
+* {@link HubChannel} without any signing. Use this when you want to
+* compose identity yourself; otherwise prefer {@link connectToHub}.
+*/
+async function openHubChannel(options = {}) {
+	const endpoint = options.endpoint ?? process.env["LINKRPC_ENDPOINT"];
+	const token = options.token ?? process.env["LINKRPC_TOKEN"] ?? "";
+	if (!endpoint) throw new Error(`${LINKRPC_ENDPOINT_VAR} is not set; cannot connect to linkrpc hub.`);
+	const closeListeners = /* @__PURE__ */ new Set();
+	let closed = false;
+	let closeChannel;
+	const fireClose = () => {
+		if (closed) return;
+		closed = true;
+		closeChannel?.();
+		for (const l of closeListeners) try {
+			l();
+		} catch {}
+		closeListeners.clear();
+	};
+	const { transport, destroy } = await _openHubTransport(endpoint, token, fireClose);
+	const rpc = JsonRpcChannel.createWithClose(transport, { deferRequests: options.deferRequests });
+	closeChannel = rpc.close;
+	if (closed) rpc.close();
+	return Object.assign(rpc.channel, {
+		endpoint,
+		token,
+		resumeRequests: rpc.resumeRequests,
+		onClose: (listener) => {
+			if (closed) {
+				queueMicrotask(listener);
+				return { dispose: () => {} };
+			}
+			closeListeners.add(listener);
+			return { dispose: () => closeListeners.delete(listener) };
+		},
+		close: () => {
+			destroy();
+			fireClose();
+		}
+	});
+}
+/** True for `ws://` / `wss://` endpoints (case-insensitive). */
+function _isWebSocketEndpoint(endpoint) {
+	return /^wss?:\/\//i.test(endpoint);
+}
+/**
+* Open the underlying transport for {@link openHubChannel}, picking the
+* scheme from the endpoint:
+*  - `ws://` / `wss://` → WebSocket; the token is presented via the
+*    `hubrpc::initialize` handshake (browsers cannot set request headers).
+*  - anything else → named pipe / UDS; the token is presented via the
+*    `hubrpc::initialize` handshake the socket server requires.
+*
+* `onClose` fires once when the peer ends the transport.
+*/
+async function _openHubTransport(endpoint, token, onClose) {
+	if (_isWebSocketEndpoint(endpoint)) {
+		const ws = await openWebSocket(endpoint);
+		const closed = new AbortController();
+		const transport = new WebSocketTransport(ws, () => {
+			closed.abort(/* @__PURE__ */ new Error("hubrpc::initialize: transport closed during handshake"));
+			onClose();
+		});
+		const destroy = () => {
+			try {
+				ws.close();
+			} catch {}
+		};
+		try {
+			await runInitializeHandshake(transport, {
+				kind: "client",
+				token
+			}, { signal: closed.signal });
+		} catch (err) {
+			transport.dispose();
+			destroy();
+			throw err;
+		}
+		return {
+			transport,
+			destroy
+		};
+	}
+	const socket = await _openSocket(endpoint);
+	const { transport } = await connectNdjson({
+		input: socket,
+		output: socket,
+		onClose: () => {
+			socket.destroy();
+			onClose();
+		},
+		initialize: {
+			kind: "client",
+			token
+		}
+	});
+	return {
+		transport,
+		destroy: () => socket.destroy()
+	};
+}
+function _openSocket(endpoint) {
+	return new Promise((resolve, reject) => {
+		const socket = net.createConnection(endpoint);
+		const onError = (err) => {
+			socket.removeListener("connect", onConnect);
+			reject(err);
+		};
+		const onConnect = () => {
+			socket.removeListener("error", onError);
+			resolve(socket);
+		};
+		socket.once("error", onError);
+		socket.once("connect", onConnect);
+	});
+}
+async function openStdioChannel(options = {}) {
+	const closeListeners = /* @__PURE__ */ new Set();
+	let closed = false;
+	let closeChannel;
+	const fireClose = () => {
+		if (closed) return;
+		closed = true;
+		closeChannel?.();
+		if (process.stdin.listenerCount("data") === 0) process.stdin.pause();
+		for (const l of closeListeners) try {
+			l();
+		} catch {}
+		closeListeners.clear();
+	};
+	const { transport } = await connectNdjson({
+		input: process.stdin,
+		output: process.stdout,
+		onClose: fireClose
+	});
+	const rpc = JsonRpcChannel.createWithClose(transport, options);
+	closeChannel = rpc.close;
+	if (closed) rpc.close();
+	return Object.assign(rpc.channel, {
+		resumeRequests: rpc.resumeRequests,
+		close: fireClose,
+		onClose: (listener) => {
+			if (closed) {
+				queueMicrotask(listener);
+				return { dispose: () => {} };
+			}
+			closeListeners.add(listener);
+			return { dispose: () => closeListeners.delete(listener) };
+		}
+	});
+}
+//#endregion
+//#region src/node/endpoint.ts
+/**
+* Start a Node application's RPC endpoint without imposing argument parsing,
+* signing, service registration, signal handlers, or process-exit policy.
+* Startup and initial onConnection failures reject. A listener isolates failed
+* peers, reports them via onError, and continues accepting other connections.
+*/
+async function startEndpoint(options) {
+	const configured = (options.endpoint ?? process.env["LINKRPC_ENDPOINT"])?.trim();
+	if (!configured) throw new Error(`${LINKRPC_ENDPOINT_VAR} is not set; specify an endpoint.`);
+	if (configured === "stdio" || configured === "stdio:") return _startSingle("stdio:", await openStdioChannel({ deferRequests: true }), options);
+	const listening = configured.startsWith("listen:");
+	const target = parseEndpointUri(listening ? configured.slice(7) : configured);
+	if (target.kind !== "socket" && target.kind !== "ws") throw new Error("startEndpoint supports stdio, socket, and LinkRPC WebSocket endpoints only.");
+	const token = options.token ?? target.token ?? process.env["LINKRPC_TOKEN"] ?? "";
+	const endpoint = formatEndpointUri({
+		...target,
+		token: void 0
+	});
+	if (!listening) return _startSingle(endpoint, await openHubChannel({
+		endpoint: target.kind === "socket" ? target.path : target.url,
+		token,
+		deferRequests: true
+	}), options);
+	if (!token) throw new Error("Listening endpoints require a nonempty token.");
+	return EndpointListener.start(target, token, options);
+}
+async function _startSingle(endpoint, source, options) {
+	let finish;
+	const closed = new Promise((resolve) => {
+		finish = resolve;
+	});
+	const subscription = source.onClose(finish);
+	closed.then(() => subscription.dispose());
+	const connection = {
+		channel: source,
+		closed,
+		dispose: () => source.close()
+	};
+	try {
+		await options.onConnection(connection);
+		source.resumeRequests();
+		return {
+			endpoint,
+			closed,
+			dispose: connection.dispose
+		};
+	} catch (error) {
+		connection.dispose();
+		await closed;
+		throw error;
+	}
+}
+var EndpointListener = class EndpointListener {
+	endpoint;
+	_server;
+	_token;
+	_options;
+	_webSocketServer;
+	_peers = /* @__PURE__ */ new Set();
+	_tasks = /* @__PURE__ */ new Set();
+	_sockets = /* @__PURE__ */ new Set();
+	_disposed = false;
+	_finish;
+	closed = new Promise((resolve) => {
+		this._finish = resolve;
+	});
+	constructor(endpoint, _server, _token, _options, _webSocketServer) {
+		this.endpoint = endpoint;
+		this._server = _server;
+		this._token = _token;
+		this._options = _options;
+		this._webSocketServer = _webSocketServer;
+		_server.on("connection", (socket) => {
+			this._sockets.add(socket);
+			socket.on("close", () => this._sockets.delete(socket));
+			if (this._disposed) socket.destroy();
+		});
+		_server.on("error", (error) => {
+			this._report(error);
+			this.dispose();
+		});
+	}
+	static async start(target, token, options) {
+		if (target.kind === "socket") {
+			const server = net.createServer();
+			await _listen(server, () => server.listen(target.path));
+			const owner = new EndpointListener(formatEndpointUri({
+				...target,
+				token: void 0
+			}), server, token, options);
+			server.on("connection", (socket) => {
+				const peer = owner._createPeer(() => socket.destroy());
+				socket.on("error", (error) => owner._peerError(peer, error));
+				socket.on("close", () => peer.dispose());
+				owner._accept(peer, () => connectNdjson({
+					input: socket,
+					output: socket,
+					onClose: () => peer.dispose(),
+					signal: peer.signal,
+					initialize: {
+						kind: "server",
+						isTokenAccepted: async (candidate) => owner._accepts(candidate)
+					}
+				}).then((result) => result.transport));
+			});
+			return owner;
+		}
+		const url = new URL(target.url);
+		if (url.protocol !== "ws:") throw new Error("Listening WebSockets require ws:; terminate TLS at a reverse proxy.");
+		if (url.username || url.password || url.search || url.hash) throw new Error("Listening WebSocket URLs cannot contain credentials, query parameters, or fragments.");
+		const { WebSocketServer } = await import('ws');
+		const server = http.createServer((_request, response) => {
+			response.writeHead(426);
+			response.end("WebSocket upgrade required");
+		});
+		await _listen(server, () => server.listen(Number(url.port || 80), url.hostname.replace(/^\[|\]$/g, "")));
+		const webSockets = new WebSocketServer({
+			server,
+			path: url.pathname,
+			maxPayload: 16777216
+		});
+		const address = server.address();
+		if (!address || typeof address === "string") {
+			server.close();
+			throw new Error("WebSocket listener did not bind a TCP address.");
+		}
+		url.port = String(address.port);
+		const owner = new EndpointListener(url.toString(), server, token, options, webSockets);
+		webSockets.on("error", (error) => {
+			owner._report(error);
+			owner.dispose();
+		});
+		webSockets.on("connection", (socket) => {
+			const peer = owner._createPeer(() => socket.terminate());
+			socket.on("error", (error) => owner._peerError(peer, error));
+			socket.on("close", () => peer.dispose());
+			const transport = new WebSocketTransport(socket, () => peer.dispose());
+			peer.setTransport(transport);
+			owner._accept(peer, async () => {
+				await runInitializeHandshake(transport, {
+					kind: "server",
+					isTokenAccepted: async (candidate) => owner._accepts(candidate)
+				}, { signal: peer.signal });
+				return transport;
+			});
+		});
+		return owner;
+	}
+	dispose() {
+		if (this._disposed) return;
+		this._disposed = true;
+		for (const peer of this._peers) peer.dispose();
+		for (const socket of this._sockets) socket.destroy();
+		const webSocketsClosed = this._webSocketServer ? new Promise((resolve) => this._webSocketServer.close(() => resolve())) : Promise.resolve();
+		this._server.close(() => {
+			Promise.all([...this._tasks, webSocketsClosed]).then(() => this._finish());
+		});
+	}
+	_accepts(candidate) {
+		if (typeof candidate !== "string") return false;
+		const expected = Buffer.from(this._token);
+		const actual = Buffer.from(candidate);
+		return actual.length === expected.length && timingSafeEqual(actual, expected);
+	}
+	_createPeer(closeSocket) {
+		const peer = new ListenerPeer(closeSocket);
+		this._peers.add(peer);
+		peer.closed.then(() => this._peers.delete(peer));
+		if (this._disposed) peer.dispose();
+		return peer;
+	}
+	_accept(peer, open) {
+		const task = (async () => {
+			try {
+				const transport = await open();
+				peer.setTransport(transport);
+				if (this._disposed || peer.signal.aborted) return;
+				const connection = peer.connect();
+				await this._options.onConnection(connection);
+				peer.resumeRequests();
+			} catch (error) {
+				const report = !this._disposed;
+				peer.dispose();
+				if (report) this._report(error);
+			}
+		})();
+		this._tasks.add(task);
+		task.then(() => this._tasks.delete(task));
+	}
+	_peerError(peer, error) {
+		if (!peer.signal.aborted && !this._disposed) this._report(error);
+		peer.dispose();
+	}
+	_report(error) {
+		const report = this._options.onError ?? ((error) => process.emitWarning(error));
+		try {
+			report(error instanceof Error ? error : new Error(String(error)));
+		} catch (error) {
+			process.emitWarning(new Error("startEndpoint onError callback threw", { cause: error }));
+		}
+	}
+};
+var ListenerPeer = class {
+	_closeSocket;
+	_abort = new AbortController();
+	signal = this._abort.signal;
+	_finish;
+	closed = new Promise((resolve) => {
+		this._finish = resolve;
+	});
+	_transport;
+	_closeChannel;
+	_resumeRequests;
+	constructor(_closeSocket) {
+		this._closeSocket = _closeSocket;
+	}
+	setTransport(transport) {
+		this._transport = transport;
+		if (this.signal.aborted) transport.dispose();
+	}
+	connect() {
+		const rpc = JsonRpcChannel.createWithClose(this._transport, { deferRequests: true });
+		this._closeChannel = rpc.close;
+		this._resumeRequests = rpc.resumeRequests;
+		return {
+			channel: rpc.channel,
+			closed: this.closed,
+			dispose: () => this.dispose()
+		};
+	}
+	resumeRequests() {
+		this._resumeRequests?.();
+	}
+	dispose() {
+		if (this.signal.aborted) return;
+		this._abort.abort(/* @__PURE__ */ new Error("Endpoint connection closed"));
+		this._closeChannel?.();
+		this._transport?.dispose();
+		this._closeSocket();
+		this._finish();
+	}
+};
+function _listen(server, listen) {
+	return new Promise((resolve, reject) => {
+		const onError = (error) => {
+			server.removeListener("listening", onListening);
+			reject(error);
+		};
+		const onListening = () => {
+			server.removeListener("error", onError);
+			resolve();
+		};
+		server.once("error", onError);
+		server.once("listening", onListening);
+		try {
+			listen();
+		} catch (error) {
+			server.removeListener("error", onError);
+			server.removeListener("listening", onListening);
+			reject(error);
+		}
+	});
+}
+//#endregion
+//#region src/node/headerDelimitedTransport.ts
+const HEADER_SEPARATOR = Buffer.from("\r\n\r\n");
+const DEFAULT_MAX_HEADER_BYTES = 65536;
+const DEFAULT_MAX_CONTENT_LENGTH = 67108864;
+const DEFAULT_MAX_PENDING_MESSAGES = 1024;
+/**
+* LSP "base protocol" framing over a Node Readable/Writable pair.
+*
+* The streams remain owned by the caller: close/dispose detach listeners but
+* never end, destroy, or otherwise take ownership of either stream.
+*/
+var HeaderDelimitedTransport = class {
+	_input;
+	_output;
+	_onClose;
+	_listener;
+	_pending = [];
+	_residual = Buffer.alloc(0);
+	_expectedLength;
+	_closed = false;
+	_closeReason;
+	_maxHeaderBytes;
+	_maxContentLength;
+	_maxPendingMessages;
+	_onDataListener = (chunk) => this._onData(chunk);
+	_onEndListener = () => this._onEnd();
+	_onInputErrorListener = (error) => this.close(`Header-delimited input error: ${error.message}`);
+	_onOutputErrorListener = (error) => this.close(`Header-delimited output error: ${error.message}`);
+	constructor(_input, _output, _onClose, options = {}) {
+		this._input = _input;
+		this._output = _output;
+		this._onClose = _onClose;
+		this._maxHeaderBytes = positiveLimit(options.maxHeaderBytes, DEFAULT_MAX_HEADER_BYTES, "maxHeaderBytes");
+		this._maxContentLength = positiveLimit(options.maxContentLength, DEFAULT_MAX_CONTENT_LENGTH, "maxContentLength");
+		this._maxPendingMessages = positiveLimit(options.maxPendingMessages, DEFAULT_MAX_PENDING_MESSAGES, "maxPendingMessages");
+		_input.on("data", this._onDataListener);
+		_input.on("end", this._onEndListener);
+		_input.on("close", this._onEndListener);
+		_input.on("error", this._onInputErrorListener);
+		_output.on("error", this._onOutputErrorListener);
+	}
+	get closed() {
+		return this._closed;
+	}
+	get closeReason() {
+		return this._closeReason;
+	}
+	send(message) {
+		if (this._closed) return Promise.reject(new Error(this._closeReason ?? "Header-delimited transport is closed"));
+		const body = Buffer.from(JSON.stringify(message), "utf8");
+		if (body.length > this._maxContentLength) return Promise.reject(/* @__PURE__ */ new Error(`Header-delimited payload exceeds ${this._maxContentLength} bytes`));
+		const wire = Buffer.concat([Buffer.from(`Content-Length: ${body.length}\r\n\r\n`, "ascii"), body]);
+		return new Promise((resolve, reject) => {
+			this._output.write(wire, (error) => {
+				if (error) reject(error);
+				else resolve();
+			});
+		});
+	}
+	setListener(listener) {
+		this._listener = listener;
+		while (this._listener && this._pending.length > 0) this._listener(this._pending.shift());
+	}
+	dispose() {
+		this.close("Header-delimited transport disposed");
+	}
+	close(reason = "Header-delimited transport closed") {
+		if (this._closed) return;
+		this._closed = true;
+		this._closeReason = reason;
+		this._input.off("data", this._onDataListener);
+		this._input.off("end", this._onEndListener);
+		this._input.off("close", this._onEndListener);
+		this._input.off("error", this._onInputErrorListener);
+		this._output.off("error", this._onOutputErrorListener);
+		this._onClose?.(reason);
+	}
+	_onData(chunk) {
+		if (this._closed) return;
+		const bytes = typeof chunk === "string" ? Buffer.from(chunk, "utf8") : chunk;
+		this._residual = this._residual.length === 0 ? Buffer.from(bytes) : Buffer.concat([this._residual, bytes]);
+		while (!this._closed) {
+			if (this._expectedLength === void 0) {
+				const headerEnd = this._residual.indexOf(HEADER_SEPARATOR);
+				if (headerEnd < 0) {
+					if (this._residual.length > this._maxHeaderBytes) this.close(`Invalid header-delimited frame: header exceeds ${this._maxHeaderBytes} bytes`);
+					return;
+				}
+				if (headerEnd + HEADER_SEPARATOR.length > this._maxHeaderBytes) {
+					this.close(`Invalid header-delimited frame: header exceeds ${this._maxHeaderBytes} bytes`);
+					return;
+				}
+				try {
+					this._expectedLength = parseHeaders(this._residual.subarray(0, headerEnd), this._maxContentLength);
+				} catch (error) {
+					this.close(`Invalid header-delimited frame: ${error instanceof Error ? error.message : String(error)}`);
+					return;
+				}
+				this._residual = this._residual.subarray(headerEnd + HEADER_SEPARATOR.length);
+			}
+			if (this._residual.length < this._expectedLength) return;
+			const body = this._residual.subarray(0, this._expectedLength);
+			this._residual = this._residual.subarray(this._expectedLength);
+			this._expectedLength = void 0;
+			let parsed;
+			try {
+				parsed = JSON.parse(body.toString("utf8"));
+			} catch (error) {
+				this.close(`Invalid header-delimited JSON payload: ${error instanceof Error ? error.message : String(error)}`);
+				return;
+			}
+			this._deliver(parsed);
+		}
+	}
+	_onEnd() {
+		if (this._closed) return;
+		this.close(this._expectedLength !== void 0 || this._residual.length > 0 ? "Truncated header-delimited frame" : "Header-delimited input closed");
+	}
+	_deliver(message) {
+		if (this._listener) {
+			this._listener(message);
+			return;
+		}
+		if (this._pending.length >= this._maxPendingMessages) {
+			this.close(`Header-delimited pending message limit ${this._maxPendingMessages} exceeded`);
+			return;
+		}
+		this._pending.push(message);
+	}
+};
+function parseHeaders(headerBytes, maxContentLength) {
+	const values = /* @__PURE__ */ new Map();
+	for (const line of headerBytes.toString("ascii").split("\r\n")) {
+		const colon = line.indexOf(":");
+		if (colon <= 0) throw new Error(`malformed header ${JSON.stringify(line)}`);
+		const name = line.slice(0, colon).trim().toLowerCase();
+		const value = line.slice(colon + 1).trim();
+		if (values.has(name)) throw new Error(`duplicate ${name} header`);
+		values.set(name, value);
+	}
+	const rawLength = values.get("content-length");
+	if (rawLength === void 0 || !/^(0|[1-9]\d*)$/.test(rawLength)) throw new Error("missing or invalid Content-Length header");
+	const length = Number(rawLength);
+	if (!Number.isSafeInteger(length) || length > maxContentLength) throw new Error(`Content-Length exceeds ${maxContentLength} bytes`);
+	const contentType = values.get("content-type");
+	if (contentType !== void 0 && !isSupportedContentType(contentType)) throw new Error(`unsupported Content-Type ${JSON.stringify(contentType)}`);
+	return length;
+}
+function isSupportedContentType(value) {
+	const parts = value.split(";").map((part) => part.trim().toLowerCase());
+	return parts[0] === "application/vscode-jsonrpc" && parts.slice(1).every((part) => /^charset\s*=\s*"?utf-?8"?$/.test(part));
+}
+function positiveLimit(value, fallback, name) {
+	const result = value ?? fallback;
+	if (!Number.isSafeInteger(result) || result <= 0) throw new Error(`${name} must be a positive integer`);
+	return result;
+}
+
+export { HeaderDelimitedTransport, JsonRpcChannel, LINKRPC_ENDPOINT_VAR, WebSocketTransport, connectNdjson, formatEndpointUri, openHubChannel, openStdioChannel, openWebSocket, parseEndpointUri, runInitializeHandshake, startEndpoint, traceMessageTransport };
+//# sourceMappingURL=node.js.map