@gadgetinc/substrate 0.1.0-rc.1

package/dist/index.js

@@ -0,0 +1,4589 @@
+//#region \0rolldown/runtime.js
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+
+//#endregion
+//#region node_modules/.pnpm/vscode-jsonrpc@8.2.1/node_modules/vscode-jsonrpc/lib/common/is.js
+var require_is = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.stringArray = exports.array = exports.func = exports.error = exports.number = exports.string = exports.boolean = void 0;
+	function boolean(value) {
+		return value === true || value === false;
+	}
+	exports.boolean = boolean;
+	function string(value) {
+		return typeof value === "string" || value instanceof String;
+	}
+	exports.string = string;
+	function number(value) {
+		return typeof value === "number" || value instanceof Number;
+	}
+	exports.number = number;
+	function error(value) {
+		return value instanceof Error;
+	}
+	exports.error = error;
+	function func(value) {
+		return typeof value === "function";
+	}
+	exports.func = func;
+	function array(value) {
+		return Array.isArray(value);
+	}
+	exports.array = array;
+	function stringArray(value) {
+		return array(value) && value.every((elem) => string(elem));
+	}
+	exports.stringArray = stringArray;
+}));
+
+//#endregion
+//#region node_modules/.pnpm/vscode-jsonrpc@8.2.1/node_modules/vscode-jsonrpc/lib/common/messages.js
+var require_messages = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.Message = exports.NotificationType9 = exports.NotificationType8 = exports.NotificationType7 = exports.NotificationType6 = exports.NotificationType5 = exports.NotificationType4 = exports.NotificationType3 = exports.NotificationType2 = exports.NotificationType1 = exports.NotificationType0 = exports.NotificationType = exports.RequestType9 = exports.RequestType8 = exports.RequestType7 = exports.RequestType6 = exports.RequestType5 = exports.RequestType4 = exports.RequestType3 = exports.RequestType2 = exports.RequestType1 = exports.RequestType = exports.RequestType0 = exports.AbstractMessageSignature = exports.ParameterStructures = exports.ResponseError = exports.ErrorCodes = void 0;
+	const is = require_is();
+	/**
+	* Predefined error codes.
+	*/
+	var ErrorCodes;
+	(function(ErrorCodes) {
+		ErrorCodes.ParseError = -32700;
+		ErrorCodes.InvalidRequest = -32600;
+		ErrorCodes.MethodNotFound = -32601;
+		ErrorCodes.InvalidParams = -32602;
+		ErrorCodes.InternalError = -32603;
+		/**
+		* This is the start range of JSON RPC reserved error codes.
+		* It doesn't denote a real error code. No application error codes should
+		* be defined between the start and end range. For backwards
+		* compatibility the `ServerNotInitialized` and the `UnknownErrorCode`
+		* are left in the range.
+		*
+		* @since 3.16.0
+		*/
+		ErrorCodes.jsonrpcReservedErrorRangeStart = -32099;
+		/** @deprecated use  jsonrpcReservedErrorRangeStart */
+		ErrorCodes.serverErrorStart = -32099;
+		/**
+		* An error occurred when write a message to the transport layer.
+		*/
+		ErrorCodes.MessageWriteError = -32099;
+		/**
+		* An error occurred when reading a message from the transport layer.
+		*/
+		ErrorCodes.MessageReadError = -32098;
+		/**
+		* The connection got disposed or lost and all pending responses got
+		* rejected.
+		*/
+		ErrorCodes.PendingResponseRejected = -32097;
+		/**
+		* The connection is inactive and a use of it failed.
+		*/
+		ErrorCodes.ConnectionInactive = -32096;
+		/**
+		* Error code indicating that a server received a notification or
+		* request before the server has received the `initialize` request.
+		*/
+		ErrorCodes.ServerNotInitialized = -32002;
+		ErrorCodes.UnknownErrorCode = -32001;
+		/**
+		* This is the end range of JSON RPC reserved error codes.
+		* It doesn't denote a real error code.
+		*
+		* @since 3.16.0
+		*/
+		ErrorCodes.jsonrpcReservedErrorRangeEnd = -32e3;
+		/** @deprecated use  jsonrpcReservedErrorRangeEnd */
+		ErrorCodes.serverErrorEnd = -32e3;
+	})(ErrorCodes || (exports.ErrorCodes = ErrorCodes = {}));
+	/**
+	* An error object return in a response in case a request
+	* has failed.
+	*/
+	var ResponseError = class ResponseError extends Error {
+		constructor(code, message, data) {
+			super(message);
+			this.code = is.number(code) ? code : ErrorCodes.UnknownErrorCode;
+			this.data = data;
+			Object.setPrototypeOf(this, ResponseError.prototype);
+		}
+		toJson() {
+			const result = {
+				code: this.code,
+				message: this.message
+			};
+			if (this.data !== void 0) result.data = this.data;
+			return result;
+		}
+	};
+	exports.ResponseError = ResponseError;
+	var ParameterStructures = class ParameterStructures {
+		constructor(kind) {
+			this.kind = kind;
+		}
+		static is(value) {
+			return value === ParameterStructures.auto || value === ParameterStructures.byName || value === ParameterStructures.byPosition;
+		}
+		toString() {
+			return this.kind;
+		}
+	};
+	exports.ParameterStructures = ParameterStructures;
+	/**
+	* The parameter structure is automatically inferred on the number of parameters
+	* and the parameter type in case of a single param.
+	*/
+	ParameterStructures.auto = new ParameterStructures("auto");
+	/**
+	* Forces `byPosition` parameter structure. This is useful if you have a single
+	* parameter which has a literal type.
+	*/
+	ParameterStructures.byPosition = new ParameterStructures("byPosition");
+	/**
+	* Forces `byName` parameter structure. This is only useful when having a single
+	* parameter. The library will report errors if used with a different number of
+	* parameters.
+	*/
+	ParameterStructures.byName = new ParameterStructures("byName");
+	/**
+	* An abstract implementation of a MessageType.
+	*/
+	var AbstractMessageSignature = class {
+		constructor(method, numberOfParams) {
+			this.method = method;
+			this.numberOfParams = numberOfParams;
+		}
+		get parameterStructures() {
+			return ParameterStructures.auto;
+		}
+	};
+	exports.AbstractMessageSignature = AbstractMessageSignature;
+	/**
+	* Classes to type request response pairs
+	*/
+	var RequestType0 = class extends AbstractMessageSignature {
+		constructor(method) {
+			super(method, 0);
+		}
+	};
+	exports.RequestType0 = RequestType0;
+	var RequestType = class extends AbstractMessageSignature {
+		constructor(method, _parameterStructures = ParameterStructures.auto) {
+			super(method, 1);
+			this._parameterStructures = _parameterStructures;
+		}
+		get parameterStructures() {
+			return this._parameterStructures;
+		}
+	};
+	exports.RequestType = RequestType;
+	var RequestType1 = class extends AbstractMessageSignature {
+		constructor(method, _parameterStructures = ParameterStructures.auto) {
+			super(method, 1);
+			this._parameterStructures = _parameterStructures;
+		}
+		get parameterStructures() {
+			return this._parameterStructures;
+		}
+	};
+	exports.RequestType1 = RequestType1;
+	var RequestType2 = class extends AbstractMessageSignature {
+		constructor(method) {
+			super(method, 2);
+		}
+	};
+	exports.RequestType2 = RequestType2;
+	var RequestType3 = class extends AbstractMessageSignature {
+		constructor(method) {
+			super(method, 3);
+		}
+	};
+	exports.RequestType3 = RequestType3;
+	var RequestType4 = class extends AbstractMessageSignature {
+		constructor(method) {
+			super(method, 4);
+		}
+	};
+	exports.RequestType4 = RequestType4;
+	var RequestType5 = class extends AbstractMessageSignature {
+		constructor(method) {
+			super(method, 5);
+		}
+	};
+	exports.RequestType5 = RequestType5;
+	var RequestType6 = class extends AbstractMessageSignature {
+		constructor(method) {
+			super(method, 6);
+		}
+	};
+	exports.RequestType6 = RequestType6;
+	var RequestType7 = class extends AbstractMessageSignature {
+		constructor(method) {
+			super(method, 7);
+		}
+	};
+	exports.RequestType7 = RequestType7;
+	var RequestType8 = class extends AbstractMessageSignature {
+		constructor(method) {
+			super(method, 8);
+		}
+	};
+	exports.RequestType8 = RequestType8;
+	var RequestType9 = class extends AbstractMessageSignature {
+		constructor(method) {
+			super(method, 9);
+		}
+	};
+	exports.RequestType9 = RequestType9;
+	var NotificationType = class extends AbstractMessageSignature {
+		constructor(method, _parameterStructures = ParameterStructures.auto) {
+			super(method, 1);
+			this._parameterStructures = _parameterStructures;
+		}
+		get parameterStructures() {
+			return this._parameterStructures;
+		}
+	};
+	exports.NotificationType = NotificationType;
+	var NotificationType0 = class extends AbstractMessageSignature {
+		constructor(method) {
+			super(method, 0);
+		}
+	};
+	exports.NotificationType0 = NotificationType0;
+	var NotificationType1 = class extends AbstractMessageSignature {
+		constructor(method, _parameterStructures = ParameterStructures.auto) {
+			super(method, 1);
+			this._parameterStructures = _parameterStructures;
+		}
+		get parameterStructures() {
+			return this._parameterStructures;
+		}
+	};
+	exports.NotificationType1 = NotificationType1;
+	var NotificationType2 = class extends AbstractMessageSignature {
+		constructor(method) {
+			super(method, 2);
+		}
+	};
+	exports.NotificationType2 = NotificationType2;
+	var NotificationType3 = class extends AbstractMessageSignature {
+		constructor(method) {
+			super(method, 3);
+		}
+	};
+	exports.NotificationType3 = NotificationType3;
+	var NotificationType4 = class extends AbstractMessageSignature {
+		constructor(method) {
+			super(method, 4);
+		}
+	};
+	exports.NotificationType4 = NotificationType4;
+	var NotificationType5 = class extends AbstractMessageSignature {
+		constructor(method) {
+			super(method, 5);
+		}
+	};
+	exports.NotificationType5 = NotificationType5;
+	var NotificationType6 = class extends AbstractMessageSignature {
+		constructor(method) {
+			super(method, 6);
+		}
+	};
+	exports.NotificationType6 = NotificationType6;
+	var NotificationType7 = class extends AbstractMessageSignature {
+		constructor(method) {
+			super(method, 7);
+		}
+	};
+	exports.NotificationType7 = NotificationType7;
+	var NotificationType8 = class extends AbstractMessageSignature {
+		constructor(method) {
+			super(method, 8);
+		}
+	};
+	exports.NotificationType8 = NotificationType8;
+	var NotificationType9 = class extends AbstractMessageSignature {
+		constructor(method) {
+			super(method, 9);
+		}
+	};
+	exports.NotificationType9 = NotificationType9;
+	var Message;
+	(function(Message) {
+		/**
+		* Tests if the given message is a request message
+		*/
+		function isRequest(message) {
+			const candidate = message;
+			return candidate && is.string(candidate.method) && (is.string(candidate.id) || is.number(candidate.id));
+		}
+		Message.isRequest = isRequest;
+		/**
+		* Tests if the given message is a notification message
+		*/
+		function isNotification(message) {
+			const candidate = message;
+			return candidate && is.string(candidate.method) && message.id === void 0;
+		}
+		Message.isNotification = isNotification;
+		/**
+		* Tests if the given message is a response message
+		*/
+		function isResponse(message) {
+			const candidate = message;
+			return candidate && (candidate.result !== void 0 || !!candidate.error) && (is.string(candidate.id) || is.number(candidate.id) || candidate.id === null);
+		}
+		Message.isResponse = isResponse;
+	})(Message || (exports.Message = Message = {}));
+}));
+
+//#endregion
+//#region node_modules/.pnpm/vscode-jsonrpc@8.2.1/node_modules/vscode-jsonrpc/lib/common/linkedMap.js
+var require_linkedMap = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var _a;
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.LRUCache = exports.LinkedMap = exports.Touch = void 0;
+	var Touch;
+	(function(Touch) {
+		Touch.None = 0;
+		Touch.First = 1;
+		Touch.AsOld = Touch.First;
+		Touch.Last = 2;
+		Touch.AsNew = Touch.Last;
+	})(Touch || (exports.Touch = Touch = {}));
+	var LinkedMap = class {
+		constructor() {
+			this[_a] = "LinkedMap";
+			this._map = /* @__PURE__ */ new Map();
+			this._head = void 0;
+			this._tail = void 0;
+			this._size = 0;
+			this._state = 0;
+		}
+		clear() {
+			this._map.clear();
+			this._head = void 0;
+			this._tail = void 0;
+			this._size = 0;
+			this._state++;
+		}
+		isEmpty() {
+			return !this._head && !this._tail;
+		}
+		get size() {
+			return this._size;
+		}
+		get first() {
+			return this._head?.value;
+		}
+		get last() {
+			return this._tail?.value;
+		}
+		has(key) {
+			return this._map.has(key);
+		}
+		get(key, touch = Touch.None) {
+			const item = this._map.get(key);
+			if (!item) return;
+			if (touch !== Touch.None) this.touch(item, touch);
+			return item.value;
+		}
+		set(key, value, touch = Touch.None) {
+			let item = this._map.get(key);
+			if (item) {
+				item.value = value;
+				if (touch !== Touch.None) this.touch(item, touch);
+			} else {
+				item = {
+					key,
+					value,
+					next: void 0,
+					previous: void 0
+				};
+				switch (touch) {
+					case Touch.None:
+						this.addItemLast(item);
+						break;
+					case Touch.First:
+						this.addItemFirst(item);
+						break;
+					case Touch.Last:
+						this.addItemLast(item);
+						break;
+					default:
+						this.addItemLast(item);
+						break;
+				}
+				this._map.set(key, item);
+				this._size++;
+			}
+			return this;
+		}
+		delete(key) {
+			return !!this.remove(key);
+		}
+		remove(key) {
+			const item = this._map.get(key);
+			if (!item) return;
+			this._map.delete(key);
+			this.removeItem(item);
+			this._size--;
+			return item.value;
+		}
+		shift() {
+			if (!this._head && !this._tail) return;
+			if (!this._head || !this._tail) throw new Error("Invalid list");
+			const item = this._head;
+			this._map.delete(item.key);
+			this.removeItem(item);
+			this._size--;
+			return item.value;
+		}
+		forEach(callbackfn, thisArg) {
+			const state = this._state;
+			let current = this._head;
+			while (current) {
+				if (thisArg) callbackfn.bind(thisArg)(current.value, current.key, this);
+				else callbackfn(current.value, current.key, this);
+				if (this._state !== state) throw new Error(`LinkedMap got modified during iteration.`);
+				current = current.next;
+			}
+		}
+		keys() {
+			const state = this._state;
+			let current = this._head;
+			const iterator = {
+				[Symbol.iterator]: () => {
+					return iterator;
+				},
+				next: () => {
+					if (this._state !== state) throw new Error(`LinkedMap got modified during iteration.`);
+					if (current) {
+						const result = {
+							value: current.key,
+							done: false
+						};
+						current = current.next;
+						return result;
+					} else return {
+						value: void 0,
+						done: true
+					};
+				}
+			};
+			return iterator;
+		}
+		values() {
+			const state = this._state;
+			let current = this._head;
+			const iterator = {
+				[Symbol.iterator]: () => {
+					return iterator;
+				},
+				next: () => {
+					if (this._state !== state) throw new Error(`LinkedMap got modified during iteration.`);
+					if (current) {
+						const result = {
+							value: current.value,
+							done: false
+						};
+						current = current.next;
+						return result;
+					} else return {
+						value: void 0,
+						done: true
+					};
+				}
+			};
+			return iterator;
+		}
+		entries() {
+			const state = this._state;
+			let current = this._head;
+			const iterator = {
+				[Symbol.iterator]: () => {
+					return iterator;
+				},
+				next: () => {
+					if (this._state !== state) throw new Error(`LinkedMap got modified during iteration.`);
+					if (current) {
+						const result = {
+							value: [current.key, current.value],
+							done: false
+						};
+						current = current.next;
+						return result;
+					} else return {
+						value: void 0,
+						done: true
+					};
+				}
+			};
+			return iterator;
+		}
+		[(_a = Symbol.toStringTag, Symbol.iterator)]() {
+			return this.entries();
+		}
+		trimOld(newSize) {
+			if (newSize >= this.size) return;
+			if (newSize === 0) {
+				this.clear();
+				return;
+			}
+			let current = this._head;
+			let currentSize = this.size;
+			while (current && currentSize > newSize) {
+				this._map.delete(current.key);
+				current = current.next;
+				currentSize--;
+			}
+			this._head = current;
+			this._size = currentSize;
+			if (current) current.previous = void 0;
+			this._state++;
+		}
+		addItemFirst(item) {
+			if (!this._head && !this._tail) this._tail = item;
+			else if (!this._head) throw new Error("Invalid list");
+			else {
+				item.next = this._head;
+				this._head.previous = item;
+			}
+			this._head = item;
+			this._state++;
+		}
+		addItemLast(item) {
+			if (!this._head && !this._tail) this._head = item;
+			else if (!this._tail) throw new Error("Invalid list");
+			else {
+				item.previous = this._tail;
+				this._tail.next = item;
+			}
+			this._tail = item;
+			this._state++;
+		}
+		removeItem(item) {
+			if (item === this._head && item === this._tail) {
+				this._head = void 0;
+				this._tail = void 0;
+			} else if (item === this._head) {
+				if (!item.next) throw new Error("Invalid list");
+				item.next.previous = void 0;
+				this._head = item.next;
+			} else if (item === this._tail) {
+				if (!item.previous) throw new Error("Invalid list");
+				item.previous.next = void 0;
+				this._tail = item.previous;
+			} else {
+				const next = item.next;
+				const previous = item.previous;
+				if (!next || !previous) throw new Error("Invalid list");
+				next.previous = previous;
+				previous.next = next;
+			}
+			item.next = void 0;
+			item.previous = void 0;
+			this._state++;
+		}
+		touch(item, touch) {
+			if (!this._head || !this._tail) throw new Error("Invalid list");
+			if (touch !== Touch.First && touch !== Touch.Last) return;
+			if (touch === Touch.First) {
+				if (item === this._head) return;
+				const next = item.next;
+				const previous = item.previous;
+				if (item === this._tail) {
+					previous.next = void 0;
+					this._tail = previous;
+				} else {
+					next.previous = previous;
+					previous.next = next;
+				}
+				item.previous = void 0;
+				item.next = this._head;
+				this._head.previous = item;
+				this._head = item;
+				this._state++;
+			} else if (touch === Touch.Last) {
+				if (item === this._tail) return;
+				const next = item.next;
+				const previous = item.previous;
+				if (item === this._head) {
+					next.previous = void 0;
+					this._head = next;
+				} else {
+					next.previous = previous;
+					previous.next = next;
+				}
+				item.next = void 0;
+				item.previous = this._tail;
+				this._tail.next = item;
+				this._tail = item;
+				this._state++;
+			}
+		}
+		toJSON() {
+			const data = [];
+			this.forEach((value, key) => {
+				data.push([key, value]);
+			});
+			return data;
+		}
+		fromJSON(data) {
+			this.clear();
+			for (const [key, value] of data) this.set(key, value);
+		}
+	};
+	exports.LinkedMap = LinkedMap;
+	var LRUCache = class extends LinkedMap {
+		constructor(limit, ratio = 1) {
+			super();
+			this._limit = limit;
+			this._ratio = Math.min(Math.max(0, ratio), 1);
+		}
+		get limit() {
+			return this._limit;
+		}
+		set limit(limit) {
+			this._limit = limit;
+			this.checkTrim();
+		}
+		get ratio() {
+			return this._ratio;
+		}
+		set ratio(ratio) {
+			this._ratio = Math.min(Math.max(0, ratio), 1);
+			this.checkTrim();
+		}
+		get(key, touch = Touch.AsNew) {
+			return super.get(key, touch);
+		}
+		peek(key) {
+			return super.get(key, Touch.None);
+		}
+		set(key, value) {
+			super.set(key, value, Touch.Last);
+			this.checkTrim();
+			return this;
+		}
+		checkTrim() {
+			if (this.size > this._limit) this.trimOld(Math.round(this._limit * this._ratio));
+		}
+	};
+	exports.LRUCache = LRUCache;
+}));
+
+//#endregion
+//#region node_modules/.pnpm/vscode-jsonrpc@8.2.1/node_modules/vscode-jsonrpc/lib/common/disposable.js
+var require_disposable = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.Disposable = void 0;
+	var Disposable;
+	(function(Disposable) {
+		function create(func) {
+			return { dispose: func };
+		}
+		Disposable.create = create;
+	})(Disposable || (exports.Disposable = Disposable = {}));
+}));
+
+//#endregion
+//#region node_modules/.pnpm/vscode-jsonrpc@8.2.1/node_modules/vscode-jsonrpc/lib/common/ral.js
+var require_ral = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	let _ral;
+	function RAL() {
+		if (_ral === void 0) throw new Error(`No runtime abstraction layer installed`);
+		return _ral;
+	}
+	(function(RAL) {
+		function install(ral) {
+			if (ral === void 0) throw new Error(`No runtime abstraction layer provided`);
+			_ral = ral;
+		}
+		RAL.install = install;
+	})(RAL || (RAL = {}));
+	exports.default = RAL;
+}));
+
+//#endregion
+//#region node_modules/.pnpm/vscode-jsonrpc@8.2.1/node_modules/vscode-jsonrpc/lib/common/events.js
+var require_events = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.Emitter = exports.Event = void 0;
+	const ral_1 = require_ral();
+	var Event;
+	(function(Event) {
+		const _disposable = { dispose() {} };
+		Event.None = function() {
+			return _disposable;
+		};
+	})(Event || (exports.Event = Event = {}));
+	var CallbackList = class {
+		add(callback, context = null, bucket) {
+			if (!this._callbacks) {
+				this._callbacks = [];
+				this._contexts = [];
+			}
+			this._callbacks.push(callback);
+			this._contexts.push(context);
+			if (Array.isArray(bucket)) bucket.push({ dispose: () => this.remove(callback, context) });
+		}
+		remove(callback, context = null) {
+			if (!this._callbacks) return;
+			let foundCallbackWithDifferentContext = false;
+			for (let i = 0, len = this._callbacks.length; i < len; i++) if (this._callbacks[i] === callback) if (this._contexts[i] === context) {
+				this._callbacks.splice(i, 1);
+				this._contexts.splice(i, 1);
+				return;
+			} else foundCallbackWithDifferentContext = true;
+			if (foundCallbackWithDifferentContext) throw new Error("When adding a listener with a context, you should remove it with the same context");
+		}
+		invoke(...args) {
+			if (!this._callbacks) return [];
+			const ret = [], callbacks = this._callbacks.slice(0), contexts = this._contexts.slice(0);
+			for (let i = 0, len = callbacks.length; i < len; i++) try {
+				ret.push(callbacks[i].apply(contexts[i], args));
+			} catch (e) {
+				(0, ral_1.default)().console.error(e);
+			}
+			return ret;
+		}
+		isEmpty() {
+			return !this._callbacks || this._callbacks.length === 0;
+		}
+		dispose() {
+			this._callbacks = void 0;
+			this._contexts = void 0;
+		}
+	};
+	var Emitter = class Emitter {
+		constructor(_options) {
+			this._options = _options;
+		}
+		/**
+		* For the public to allow to subscribe
+		* to events from this Emitter
+		*/
+		get event() {
+			if (!this._event) this._event = (listener, thisArgs, disposables) => {
+				if (!this._callbacks) this._callbacks = new CallbackList();
+				if (this._options && this._options.onFirstListenerAdd && this._callbacks.isEmpty()) this._options.onFirstListenerAdd(this);
+				this._callbacks.add(listener, thisArgs);
+				const result = { dispose: () => {
+					if (!this._callbacks) return;
+					this._callbacks.remove(listener, thisArgs);
+					result.dispose = Emitter._noop;
+					if (this._options && this._options.onLastListenerRemove && this._callbacks.isEmpty()) this._options.onLastListenerRemove(this);
+				} };
+				if (Array.isArray(disposables)) disposables.push(result);
+				return result;
+			};
+			return this._event;
+		}
+		/**
+		* To be kept private to fire an event to
+		* subscribers
+		*/
+		fire(event) {
+			if (this._callbacks) this._callbacks.invoke.call(this._callbacks, event);
+		}
+		dispose() {
+			if (this._callbacks) {
+				this._callbacks.dispose();
+				this._callbacks = void 0;
+			}
+		}
+	};
+	exports.Emitter = Emitter;
+	Emitter._noop = function() {};
+}));
+
+//#endregion
+//#region node_modules/.pnpm/vscode-jsonrpc@8.2.1/node_modules/vscode-jsonrpc/lib/common/cancellation.js
+var require_cancellation = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.CancellationTokenSource = exports.CancellationToken = void 0;
+	const ral_1 = require_ral();
+	const Is = require_is();
+	const events_1 = require_events();
+	var CancellationToken;
+	(function(CancellationToken) {
+		CancellationToken.None = Object.freeze({
+			isCancellationRequested: false,
+			onCancellationRequested: events_1.Event.None
+		});
+		CancellationToken.Cancelled = Object.freeze({
+			isCancellationRequested: true,
+			onCancellationRequested: events_1.Event.None
+		});
+		function is(value) {
+			const candidate = value;
+			return candidate && (candidate === CancellationToken.None || candidate === CancellationToken.Cancelled || Is.boolean(candidate.isCancellationRequested) && !!candidate.onCancellationRequested);
+		}
+		CancellationToken.is = is;
+	})(CancellationToken || (exports.CancellationToken = CancellationToken = {}));
+	const shortcutEvent = Object.freeze(function(callback, context) {
+		const handle = (0, ral_1.default)().timer.setTimeout(callback.bind(context), 0);
+		return { dispose() {
+			handle.dispose();
+		} };
+	});
+	var MutableToken = class {
+		constructor() {
+			this._isCancelled = false;
+		}
+		cancel() {
+			if (!this._isCancelled) {
+				this._isCancelled = true;
+				if (this._emitter) {
+					this._emitter.fire(void 0);
+					this.dispose();
+				}
+			}
+		}
+		get isCancellationRequested() {
+			return this._isCancelled;
+		}
+		get onCancellationRequested() {
+			if (this._isCancelled) return shortcutEvent;
+			if (!this._emitter) this._emitter = new events_1.Emitter();
+			return this._emitter.event;
+		}
+		dispose() {
+			if (this._emitter) {
+				this._emitter.dispose();
+				this._emitter = void 0;
+			}
+		}
+	};
+	var CancellationTokenSource = class {
+		get token() {
+			if (!this._token) this._token = new MutableToken();
+			return this._token;
+		}
+		cancel() {
+			if (!this._token) this._token = CancellationToken.Cancelled;
+			else this._token.cancel();
+		}
+		dispose() {
+			if (!this._token) this._token = CancellationToken.None;
+			else if (this._token instanceof MutableToken) this._token.dispose();
+		}
+	};
+	exports.CancellationTokenSource = CancellationTokenSource;
+}));
+
+//#endregion
+//#region node_modules/.pnpm/vscode-jsonrpc@8.2.1/node_modules/vscode-jsonrpc/lib/common/sharedArrayCancellation.js
+var require_sharedArrayCancellation = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.SharedArrayReceiverStrategy = exports.SharedArraySenderStrategy = void 0;
+	const cancellation_1 = require_cancellation();
+	var CancellationState;
+	(function(CancellationState) {
+		CancellationState.Continue = 0;
+		CancellationState.Cancelled = 1;
+	})(CancellationState || (CancellationState = {}));
+	var SharedArraySenderStrategy = class {
+		constructor() {
+			this.buffers = /* @__PURE__ */ new Map();
+		}
+		enableCancellation(request) {
+			if (request.id === null) return;
+			const buffer = new SharedArrayBuffer(4);
+			const data = new Int32Array(buffer, 0, 1);
+			data[0] = CancellationState.Continue;
+			this.buffers.set(request.id, buffer);
+			request.$cancellationData = buffer;
+		}
+		async sendCancellation(_conn, id) {
+			const buffer = this.buffers.get(id);
+			if (buffer === void 0) return;
+			const data = new Int32Array(buffer, 0, 1);
+			Atomics.store(data, 0, CancellationState.Cancelled);
+		}
+		cleanup(id) {
+			this.buffers.delete(id);
+		}
+		dispose() {
+			this.buffers.clear();
+		}
+	};
+	exports.SharedArraySenderStrategy = SharedArraySenderStrategy;
+	var SharedArrayBufferCancellationToken = class {
+		constructor(buffer) {
+			this.data = new Int32Array(buffer, 0, 1);
+		}
+		get isCancellationRequested() {
+			return Atomics.load(this.data, 0) === CancellationState.Cancelled;
+		}
+		get onCancellationRequested() {
+			throw new Error(`Cancellation over SharedArrayBuffer doesn't support cancellation events`);
+		}
+	};
+	var SharedArrayBufferCancellationTokenSource = class {
+		constructor(buffer) {
+			this.token = new SharedArrayBufferCancellationToken(buffer);
+		}
+		cancel() {}
+		dispose() {}
+	};
+	var SharedArrayReceiverStrategy = class {
+		constructor() {
+			this.kind = "request";
+		}
+		createCancellationTokenSource(request) {
+			const buffer = request.$cancellationData;
+			if (buffer === void 0) return new cancellation_1.CancellationTokenSource();
+			return new SharedArrayBufferCancellationTokenSource(buffer);
+		}
+	};
+	exports.SharedArrayReceiverStrategy = SharedArrayReceiverStrategy;
+}));
+
+//#endregion
+//#region node_modules/.pnpm/vscode-jsonrpc@8.2.1/node_modules/vscode-jsonrpc/lib/common/semaphore.js
+var require_semaphore = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.Semaphore = void 0;
+	const ral_1 = require_ral();
+	var Semaphore = class {
+		constructor(capacity = 1) {
+			if (capacity <= 0) throw new Error("Capacity must be greater than 0");
+			this._capacity = capacity;
+			this._active = 0;
+			this._waiting = [];
+		}
+		lock(thunk) {
+			return new Promise((resolve, reject) => {
+				this._waiting.push({
+					thunk,
+					resolve,
+					reject
+				});
+				this.runNext();
+			});
+		}
+		get active() {
+			return this._active;
+		}
+		runNext() {
+			if (this._waiting.length === 0 || this._active === this._capacity) return;
+			(0, ral_1.default)().timer.setImmediate(() => this.doRunNext());
+		}
+		doRunNext() {
+			if (this._waiting.length === 0 || this._active === this._capacity) return;
+			const next = this._waiting.shift();
+			this._active++;
+			if (this._active > this._capacity) throw new Error(`To many thunks active`);
+			try {
+				const result = next.thunk();
+				if (result instanceof Promise) result.then((value) => {
+					this._active--;
+					next.resolve(value);
+					this.runNext();
+				}, (err) => {
+					this._active--;
+					next.reject(err);
+					this.runNext();
+				});
+				else {
+					this._active--;
+					next.resolve(result);
+					this.runNext();
+				}
+			} catch (err) {
+				this._active--;
+				next.reject(err);
+				this.runNext();
+			}
+		}
+	};
+	exports.Semaphore = Semaphore;
+}));
+
+//#endregion
+//#region node_modules/.pnpm/vscode-jsonrpc@8.2.1/node_modules/vscode-jsonrpc/lib/common/messageReader.js
+var require_messageReader = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.ReadableStreamMessageReader = exports.AbstractMessageReader = exports.MessageReader = void 0;
+	const ral_1 = require_ral();
+	const Is = require_is();
+	const events_1 = require_events();
+	const semaphore_1 = require_semaphore();
+	var MessageReader;
+	(function(MessageReader) {
+		function is(value) {
+			let candidate = value;
+			return candidate && Is.func(candidate.listen) && Is.func(candidate.dispose) && Is.func(candidate.onError) && Is.func(candidate.onClose) && Is.func(candidate.onPartialMessage);
+		}
+		MessageReader.is = is;
+	})(MessageReader || (exports.MessageReader = MessageReader = {}));
+	var AbstractMessageReader = class {
+		constructor() {
+			this.errorEmitter = new events_1.Emitter();
+			this.closeEmitter = new events_1.Emitter();
+			this.partialMessageEmitter = new events_1.Emitter();
+		}
+		dispose() {
+			this.errorEmitter.dispose();
+			this.closeEmitter.dispose();
+		}
+		get onError() {
+			return this.errorEmitter.event;
+		}
+		fireError(error) {
+			this.errorEmitter.fire(this.asError(error));
+		}
+		get onClose() {
+			return this.closeEmitter.event;
+		}
+		fireClose() {
+			this.closeEmitter.fire(void 0);
+		}
+		get onPartialMessage() {
+			return this.partialMessageEmitter.event;
+		}
+		firePartialMessage(info) {
+			this.partialMessageEmitter.fire(info);
+		}
+		asError(error) {
+			if (error instanceof Error) return error;
+			else return /* @__PURE__ */ new Error(`Reader received error. Reason: ${Is.string(error.message) ? error.message : "unknown"}`);
+		}
+	};
+	exports.AbstractMessageReader = AbstractMessageReader;
+	var ResolvedMessageReaderOptions;
+	(function(ResolvedMessageReaderOptions) {
+		function fromOptions(options) {
+			let charset;
+			let contentDecoder;
+			const contentDecoders = /* @__PURE__ */ new Map();
+			let contentTypeDecoder;
+			const contentTypeDecoders = /* @__PURE__ */ new Map();
+			if (options === void 0 || typeof options === "string") charset = options ?? "utf-8";
+			else {
+				charset = options.charset ?? "utf-8";
+				if (options.contentDecoder !== void 0) {
+					contentDecoder = options.contentDecoder;
+					contentDecoders.set(contentDecoder.name, contentDecoder);
+				}
+				if (options.contentDecoders !== void 0) for (const decoder of options.contentDecoders) contentDecoders.set(decoder.name, decoder);
+				if (options.contentTypeDecoder !== void 0) {
+					contentTypeDecoder = options.contentTypeDecoder;
+					contentTypeDecoders.set(contentTypeDecoder.name, contentTypeDecoder);
+				}
+				if (options.contentTypeDecoders !== void 0) for (const decoder of options.contentTypeDecoders) contentTypeDecoders.set(decoder.name, decoder);
+			}
+			if (contentTypeDecoder === void 0) {
+				contentTypeDecoder = (0, ral_1.default)().applicationJson.decoder;
+				contentTypeDecoders.set(contentTypeDecoder.name, contentTypeDecoder);
+			}
+			return {
+				charset,
+				contentDecoder,
+				contentDecoders,
+				contentTypeDecoder,
+				contentTypeDecoders
+			};
+		}
+		ResolvedMessageReaderOptions.fromOptions = fromOptions;
+	})(ResolvedMessageReaderOptions || (ResolvedMessageReaderOptions = {}));
+	var ReadableStreamMessageReader = class extends AbstractMessageReader {
+		constructor(readable, options) {
+			super();
+			this.readable = readable;
+			this.options = ResolvedMessageReaderOptions.fromOptions(options);
+			this.buffer = (0, ral_1.default)().messageBuffer.create(this.options.charset);
+			this._partialMessageTimeout = 1e4;
+			this.nextMessageLength = -1;
+			this.messageToken = 0;
+			this.readSemaphore = new semaphore_1.Semaphore(1);
+		}
+		set partialMessageTimeout(timeout) {
+			this._partialMessageTimeout = timeout;
+		}
+		get partialMessageTimeout() {
+			return this._partialMessageTimeout;
+		}
+		listen(callback) {
+			this.nextMessageLength = -1;
+			this.messageToken = 0;
+			this.partialMessageTimer = void 0;
+			this.callback = callback;
+			const result = this.readable.onData((data) => {
+				this.onData(data);
+			});
+			this.readable.onError((error) => this.fireError(error));
+			this.readable.onClose(() => this.fireClose());
+			return result;
+		}
+		onData(data) {
+			try {
+				this.buffer.append(data);
+				while (true) {
+					if (this.nextMessageLength === -1) {
+						const headers = this.buffer.tryReadHeaders(true);
+						if (!headers) return;
+						const contentLength = headers.get("content-length");
+						if (!contentLength) {
+							this.fireError(/* @__PURE__ */ new Error(`Header must provide a Content-Length property.\n${JSON.stringify(Object.fromEntries(headers))}`));
+							return;
+						}
+						const length = parseInt(contentLength);
+						if (isNaN(length)) {
+							this.fireError(/* @__PURE__ */ new Error(`Content-Length value must be a number. Got ${contentLength}`));
+							return;
+						}
+						this.nextMessageLength = length;
+					}
+					const body = this.buffer.tryReadBody(this.nextMessageLength);
+					if (body === void 0) {
+						/** We haven't received the full message yet. */
+						this.setPartialMessageTimer();
+						return;
+					}
+					this.clearPartialMessageTimer();
+					this.nextMessageLength = -1;
+					this.readSemaphore.lock(async () => {
+						const bytes = this.options.contentDecoder !== void 0 ? await this.options.contentDecoder.decode(body) : body;
+						const message = await this.options.contentTypeDecoder.decode(bytes, this.options);
+						this.callback(message);
+					}).catch((error) => {
+						this.fireError(error);
+					});
+				}
+			} catch (error) {
+				this.fireError(error);
+			}
+		}
+		clearPartialMessageTimer() {
+			if (this.partialMessageTimer) {
+				this.partialMessageTimer.dispose();
+				this.partialMessageTimer = void 0;
+			}
+		}
+		setPartialMessageTimer() {
+			this.clearPartialMessageTimer();
+			if (this._partialMessageTimeout <= 0) return;
+			this.partialMessageTimer = (0, ral_1.default)().timer.setTimeout((token, timeout) => {
+				this.partialMessageTimer = void 0;
+				if (token === this.messageToken) {
+					this.firePartialMessage({
+						messageToken: token,
+						waitingTime: timeout
+					});
+					this.setPartialMessageTimer();
+				}
+			}, this._partialMessageTimeout, this.messageToken, this._partialMessageTimeout);
+		}
+	};
+	exports.ReadableStreamMessageReader = ReadableStreamMessageReader;
+}));
+
+//#endregion
+//#region node_modules/.pnpm/vscode-jsonrpc@8.2.1/node_modules/vscode-jsonrpc/lib/common/messageWriter.js
+var require_messageWriter = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.WriteableStreamMessageWriter = exports.AbstractMessageWriter = exports.MessageWriter = void 0;
+	const ral_1 = require_ral();
+	const Is = require_is();
+	const semaphore_1 = require_semaphore();
+	const events_1 = require_events();
+	const ContentLength = "Content-Length: ";
+	const CRLF = "\r\n";
+	var MessageWriter;
+	(function(MessageWriter) {
+		function is(value) {
+			let candidate = value;
+			return candidate && Is.func(candidate.dispose) && Is.func(candidate.onClose) && Is.func(candidate.onError) && Is.func(candidate.write);
+		}
+		MessageWriter.is = is;
+	})(MessageWriter || (exports.MessageWriter = MessageWriter = {}));
+	var AbstractMessageWriter = class {
+		constructor() {
+			this.errorEmitter = new events_1.Emitter();
+			this.closeEmitter = new events_1.Emitter();
+		}
+		dispose() {
+			this.errorEmitter.dispose();
+			this.closeEmitter.dispose();
+		}
+		get onError() {
+			return this.errorEmitter.event;
+		}
+		fireError(error, message, count) {
+			this.errorEmitter.fire([
+				this.asError(error),
+				message,
+				count
+			]);
+		}
+		get onClose() {
+			return this.closeEmitter.event;
+		}
+		fireClose() {
+			this.closeEmitter.fire(void 0);
+		}
+		asError(error) {
+			if (error instanceof Error) return error;
+			else return /* @__PURE__ */ new Error(`Writer received error. Reason: ${Is.string(error.message) ? error.message : "unknown"}`);
+		}
+	};
+	exports.AbstractMessageWriter = AbstractMessageWriter;
+	var ResolvedMessageWriterOptions;
+	(function(ResolvedMessageWriterOptions) {
+		function fromOptions(options) {
+			if (options === void 0 || typeof options === "string") return {
+				charset: options ?? "utf-8",
+				contentTypeEncoder: (0, ral_1.default)().applicationJson.encoder
+			};
+			else return {
+				charset: options.charset ?? "utf-8",
+				contentEncoder: options.contentEncoder,
+				contentTypeEncoder: options.contentTypeEncoder ?? (0, ral_1.default)().applicationJson.encoder
+			};
+		}
+		ResolvedMessageWriterOptions.fromOptions = fromOptions;
+	})(ResolvedMessageWriterOptions || (ResolvedMessageWriterOptions = {}));
+	var WriteableStreamMessageWriter = class extends AbstractMessageWriter {
+		constructor(writable, options) {
+			super();
+			this.writable = writable;
+			this.options = ResolvedMessageWriterOptions.fromOptions(options);
+			this.errorCount = 0;
+			this.writeSemaphore = new semaphore_1.Semaphore(1);
+			this.writable.onError((error) => this.fireError(error));
+			this.writable.onClose(() => this.fireClose());
+		}
+		async write(msg) {
+			return this.writeSemaphore.lock(async () => {
+				return this.options.contentTypeEncoder.encode(msg, this.options).then((buffer) => {
+					if (this.options.contentEncoder !== void 0) return this.options.contentEncoder.encode(buffer);
+					else return buffer;
+				}).then((buffer) => {
+					const headers = [];
+					headers.push(ContentLength, buffer.byteLength.toString(), CRLF);
+					headers.push(CRLF);
+					return this.doWrite(msg, headers, buffer);
+				}, (error) => {
+					this.fireError(error);
+					throw error;
+				});
+			});
+		}
+		async doWrite(msg, headers, data) {
+			try {
+				await this.writable.write(headers.join(""), "ascii");
+				return this.writable.write(data);
+			} catch (error) {
+				this.handleError(error, msg);
+				return Promise.reject(error);
+			}
+		}
+		handleError(error, msg) {
+			this.errorCount++;
+			this.fireError(error, msg, this.errorCount);
+		}
+		end() {
+			this.writable.end();
+		}
+	};
+	exports.WriteableStreamMessageWriter = WriteableStreamMessageWriter;
+}));
+
+//#endregion
+//#region node_modules/.pnpm/vscode-jsonrpc@8.2.1/node_modules/vscode-jsonrpc/lib/common/messageBuffer.js
+var require_messageBuffer = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.AbstractMessageBuffer = void 0;
+	const CR = 13;
+	const LF = 10;
+	const CRLF = "\r\n";
+	var AbstractMessageBuffer = class {
+		constructor(encoding = "utf-8") {
+			this._encoding = encoding;
+			this._chunks = [];
+			this._totalLength = 0;
+		}
+		get encoding() {
+			return this._encoding;
+		}
+		append(chunk) {
+			const toAppend = typeof chunk === "string" ? this.fromString(chunk, this._encoding) : chunk;
+			this._chunks.push(toAppend);
+			this._totalLength += toAppend.byteLength;
+		}
+		tryReadHeaders(lowerCaseKeys = false) {
+			if (this._chunks.length === 0) return;
+			let state = 0;
+			let chunkIndex = 0;
+			let offset = 0;
+			let chunkBytesRead = 0;
+			row: while (chunkIndex < this._chunks.length) {
+				const chunk = this._chunks[chunkIndex];
+				offset = 0;
+				column: while (offset < chunk.length) {
+					switch (chunk[offset]) {
+						case CR:
+							switch (state) {
+								case 0:
+									state = 1;
+									break;
+								case 2:
+									state = 3;
+									break;
+								default: state = 0;
+							}
+							break;
+						case LF:
+							switch (state) {
+								case 1:
+									state = 2;
+									break;
+								case 3:
+									state = 4;
+									offset++;
+									break row;
+								default: state = 0;
+							}
+							break;
+						default: state = 0;
+					}
+					offset++;
+				}
+				chunkBytesRead += chunk.byteLength;
+				chunkIndex++;
+			}
+			if (state !== 4) return;
+			const buffer = this._read(chunkBytesRead + offset);
+			const result = /* @__PURE__ */ new Map();
+			const headers = this.toString(buffer, "ascii").split(CRLF);
+			if (headers.length < 2) return result;
+			for (let i = 0; i < headers.length - 2; i++) {
+				const header = headers[i];
+				const index = header.indexOf(":");
+				if (index === -1) throw new Error(`Message header must separate key and value using ':'\n${header}`);
+				const key = header.substr(0, index);
+				const value = header.substr(index + 1).trim();
+				result.set(lowerCaseKeys ? key.toLowerCase() : key, value);
+			}
+			return result;
+		}
+		tryReadBody(length) {
+			if (this._totalLength < length) return;
+			return this._read(length);
+		}
+		get numberOfBytes() {
+			return this._totalLength;
+		}
+		_read(byteCount) {
+			if (byteCount === 0) return this.emptyBuffer();
+			if (byteCount > this._totalLength) throw new Error(`Cannot read so many bytes!`);
+			if (this._chunks[0].byteLength === byteCount) {
+				const chunk = this._chunks[0];
+				this._chunks.shift();
+				this._totalLength -= byteCount;
+				return this.asNative(chunk);
+			}
+			if (this._chunks[0].byteLength > byteCount) {
+				const chunk = this._chunks[0];
+				const result = this.asNative(chunk, byteCount);
+				this._chunks[0] = chunk.slice(byteCount);
+				this._totalLength -= byteCount;
+				return result;
+			}
+			const result = this.allocNative(byteCount);
+			let resultOffset = 0;
+			let chunkIndex = 0;
+			while (byteCount > 0) {
+				const chunk = this._chunks[chunkIndex];
+				if (chunk.byteLength > byteCount) {
+					const chunkPart = chunk.slice(0, byteCount);
+					result.set(chunkPart, resultOffset);
+					resultOffset += byteCount;
+					this._chunks[chunkIndex] = chunk.slice(byteCount);
+					this._totalLength -= byteCount;
+					byteCount -= byteCount;
+				} else {
+					result.set(chunk, resultOffset);
+					resultOffset += chunk.byteLength;
+					this._chunks.shift();
+					this._totalLength -= chunk.byteLength;
+					byteCount -= chunk.byteLength;
+				}
+			}
+			return result;
+		}
+	};
+	exports.AbstractMessageBuffer = AbstractMessageBuffer;
+}));
+
+//#endregion
+//#region node_modules/.pnpm/vscode-jsonrpc@8.2.1/node_modules/vscode-jsonrpc/lib/common/connection.js
+var require_connection = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.createMessageConnection = exports.ConnectionOptions = exports.MessageStrategy = exports.CancellationStrategy = exports.CancellationSenderStrategy = exports.CancellationReceiverStrategy = exports.RequestCancellationReceiverStrategy = exports.IdCancellationReceiverStrategy = exports.ConnectionStrategy = exports.ConnectionError = exports.ConnectionErrors = exports.LogTraceNotification = exports.SetTraceNotification = exports.TraceFormat = exports.TraceValues = exports.Trace = exports.NullLogger = exports.ProgressType = exports.ProgressToken = void 0;
+	const ral_1 = require_ral();
+	const Is = require_is();
+	const messages_1 = require_messages();
+	const linkedMap_1 = require_linkedMap();
+	const events_1 = require_events();
+	const cancellation_1 = require_cancellation();
+	var CancelNotification;
+	(function(CancelNotification) {
+		CancelNotification.type = new messages_1.NotificationType("$/cancelRequest");
+	})(CancelNotification || (CancelNotification = {}));
+	var ProgressToken;
+	(function(ProgressToken) {
+		function is(value) {
+			return typeof value === "string" || typeof value === "number";
+		}
+		ProgressToken.is = is;
+	})(ProgressToken || (exports.ProgressToken = ProgressToken = {}));
+	var ProgressNotification;
+	(function(ProgressNotification) {
+		ProgressNotification.type = new messages_1.NotificationType("$/progress");
+	})(ProgressNotification || (ProgressNotification = {}));
+	var ProgressType = class {
+		constructor() {}
+	};
+	exports.ProgressType = ProgressType;
+	var StarRequestHandler;
+	(function(StarRequestHandler) {
+		function is(value) {
+			return Is.func(value);
+		}
+		StarRequestHandler.is = is;
+	})(StarRequestHandler || (StarRequestHandler = {}));
+	exports.NullLogger = Object.freeze({
+		error: () => {},
+		warn: () => {},
+		info: () => {},
+		log: () => {}
+	});
+	var Trace;
+	(function(Trace) {
+		Trace[Trace["Off"] = 0] = "Off";
+		Trace[Trace["Messages"] = 1] = "Messages";
+		Trace[Trace["Compact"] = 2] = "Compact";
+		Trace[Trace["Verbose"] = 3] = "Verbose";
+	})(Trace || (exports.Trace = Trace = {}));
+	var TraceValues;
+	(function(TraceValues) {
+		/**
+		* Turn tracing off.
+		*/
+		TraceValues.Off = "off";
+		/**
+		* Trace messages only.
+		*/
+		TraceValues.Messages = "messages";
+		/**
+		* Compact message tracing.
+		*/
+		TraceValues.Compact = "compact";
+		/**
+		* Verbose message tracing.
+		*/
+		TraceValues.Verbose = "verbose";
+	})(TraceValues || (exports.TraceValues = TraceValues = {}));
+	(function(Trace) {
+		function fromString(value) {
+			if (!Is.string(value)) return Trace.Off;
+			value = value.toLowerCase();
+			switch (value) {
+				case "off": return Trace.Off;
+				case "messages": return Trace.Messages;
+				case "compact": return Trace.Compact;
+				case "verbose": return Trace.Verbose;
+				default: return Trace.Off;
+			}
+		}
+		Trace.fromString = fromString;
+		function toString(value) {
+			switch (value) {
+				case Trace.Off: return "off";
+				case Trace.Messages: return "messages";
+				case Trace.Compact: return "compact";
+				case Trace.Verbose: return "verbose";
+				default: return "off";
+			}
+		}
+		Trace.toString = toString;
+	})(Trace || (exports.Trace = Trace = {}));
+	var TraceFormat;
+	(function(TraceFormat) {
+		TraceFormat["Text"] = "text";
+		TraceFormat["JSON"] = "json";
+	})(TraceFormat || (exports.TraceFormat = TraceFormat = {}));
+	(function(TraceFormat) {
+		function fromString(value) {
+			if (!Is.string(value)) return TraceFormat.Text;
+			value = value.toLowerCase();
+			if (value === "json") return TraceFormat.JSON;
+			else return TraceFormat.Text;
+		}
+		TraceFormat.fromString = fromString;
+	})(TraceFormat || (exports.TraceFormat = TraceFormat = {}));
+	var SetTraceNotification;
+	(function(SetTraceNotification) {
+		SetTraceNotification.type = new messages_1.NotificationType("$/setTrace");
+	})(SetTraceNotification || (exports.SetTraceNotification = SetTraceNotification = {}));
+	var LogTraceNotification;
+	(function(LogTraceNotification) {
+		LogTraceNotification.type = new messages_1.NotificationType("$/logTrace");
+	})(LogTraceNotification || (exports.LogTraceNotification = LogTraceNotification = {}));
+	var ConnectionErrors;
+	(function(ConnectionErrors) {
+		/**
+		* The connection is closed.
+		*/
+		ConnectionErrors[ConnectionErrors["Closed"] = 1] = "Closed";
+		/**
+		* The connection got disposed.
+		*/
+		ConnectionErrors[ConnectionErrors["Disposed"] = 2] = "Disposed";
+		/**
+		* The connection is already in listening mode.
+		*/
+		ConnectionErrors[ConnectionErrors["AlreadyListening"] = 3] = "AlreadyListening";
+	})(ConnectionErrors || (exports.ConnectionErrors = ConnectionErrors = {}));
+	var ConnectionError = class ConnectionError extends Error {
+		constructor(code, message) {
+			super(message);
+			this.code = code;
+			Object.setPrototypeOf(this, ConnectionError.prototype);
+		}
+	};
+	exports.ConnectionError = ConnectionError;
+	var ConnectionStrategy;
+	(function(ConnectionStrategy) {
+		function is(value) {
+			const candidate = value;
+			return candidate && Is.func(candidate.cancelUndispatched);
+		}
+		ConnectionStrategy.is = is;
+	})(ConnectionStrategy || (exports.ConnectionStrategy = ConnectionStrategy = {}));
+	var IdCancellationReceiverStrategy;
+	(function(IdCancellationReceiverStrategy) {
+		function is(value) {
+			const candidate = value;
+			return candidate && (candidate.kind === void 0 || candidate.kind === "id") && Is.func(candidate.createCancellationTokenSource) && (candidate.dispose === void 0 || Is.func(candidate.dispose));
+		}
+		IdCancellationReceiverStrategy.is = is;
+	})(IdCancellationReceiverStrategy || (exports.IdCancellationReceiverStrategy = IdCancellationReceiverStrategy = {}));
+	var RequestCancellationReceiverStrategy;
+	(function(RequestCancellationReceiverStrategy) {
+		function is(value) {
+			const candidate = value;
+			return candidate && candidate.kind === "request" && Is.func(candidate.createCancellationTokenSource) && (candidate.dispose === void 0 || Is.func(candidate.dispose));
+		}
+		RequestCancellationReceiverStrategy.is = is;
+	})(RequestCancellationReceiverStrategy || (exports.RequestCancellationReceiverStrategy = RequestCancellationReceiverStrategy = {}));
+	var CancellationReceiverStrategy;
+	(function(CancellationReceiverStrategy) {
+		CancellationReceiverStrategy.Message = Object.freeze({ createCancellationTokenSource(_) {
+			return new cancellation_1.CancellationTokenSource();
+		} });
+		function is(value) {
+			return IdCancellationReceiverStrategy.is(value) || RequestCancellationReceiverStrategy.is(value);
+		}
+		CancellationReceiverStrategy.is = is;
+	})(CancellationReceiverStrategy || (exports.CancellationReceiverStrategy = CancellationReceiverStrategy = {}));
+	var CancellationSenderStrategy;
+	(function(CancellationSenderStrategy) {
+		CancellationSenderStrategy.Message = Object.freeze({
+			sendCancellation(conn, id) {
+				return conn.sendNotification(CancelNotification.type, { id });
+			},
+			cleanup(_) {}
+		});
+		function is(value) {
+			const candidate = value;
+			return candidate && Is.func(candidate.sendCancellation) && Is.func(candidate.cleanup);
+		}
+		CancellationSenderStrategy.is = is;
+	})(CancellationSenderStrategy || (exports.CancellationSenderStrategy = CancellationSenderStrategy = {}));
+	var CancellationStrategy;
+	(function(CancellationStrategy) {
+		CancellationStrategy.Message = Object.freeze({
+			receiver: CancellationReceiverStrategy.Message,
+			sender: CancellationSenderStrategy.Message
+		});
+		function is(value) {
+			const candidate = value;
+			return candidate && CancellationReceiverStrategy.is(candidate.receiver) && CancellationSenderStrategy.is(candidate.sender);
+		}
+		CancellationStrategy.is = is;
+	})(CancellationStrategy || (exports.CancellationStrategy = CancellationStrategy = {}));
+	var MessageStrategy;
+	(function(MessageStrategy) {
+		function is(value) {
+			const candidate = value;
+			return candidate && Is.func(candidate.handleMessage);
+		}
+		MessageStrategy.is = is;
+	})(MessageStrategy || (exports.MessageStrategy = MessageStrategy = {}));
+	var ConnectionOptions;
+	(function(ConnectionOptions) {
+		function is(value) {
+			const candidate = value;
+			return candidate && (CancellationStrategy.is(candidate.cancellationStrategy) || ConnectionStrategy.is(candidate.connectionStrategy) || MessageStrategy.is(candidate.messageStrategy));
+		}
+		ConnectionOptions.is = is;
+	})(ConnectionOptions || (exports.ConnectionOptions = ConnectionOptions = {}));
+	var ConnectionState;
+	(function(ConnectionState) {
+		ConnectionState[ConnectionState["New"] = 1] = "New";
+		ConnectionState[ConnectionState["Listening"] = 2] = "Listening";
+		ConnectionState[ConnectionState["Closed"] = 3] = "Closed";
+		ConnectionState[ConnectionState["Disposed"] = 4] = "Disposed";
+	})(ConnectionState || (ConnectionState = {}));
+	function createMessageConnection(messageReader, messageWriter, _logger, options) {
+		const logger = _logger !== void 0 ? _logger : exports.NullLogger;
+		let sequenceNumber = 0;
+		let notificationSequenceNumber = 0;
+		let unknownResponseSequenceNumber = 0;
+		const version = "2.0";
+		let starRequestHandler = void 0;
+		const requestHandlers = /* @__PURE__ */ new Map();
+		let starNotificationHandler = void 0;
+		const notificationHandlers = /* @__PURE__ */ new Map();
+		const progressHandlers = /* @__PURE__ */ new Map();
+		let timer;
+		let messageQueue = new linkedMap_1.LinkedMap();
+		let responsePromises = /* @__PURE__ */ new Map();
+		let knownCanceledRequests = /* @__PURE__ */ new Set();
+		let requestTokens = /* @__PURE__ */ new Map();
+		let trace = Trace.Off;
+		let traceFormat = TraceFormat.Text;
+		let tracer;
+		let state = ConnectionState.New;
+		const errorEmitter = new events_1.Emitter();
+		const closeEmitter = new events_1.Emitter();
+		const unhandledNotificationEmitter = new events_1.Emitter();
+		const unhandledProgressEmitter = new events_1.Emitter();
+		const disposeEmitter = new events_1.Emitter();
+		const cancellationStrategy = options && options.cancellationStrategy ? options.cancellationStrategy : CancellationStrategy.Message;
+		function createRequestQueueKey(id) {
+			if (id === null) throw new Error(`Can't send requests with id null since the response can't be correlated.`);
+			return "req-" + id.toString();
+		}
+		function createResponseQueueKey(id) {
+			if (id === null) return "res-unknown-" + (++unknownResponseSequenceNumber).toString();
+			else return "res-" + id.toString();
+		}
+		function createNotificationQueueKey() {
+			return "not-" + (++notificationSequenceNumber).toString();
+		}
+		function addMessageToQueue(queue, message) {
+			if (messages_1.Message.isRequest(message)) queue.set(createRequestQueueKey(message.id), message);
+			else if (messages_1.Message.isResponse(message)) queue.set(createResponseQueueKey(message.id), message);
+			else queue.set(createNotificationQueueKey(), message);
+		}
+		function cancelUndispatched(_message) {}
+		function isListening() {
+			return state === ConnectionState.Listening;
+		}
+		function isClosed() {
+			return state === ConnectionState.Closed;
+		}
+		function isDisposed() {
+			return state === ConnectionState.Disposed;
+		}
+		function closeHandler() {
+			if (state === ConnectionState.New || state === ConnectionState.Listening) {
+				state = ConnectionState.Closed;
+				closeEmitter.fire(void 0);
+			}
+		}
+		function readErrorHandler(error) {
+			errorEmitter.fire([
+				error,
+				void 0,
+				void 0
+			]);
+		}
+		function writeErrorHandler(data) {
+			errorEmitter.fire(data);
+		}
+		messageReader.onClose(closeHandler);
+		messageReader.onError(readErrorHandler);
+		messageWriter.onClose(closeHandler);
+		messageWriter.onError(writeErrorHandler);
+		function triggerMessageQueue() {
+			if (timer || messageQueue.size === 0) return;
+			timer = (0, ral_1.default)().timer.setImmediate(() => {
+				timer = void 0;
+				processMessageQueue();
+			});
+		}
+		function handleMessage(message) {
+			if (messages_1.Message.isRequest(message)) handleRequest(message);
+			else if (messages_1.Message.isNotification(message)) handleNotification(message);
+			else if (messages_1.Message.isResponse(message)) handleResponse(message);
+			else handleInvalidMessage(message);
+		}
+		function processMessageQueue() {
+			if (messageQueue.size === 0) return;
+			const message = messageQueue.shift();
+			try {
+				const messageStrategy = options?.messageStrategy;
+				if (MessageStrategy.is(messageStrategy)) messageStrategy.handleMessage(message, handleMessage);
+				else handleMessage(message);
+			} finally {
+				triggerMessageQueue();
+			}
+		}
+		const callback = (message) => {
+			try {
+				if (messages_1.Message.isNotification(message) && message.method === CancelNotification.type.method) {
+					const cancelId = message.params.id;
+					const key = createRequestQueueKey(cancelId);
+					const toCancel = messageQueue.get(key);
+					if (messages_1.Message.isRequest(toCancel)) {
+						const strategy = options?.connectionStrategy;
+						const response = strategy && strategy.cancelUndispatched ? strategy.cancelUndispatched(toCancel, cancelUndispatched) : cancelUndispatched(toCancel);
+						if (response && (response.error !== void 0 || response.result !== void 0)) {
+							messageQueue.delete(key);
+							requestTokens.delete(cancelId);
+							response.id = toCancel.id;
+							traceSendingResponse(response, message.method, Date.now());
+							messageWriter.write(response).catch(() => logger.error(`Sending response for canceled message failed.`));
+							return;
+						}
+					}
+					const cancellationToken = requestTokens.get(cancelId);
+					if (cancellationToken !== void 0) {
+						cancellationToken.cancel();
+						traceReceivedNotification(message);
+						return;
+					} else knownCanceledRequests.add(cancelId);
+				}
+				addMessageToQueue(messageQueue, message);
+			} finally {
+				triggerMessageQueue();
+			}
+		};
+		function handleRequest(requestMessage) {
+			if (isDisposed()) return;
+			function reply(resultOrError, method, startTime) {
+				const message = {
+					jsonrpc: version,
+					id: requestMessage.id
+				};
+				if (resultOrError instanceof messages_1.ResponseError) message.error = resultOrError.toJson();
+				else message.result = resultOrError === void 0 ? null : resultOrError;
+				traceSendingResponse(message, method, startTime);
+				messageWriter.write(message).catch(() => logger.error(`Sending response failed.`));
+			}
+			function replyError(error, method, startTime) {
+				const message = {
+					jsonrpc: version,
+					id: requestMessage.id,
+					error: error.toJson()
+				};
+				traceSendingResponse(message, method, startTime);
+				messageWriter.write(message).catch(() => logger.error(`Sending response failed.`));
+			}
+			function replySuccess(result, method, startTime) {
+				if (result === void 0) result = null;
+				const message = {
+					jsonrpc: version,
+					id: requestMessage.id,
+					result
+				};
+				traceSendingResponse(message, method, startTime);
+				messageWriter.write(message).catch(() => logger.error(`Sending response failed.`));
+			}
+			traceReceivedRequest(requestMessage);
+			const element = requestHandlers.get(requestMessage.method);
+			let type;
+			let requestHandler;
+			if (element) {
+				type = element.type;
+				requestHandler = element.handler;
+			}
+			const startTime = Date.now();
+			if (requestHandler || starRequestHandler) {
+				const tokenKey = requestMessage.id ?? String(Date.now());
+				const cancellationSource = IdCancellationReceiverStrategy.is(cancellationStrategy.receiver) ? cancellationStrategy.receiver.createCancellationTokenSource(tokenKey) : cancellationStrategy.receiver.createCancellationTokenSource(requestMessage);
+				if (requestMessage.id !== null && knownCanceledRequests.has(requestMessage.id)) cancellationSource.cancel();
+				if (requestMessage.id !== null) requestTokens.set(tokenKey, cancellationSource);
+				try {
+					let handlerResult;
+					if (requestHandler) if (requestMessage.params === void 0) {
+						if (type !== void 0 && type.numberOfParams !== 0) {
+							replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InvalidParams, `Request ${requestMessage.method} defines ${type.numberOfParams} params but received none.`), requestMessage.method, startTime);
+							return;
+						}
+						handlerResult = requestHandler(cancellationSource.token);
+					} else if (Array.isArray(requestMessage.params)) {
+						if (type !== void 0 && type.parameterStructures === messages_1.ParameterStructures.byName) {
+							replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InvalidParams, `Request ${requestMessage.method} defines parameters by name but received parameters by position`), requestMessage.method, startTime);
+							return;
+						}
+						handlerResult = requestHandler(...requestMessage.params, cancellationSource.token);
+					} else {
+						if (type !== void 0 && type.parameterStructures === messages_1.ParameterStructures.byPosition) {
+							replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InvalidParams, `Request ${requestMessage.method} defines parameters by position but received parameters by name`), requestMessage.method, startTime);
+							return;
+						}
+						handlerResult = requestHandler(requestMessage.params, cancellationSource.token);
+					}
+					else if (starRequestHandler) handlerResult = starRequestHandler(requestMessage.method, requestMessage.params, cancellationSource.token);
+					const promise = handlerResult;
+					if (!handlerResult) {
+						requestTokens.delete(tokenKey);
+						replySuccess(handlerResult, requestMessage.method, startTime);
+					} else if (promise.then) promise.then((resultOrError) => {
+						requestTokens.delete(tokenKey);
+						reply(resultOrError, requestMessage.method, startTime);
+					}, (error) => {
+						requestTokens.delete(tokenKey);
+						if (error instanceof messages_1.ResponseError) replyError(error, requestMessage.method, startTime);
+						else if (error && Is.string(error.message)) replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InternalError, `Request ${requestMessage.method} failed with message: ${error.message}`), requestMessage.method, startTime);
+						else replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InternalError, `Request ${requestMessage.method} failed unexpectedly without providing any details.`), requestMessage.method, startTime);
+					});
+					else {
+						requestTokens.delete(tokenKey);
+						reply(handlerResult, requestMessage.method, startTime);
+					}
+				} catch (error) {
+					requestTokens.delete(tokenKey);
+					if (error instanceof messages_1.ResponseError) reply(error, requestMessage.method, startTime);
+					else if (error && Is.string(error.message)) replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InternalError, `Request ${requestMessage.method} failed with message: ${error.message}`), requestMessage.method, startTime);
+					else replyError(new messages_1.ResponseError(messages_1.ErrorCodes.InternalError, `Request ${requestMessage.method} failed unexpectedly without providing any details.`), requestMessage.method, startTime);
+				}
+			} else replyError(new messages_1.ResponseError(messages_1.ErrorCodes.MethodNotFound, `Unhandled method ${requestMessage.method}`), requestMessage.method, startTime);
+		}
+		function handleResponse(responseMessage) {
+			if (isDisposed()) return;
+			if (responseMessage.id === null) if (responseMessage.error) logger.error(`Received response message without id: Error is: \n${JSON.stringify(responseMessage.error, void 0, 4)}`);
+			else logger.error(`Received response message without id. No further error information provided.`);
+			else {
+				const key = responseMessage.id;
+				const responsePromise = responsePromises.get(key);
+				traceReceivedResponse(responseMessage, responsePromise);
+				if (responsePromise !== void 0) {
+					responsePromises.delete(key);
+					try {
+						if (responseMessage.error) {
+							const error = responseMessage.error;
+							responsePromise.reject(new messages_1.ResponseError(error.code, error.message, error.data));
+						} else if (responseMessage.result !== void 0) responsePromise.resolve(responseMessage.result);
+						else throw new Error("Should never happen.");
+					} catch (error) {
+						if (error.message) logger.error(`Response handler '${responsePromise.method}' failed with message: ${error.message}`);
+						else logger.error(`Response handler '${responsePromise.method}' failed unexpectedly.`);
+					}
+				}
+			}
+		}
+		function handleNotification(message) {
+			if (isDisposed()) return;
+			let type = void 0;
+			let notificationHandler;
+			if (message.method === CancelNotification.type.method) {
+				const cancelId = message.params.id;
+				knownCanceledRequests.delete(cancelId);
+				traceReceivedNotification(message);
+				return;
+			} else {
+				const element = notificationHandlers.get(message.method);
+				if (element) {
+					notificationHandler = element.handler;
+					type = element.type;
+				}
+			}
+			if (notificationHandler || starNotificationHandler) try {
+				traceReceivedNotification(message);
+				if (notificationHandler) if (message.params === void 0) {
+					if (type !== void 0) {
+						if (type.numberOfParams !== 0 && type.parameterStructures !== messages_1.ParameterStructures.byName) logger.error(`Notification ${message.method} defines ${type.numberOfParams} params but received none.`);
+					}
+					notificationHandler();
+				} else if (Array.isArray(message.params)) {
+					const params = message.params;
+					if (message.method === ProgressNotification.type.method && params.length === 2 && ProgressToken.is(params[0])) notificationHandler({
+						token: params[0],
+						value: params[1]
+					});
+					else {
+						if (type !== void 0) {
+							if (type.parameterStructures === messages_1.ParameterStructures.byName) logger.error(`Notification ${message.method} defines parameters by name but received parameters by position`);
+							if (type.numberOfParams !== message.params.length) logger.error(`Notification ${message.method} defines ${type.numberOfParams} params but received ${params.length} arguments`);
+						}
+						notificationHandler(...params);
+					}
+				} else {
+					if (type !== void 0 && type.parameterStructures === messages_1.ParameterStructures.byPosition) logger.error(`Notification ${message.method} defines parameters by position but received parameters by name`);
+					notificationHandler(message.params);
+				}
+				else if (starNotificationHandler) starNotificationHandler(message.method, message.params);
+			} catch (error) {
+				if (error.message) logger.error(`Notification handler '${message.method}' failed with message: ${error.message}`);
+				else logger.error(`Notification handler '${message.method}' failed unexpectedly.`);
+			}
+			else unhandledNotificationEmitter.fire(message);
+		}
+		function handleInvalidMessage(message) {
+			if (!message) {
+				logger.error("Received empty message.");
+				return;
+			}
+			logger.error(`Received message which is neither a response nor a notification message:\n${JSON.stringify(message, null, 4)}`);
+			const responseMessage = message;
+			if (Is.string(responseMessage.id) || Is.number(responseMessage.id)) {
+				const key = responseMessage.id;
+				const responseHandler = responsePromises.get(key);
+				if (responseHandler) responseHandler.reject(/* @__PURE__ */ new Error("The received response has neither a result nor an error property."));
+			}
+		}
+		function stringifyTrace(params) {
+			if (params === void 0 || params === null) return;
+			switch (trace) {
+				case Trace.Verbose: return JSON.stringify(params, null, 4);
+				case Trace.Compact: return JSON.stringify(params);
+				default: return;
+			}
+		}
+		function traceSendingRequest(message) {
+			if (trace === Trace.Off || !tracer) return;
+			if (traceFormat === TraceFormat.Text) {
+				let data = void 0;
+				if ((trace === Trace.Verbose || trace === Trace.Compact) && message.params) data = `Params: ${stringifyTrace(message.params)}\n\n`;
+				tracer.log(`Sending request '${message.method} - (${message.id})'.`, data);
+			} else logLSPMessage("send-request", message);
+		}
+		function traceSendingNotification(message) {
+			if (trace === Trace.Off || !tracer) return;
+			if (traceFormat === TraceFormat.Text) {
+				let data = void 0;
+				if (trace === Trace.Verbose || trace === Trace.Compact) if (message.params) data = `Params: ${stringifyTrace(message.params)}\n\n`;
+				else data = "No parameters provided.\n\n";
+				tracer.log(`Sending notification '${message.method}'.`, data);
+			} else logLSPMessage("send-notification", message);
+		}
+		function traceSendingResponse(message, method, startTime) {
+			if (trace === Trace.Off || !tracer) return;
+			if (traceFormat === TraceFormat.Text) {
+				let data = void 0;
+				if (trace === Trace.Verbose || trace === Trace.Compact) {
+					if (message.error && message.error.data) data = `Error data: ${stringifyTrace(message.error.data)}\n\n`;
+					else if (message.result) data = `Result: ${stringifyTrace(message.result)}\n\n`;
+					else if (message.error === void 0) data = "No result returned.\n\n";
+				}
+				tracer.log(`Sending response '${method} - (${message.id})'. Processing request took ${Date.now() - startTime}ms`, data);
+			} else logLSPMessage("send-response", message);
+		}
+		function traceReceivedRequest(message) {
+			if (trace === Trace.Off || !tracer) return;
+			if (traceFormat === TraceFormat.Text) {
+				let data = void 0;
+				if ((trace === Trace.Verbose || trace === Trace.Compact) && message.params) data = `Params: ${stringifyTrace(message.params)}\n\n`;
+				tracer.log(`Received request '${message.method} - (${message.id})'.`, data);
+			} else logLSPMessage("receive-request", message);
+		}
+		function traceReceivedNotification(message) {
+			if (trace === Trace.Off || !tracer || message.method === LogTraceNotification.type.method) return;
+			if (traceFormat === TraceFormat.Text) {
+				let data = void 0;
+				if (trace === Trace.Verbose || trace === Trace.Compact) if (message.params) data = `Params: ${stringifyTrace(message.params)}\n\n`;
+				else data = "No parameters provided.\n\n";
+				tracer.log(`Received notification '${message.method}'.`, data);
+			} else logLSPMessage("receive-notification", message);
+		}
+		function traceReceivedResponse(message, responsePromise) {
+			if (trace === Trace.Off || !tracer) return;
+			if (traceFormat === TraceFormat.Text) {
+				let data = void 0;
+				if (trace === Trace.Verbose || trace === Trace.Compact) {
+					if (message.error && message.error.data) data = `Error data: ${stringifyTrace(message.error.data)}\n\n`;
+					else if (message.result) data = `Result: ${stringifyTrace(message.result)}\n\n`;
+					else if (message.error === void 0) data = "No result returned.\n\n";
+				}
+				if (responsePromise) {
+					const error = message.error ? ` Request failed: ${message.error.message} (${message.error.code}).` : "";
+					tracer.log(`Received response '${responsePromise.method} - (${message.id})' in ${Date.now() - responsePromise.timerStart}ms.${error}`, data);
+				} else tracer.log(`Received response ${message.id} without active response promise.`, data);
+			} else logLSPMessage("receive-response", message);
+		}
+		function logLSPMessage(type, message) {
+			if (!tracer || trace === Trace.Off) return;
+			const lspMessage = {
+				isLSPMessage: true,
+				type,
+				message,
+				timestamp: Date.now()
+			};
+			tracer.log(lspMessage);
+		}
+		function throwIfClosedOrDisposed() {
+			if (isClosed()) throw new ConnectionError(ConnectionErrors.Closed, "Connection is closed.");
+			if (isDisposed()) throw new ConnectionError(ConnectionErrors.Disposed, "Connection is disposed.");
+		}
+		function throwIfListening() {
+			if (isListening()) throw new ConnectionError(ConnectionErrors.AlreadyListening, "Connection is already listening");
+		}
+		function throwIfNotListening() {
+			if (!isListening()) throw new Error("Call listen() first.");
+		}
+		function undefinedToNull(param) {
+			if (param === void 0) return null;
+			else return param;
+		}
+		function nullToUndefined(param) {
+			if (param === null) return;
+			else return param;
+		}
+		function isNamedParam(param) {
+			return param !== void 0 && param !== null && !Array.isArray(param) && typeof param === "object";
+		}
+		function computeSingleParam(parameterStructures, param) {
+			switch (parameterStructures) {
+				case messages_1.ParameterStructures.auto: if (isNamedParam(param)) return nullToUndefined(param);
+				else return [undefinedToNull(param)];
+				case messages_1.ParameterStructures.byName:
+					if (!isNamedParam(param)) throw new Error(`Received parameters by name but param is not an object literal.`);
+					return nullToUndefined(param);
+				case messages_1.ParameterStructures.byPosition: return [undefinedToNull(param)];
+				default: throw new Error(`Unknown parameter structure ${parameterStructures.toString()}`);
+			}
+		}
+		function computeMessageParams(type, params) {
+			let result;
+			const numberOfParams = type.numberOfParams;
+			switch (numberOfParams) {
+				case 0:
+					result = void 0;
+					break;
+				case 1:
+					result = computeSingleParam(type.parameterStructures, params[0]);
+					break;
+				default:
+					result = [];
+					for (let i = 0; i < params.length && i < numberOfParams; i++) result.push(undefinedToNull(params[i]));
+					if (params.length < numberOfParams) for (let i = params.length; i < numberOfParams; i++) result.push(null);
+					break;
+			}
+			return result;
+		}
+		const connection = {
+			sendNotification: (type, ...args) => {
+				throwIfClosedOrDisposed();
+				let method;
+				let messageParams;
+				if (Is.string(type)) {
+					method = type;
+					const first = args[0];
+					let paramStart = 0;
+					let parameterStructures = messages_1.ParameterStructures.auto;
+					if (messages_1.ParameterStructures.is(first)) {
+						paramStart = 1;
+						parameterStructures = first;
+					}
+					let paramEnd = args.length;
+					const numberOfParams = paramEnd - paramStart;
+					switch (numberOfParams) {
+						case 0:
+							messageParams = void 0;
+							break;
+						case 1:
+							messageParams = computeSingleParam(parameterStructures, args[paramStart]);
+							break;
+						default:
+							if (parameterStructures === messages_1.ParameterStructures.byName) throw new Error(`Received ${numberOfParams} parameters for 'by Name' notification parameter structure.`);
+							messageParams = args.slice(paramStart, paramEnd).map((value) => undefinedToNull(value));
+							break;
+					}
+				} else {
+					const params = args;
+					method = type.method;
+					messageParams = computeMessageParams(type, params);
+				}
+				const notificationMessage = {
+					jsonrpc: version,
+					method,
+					params: messageParams
+				};
+				traceSendingNotification(notificationMessage);
+				return messageWriter.write(notificationMessage).catch((error) => {
+					logger.error(`Sending notification failed.`);
+					throw error;
+				});
+			},
+			onNotification: (type, handler) => {
+				throwIfClosedOrDisposed();
+				let method;
+				if (Is.func(type)) starNotificationHandler = type;
+				else if (handler) if (Is.string(type)) {
+					method = type;
+					notificationHandlers.set(type, {
+						type: void 0,
+						handler
+					});
+				} else {
+					method = type.method;
+					notificationHandlers.set(type.method, {
+						type,
+						handler
+					});
+				}
+				return { dispose: () => {
+					if (method !== void 0) notificationHandlers.delete(method);
+					else starNotificationHandler = void 0;
+				} };
+			},
+			onProgress: (_type, token, handler) => {
+				if (progressHandlers.has(token)) throw new Error(`Progress handler for token ${token} already registered`);
+				progressHandlers.set(token, handler);
+				return { dispose: () => {
+					progressHandlers.delete(token);
+				} };
+			},
+			sendProgress: (_type, token, value) => {
+				return connection.sendNotification(ProgressNotification.type, {
+					token,
+					value
+				});
+			},
+			onUnhandledProgress: unhandledProgressEmitter.event,
+			sendRequest: (type, ...args) => {
+				throwIfClosedOrDisposed();
+				throwIfNotListening();
+				let method;
+				let messageParams;
+				let token = void 0;
+				if (Is.string(type)) {
+					method = type;
+					const first = args[0];
+					const last = args[args.length - 1];
+					let paramStart = 0;
+					let parameterStructures = messages_1.ParameterStructures.auto;
+					if (messages_1.ParameterStructures.is(first)) {
+						paramStart = 1;
+						parameterStructures = first;
+					}
+					let paramEnd = args.length;
+					if (cancellation_1.CancellationToken.is(last)) {
+						paramEnd = paramEnd - 1;
+						token = last;
+					}
+					const numberOfParams = paramEnd - paramStart;
+					switch (numberOfParams) {
+						case 0:
+							messageParams = void 0;
+							break;
+						case 1:
+							messageParams = computeSingleParam(parameterStructures, args[paramStart]);
+							break;
+						default:
+							if (parameterStructures === messages_1.ParameterStructures.byName) throw new Error(`Received ${numberOfParams} parameters for 'by Name' request parameter structure.`);
+							messageParams = args.slice(paramStart, paramEnd).map((value) => undefinedToNull(value));
+							break;
+					}
+				} else {
+					const params = args;
+					method = type.method;
+					messageParams = computeMessageParams(type, params);
+					const numberOfParams = type.numberOfParams;
+					token = cancellation_1.CancellationToken.is(params[numberOfParams]) ? params[numberOfParams] : void 0;
+				}
+				const id = sequenceNumber++;
+				let disposable;
+				if (token) disposable = token.onCancellationRequested(() => {
+					const p = cancellationStrategy.sender.sendCancellation(connection, id);
+					if (p === void 0) {
+						logger.log(`Received no promise from cancellation strategy when cancelling id ${id}`);
+						return Promise.resolve();
+					} else return p.catch(() => {
+						logger.log(`Sending cancellation messages for id ${id} failed`);
+					});
+				});
+				const requestMessage = {
+					jsonrpc: version,
+					id,
+					method,
+					params: messageParams
+				};
+				traceSendingRequest(requestMessage);
+				if (typeof cancellationStrategy.sender.enableCancellation === "function") cancellationStrategy.sender.enableCancellation(requestMessage);
+				return new Promise(async (resolve, reject) => {
+					const resolveWithCleanup = (r) => {
+						resolve(r);
+						cancellationStrategy.sender.cleanup(id);
+						disposable?.dispose();
+					};
+					const rejectWithCleanup = (r) => {
+						reject(r);
+						cancellationStrategy.sender.cleanup(id);
+						disposable?.dispose();
+					};
+					const responsePromise = {
+						method,
+						timerStart: Date.now(),
+						resolve: resolveWithCleanup,
+						reject: rejectWithCleanup
+					};
+					try {
+						responsePromises.set(id, responsePromise);
+						await messageWriter.write(requestMessage);
+					} catch (error) {
+						responsePromises.delete(id);
+						responsePromise.reject(new messages_1.ResponseError(messages_1.ErrorCodes.MessageWriteError, error.message ? error.message : "Unknown reason"));
+						logger.error(`Sending request failed.`);
+						throw error;
+					}
+				});
+			},
+			onRequest: (type, handler) => {
+				throwIfClosedOrDisposed();
+				let method = null;
+				if (StarRequestHandler.is(type)) {
+					method = void 0;
+					starRequestHandler = type;
+				} else if (Is.string(type)) {
+					method = null;
+					if (handler !== void 0) {
+						method = type;
+						requestHandlers.set(type, {
+							handler,
+							type: void 0
+						});
+					}
+				} else if (handler !== void 0) {
+					method = type.method;
+					requestHandlers.set(type.method, {
+						type,
+						handler
+					});
+				}
+				return { dispose: () => {
+					if (method === null) return;
+					if (method !== void 0) requestHandlers.delete(method);
+					else starRequestHandler = void 0;
+				} };
+			},
+			hasPendingResponse: () => {
+				return responsePromises.size > 0;
+			},
+			trace: async (_value, _tracer, sendNotificationOrTraceOptions) => {
+				let _sendNotification = false;
+				let _traceFormat = TraceFormat.Text;
+				if (sendNotificationOrTraceOptions !== void 0) if (Is.boolean(sendNotificationOrTraceOptions)) _sendNotification = sendNotificationOrTraceOptions;
+				else {
+					_sendNotification = sendNotificationOrTraceOptions.sendNotification || false;
+					_traceFormat = sendNotificationOrTraceOptions.traceFormat || TraceFormat.Text;
+				}
+				trace = _value;
+				traceFormat = _traceFormat;
+				if (trace === Trace.Off) tracer = void 0;
+				else tracer = _tracer;
+				if (_sendNotification && !isClosed() && !isDisposed()) await connection.sendNotification(SetTraceNotification.type, { value: Trace.toString(_value) });
+			},
+			onError: errorEmitter.event,
+			onClose: closeEmitter.event,
+			onUnhandledNotification: unhandledNotificationEmitter.event,
+			onDispose: disposeEmitter.event,
+			end: () => {
+				messageWriter.end();
+			},
+			dispose: () => {
+				if (isDisposed()) return;
+				state = ConnectionState.Disposed;
+				disposeEmitter.fire(void 0);
+				const error = new messages_1.ResponseError(messages_1.ErrorCodes.PendingResponseRejected, "Pending response rejected since connection got disposed");
+				for (const promise of responsePromises.values()) promise.reject(error);
+				responsePromises = /* @__PURE__ */ new Map();
+				requestTokens = /* @__PURE__ */ new Map();
+				knownCanceledRequests = /* @__PURE__ */ new Set();
+				messageQueue = new linkedMap_1.LinkedMap();
+				if (Is.func(messageWriter.dispose)) messageWriter.dispose();
+				if (Is.func(messageReader.dispose)) messageReader.dispose();
+			},
+			listen: () => {
+				throwIfClosedOrDisposed();
+				throwIfListening();
+				state = ConnectionState.Listening;
+				messageReader.listen(callback);
+			},
+			inspect: () => {
+				(0, ral_1.default)().console.log("inspect");
+			}
+		};
+		connection.onNotification(LogTraceNotification.type, (params) => {
+			if (trace === Trace.Off || !tracer) return;
+			const verbose = trace === Trace.Verbose || trace === Trace.Compact;
+			tracer.log(params.message, verbose ? params.verbose : void 0);
+		});
+		connection.onNotification(ProgressNotification.type, (params) => {
+			const handler = progressHandlers.get(params.token);
+			if (handler) handler(params.value);
+			else unhandledProgressEmitter.fire(params);
+		});
+		return connection;
+	}
+	exports.createMessageConnection = createMessageConnection;
+}));
+
+//#endregion
+//#region node_modules/.pnpm/vscode-jsonrpc@8.2.1/node_modules/vscode-jsonrpc/lib/common/api.js
+var require_api = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.ProgressType = exports.ProgressToken = exports.createMessageConnection = exports.NullLogger = exports.ConnectionOptions = exports.ConnectionStrategy = exports.AbstractMessageBuffer = exports.WriteableStreamMessageWriter = exports.AbstractMessageWriter = exports.MessageWriter = exports.ReadableStreamMessageReader = exports.AbstractMessageReader = exports.MessageReader = exports.SharedArrayReceiverStrategy = exports.SharedArraySenderStrategy = exports.CancellationToken = exports.CancellationTokenSource = exports.Emitter = exports.Event = exports.Disposable = exports.LRUCache = exports.Touch = exports.LinkedMap = exports.ParameterStructures = exports.NotificationType9 = exports.NotificationType8 = exports.NotificationType7 = exports.NotificationType6 = exports.NotificationType5 = exports.NotificationType4 = exports.NotificationType3 = exports.NotificationType2 = exports.NotificationType1 = exports.NotificationType0 = exports.NotificationType = exports.ErrorCodes = exports.ResponseError = exports.RequestType9 = exports.RequestType8 = exports.RequestType7 = exports.RequestType6 = exports.RequestType5 = exports.RequestType4 = exports.RequestType3 = exports.RequestType2 = exports.RequestType1 = exports.RequestType0 = exports.RequestType = exports.Message = exports.RAL = void 0;
+	exports.MessageStrategy = exports.CancellationStrategy = exports.CancellationSenderStrategy = exports.CancellationReceiverStrategy = exports.ConnectionError = exports.ConnectionErrors = exports.LogTraceNotification = exports.SetTraceNotification = exports.TraceFormat = exports.TraceValues = exports.Trace = void 0;
+	const messages_1 = require_messages();
+	Object.defineProperty(exports, "Message", {
+		enumerable: true,
+		get: function() {
+			return messages_1.Message;
+		}
+	});
+	Object.defineProperty(exports, "RequestType", {
+		enumerable: true,
+		get: function() {
+			return messages_1.RequestType;
+		}
+	});
+	Object.defineProperty(exports, "RequestType0", {
+		enumerable: true,
+		get: function() {
+			return messages_1.RequestType0;
+		}
+	});
+	Object.defineProperty(exports, "RequestType1", {
+		enumerable: true,
+		get: function() {
+			return messages_1.RequestType1;
+		}
+	});
+	Object.defineProperty(exports, "RequestType2", {
+		enumerable: true,
+		get: function() {
+			return messages_1.RequestType2;
+		}
+	});
+	Object.defineProperty(exports, "RequestType3", {
+		enumerable: true,
+		get: function() {
+			return messages_1.RequestType3;
+		}
+	});
+	Object.defineProperty(exports, "RequestType4", {
+		enumerable: true,
+		get: function() {
+			return messages_1.RequestType4;
+		}
+	});
+	Object.defineProperty(exports, "RequestType5", {
+		enumerable: true,
+		get: function() {
+			return messages_1.RequestType5;
+		}
+	});
+	Object.defineProperty(exports, "RequestType6", {
+		enumerable: true,
+		get: function() {
+			return messages_1.RequestType6;
+		}
+	});
+	Object.defineProperty(exports, "RequestType7", {
+		enumerable: true,
+		get: function() {
+			return messages_1.RequestType7;
+		}
+	});
+	Object.defineProperty(exports, "RequestType8", {
+		enumerable: true,
+		get: function() {
+			return messages_1.RequestType8;
+		}
+	});
+	Object.defineProperty(exports, "RequestType9", {
+		enumerable: true,
+		get: function() {
+			return messages_1.RequestType9;
+		}
+	});
+	Object.defineProperty(exports, "ResponseError", {
+		enumerable: true,
+		get: function() {
+			return messages_1.ResponseError;
+		}
+	});
+	Object.defineProperty(exports, "ErrorCodes", {
+		enumerable: true,
+		get: function() {
+			return messages_1.ErrorCodes;
+		}
+	});
+	Object.defineProperty(exports, "NotificationType", {
+		enumerable: true,
+		get: function() {
+			return messages_1.NotificationType;
+		}
+	});
+	Object.defineProperty(exports, "NotificationType0", {
+		enumerable: true,
+		get: function() {
+			return messages_1.NotificationType0;
+		}
+	});
+	Object.defineProperty(exports, "NotificationType1", {
+		enumerable: true,
+		get: function() {
+			return messages_1.NotificationType1;
+		}
+	});
+	Object.defineProperty(exports, "NotificationType2", {
+		enumerable: true,
+		get: function() {
+			return messages_1.NotificationType2;
+		}
+	});
+	Object.defineProperty(exports, "NotificationType3", {
+		enumerable: true,
+		get: function() {
+			return messages_1.NotificationType3;
+		}
+	});
+	Object.defineProperty(exports, "NotificationType4", {
+		enumerable: true,
+		get: function() {
+			return messages_1.NotificationType4;
+		}
+	});
+	Object.defineProperty(exports, "NotificationType5", {
+		enumerable: true,
+		get: function() {
+			return messages_1.NotificationType5;
+		}
+	});
+	Object.defineProperty(exports, "NotificationType6", {
+		enumerable: true,
+		get: function() {
+			return messages_1.NotificationType6;
+		}
+	});
+	Object.defineProperty(exports, "NotificationType7", {
+		enumerable: true,
+		get: function() {
+			return messages_1.NotificationType7;
+		}
+	});
+	Object.defineProperty(exports, "NotificationType8", {
+		enumerable: true,
+		get: function() {
+			return messages_1.NotificationType8;
+		}
+	});
+	Object.defineProperty(exports, "NotificationType9", {
+		enumerable: true,
+		get: function() {
+			return messages_1.NotificationType9;
+		}
+	});
+	Object.defineProperty(exports, "ParameterStructures", {
+		enumerable: true,
+		get: function() {
+			return messages_1.ParameterStructures;
+		}
+	});
+	const linkedMap_1 = require_linkedMap();
+	Object.defineProperty(exports, "LinkedMap", {
+		enumerable: true,
+		get: function() {
+			return linkedMap_1.LinkedMap;
+		}
+	});
+	Object.defineProperty(exports, "LRUCache", {
+		enumerable: true,
+		get: function() {
+			return linkedMap_1.LRUCache;
+		}
+	});
+	Object.defineProperty(exports, "Touch", {
+		enumerable: true,
+		get: function() {
+			return linkedMap_1.Touch;
+		}
+	});
+	const disposable_1 = require_disposable();
+	Object.defineProperty(exports, "Disposable", {
+		enumerable: true,
+		get: function() {
+			return disposable_1.Disposable;
+		}
+	});
+	const events_1 = require_events();
+	Object.defineProperty(exports, "Event", {
+		enumerable: true,
+		get: function() {
+			return events_1.Event;
+		}
+	});
+	Object.defineProperty(exports, "Emitter", {
+		enumerable: true,
+		get: function() {
+			return events_1.Emitter;
+		}
+	});
+	const cancellation_1 = require_cancellation();
+	Object.defineProperty(exports, "CancellationTokenSource", {
+		enumerable: true,
+		get: function() {
+			return cancellation_1.CancellationTokenSource;
+		}
+	});
+	Object.defineProperty(exports, "CancellationToken", {
+		enumerable: true,
+		get: function() {
+			return cancellation_1.CancellationToken;
+		}
+	});
+	const sharedArrayCancellation_1 = require_sharedArrayCancellation();
+	Object.defineProperty(exports, "SharedArraySenderStrategy", {
+		enumerable: true,
+		get: function() {
+			return sharedArrayCancellation_1.SharedArraySenderStrategy;
+		}
+	});
+	Object.defineProperty(exports, "SharedArrayReceiverStrategy", {
+		enumerable: true,
+		get: function() {
+			return sharedArrayCancellation_1.SharedArrayReceiverStrategy;
+		}
+	});
+	const messageReader_1 = require_messageReader();
+	Object.defineProperty(exports, "MessageReader", {
+		enumerable: true,
+		get: function() {
+			return messageReader_1.MessageReader;
+		}
+	});
+	Object.defineProperty(exports, "AbstractMessageReader", {
+		enumerable: true,
+		get: function() {
+			return messageReader_1.AbstractMessageReader;
+		}
+	});
+	Object.defineProperty(exports, "ReadableStreamMessageReader", {
+		enumerable: true,
+		get: function() {
+			return messageReader_1.ReadableStreamMessageReader;
+		}
+	});
+	const messageWriter_1 = require_messageWriter();
+	Object.defineProperty(exports, "MessageWriter", {
+		enumerable: true,
+		get: function() {
+			return messageWriter_1.MessageWriter;
+		}
+	});
+	Object.defineProperty(exports, "AbstractMessageWriter", {
+		enumerable: true,
+		get: function() {
+			return messageWriter_1.AbstractMessageWriter;
+		}
+	});
+	Object.defineProperty(exports, "WriteableStreamMessageWriter", {
+		enumerable: true,
+		get: function() {
+			return messageWriter_1.WriteableStreamMessageWriter;
+		}
+	});
+	const messageBuffer_1 = require_messageBuffer();
+	Object.defineProperty(exports, "AbstractMessageBuffer", {
+		enumerable: true,
+		get: function() {
+			return messageBuffer_1.AbstractMessageBuffer;
+		}
+	});
+	const connection_1 = require_connection();
+	Object.defineProperty(exports, "ConnectionStrategy", {
+		enumerable: true,
+		get: function() {
+			return connection_1.ConnectionStrategy;
+		}
+	});
+	Object.defineProperty(exports, "ConnectionOptions", {
+		enumerable: true,
+		get: function() {
+			return connection_1.ConnectionOptions;
+		}
+	});
+	Object.defineProperty(exports, "NullLogger", {
+		enumerable: true,
+		get: function() {
+			return connection_1.NullLogger;
+		}
+	});
+	Object.defineProperty(exports, "createMessageConnection", {
+		enumerable: true,
+		get: function() {
+			return connection_1.createMessageConnection;
+		}
+	});
+	Object.defineProperty(exports, "ProgressToken", {
+		enumerable: true,
+		get: function() {
+			return connection_1.ProgressToken;
+		}
+	});
+	Object.defineProperty(exports, "ProgressType", {
+		enumerable: true,
+		get: function() {
+			return connection_1.ProgressType;
+		}
+	});
+	Object.defineProperty(exports, "Trace", {
+		enumerable: true,
+		get: function() {
+			return connection_1.Trace;
+		}
+	});
+	Object.defineProperty(exports, "TraceValues", {
+		enumerable: true,
+		get: function() {
+			return connection_1.TraceValues;
+		}
+	});
+	Object.defineProperty(exports, "TraceFormat", {
+		enumerable: true,
+		get: function() {
+			return connection_1.TraceFormat;
+		}
+	});
+	Object.defineProperty(exports, "SetTraceNotification", {
+		enumerable: true,
+		get: function() {
+			return connection_1.SetTraceNotification;
+		}
+	});
+	Object.defineProperty(exports, "LogTraceNotification", {
+		enumerable: true,
+		get: function() {
+			return connection_1.LogTraceNotification;
+		}
+	});
+	Object.defineProperty(exports, "ConnectionErrors", {
+		enumerable: true,
+		get: function() {
+			return connection_1.ConnectionErrors;
+		}
+	});
+	Object.defineProperty(exports, "ConnectionError", {
+		enumerable: true,
+		get: function() {
+			return connection_1.ConnectionError;
+		}
+	});
+	Object.defineProperty(exports, "CancellationReceiverStrategy", {
+		enumerable: true,
+		get: function() {
+			return connection_1.CancellationReceiverStrategy;
+		}
+	});
+	Object.defineProperty(exports, "CancellationSenderStrategy", {
+		enumerable: true,
+		get: function() {
+			return connection_1.CancellationSenderStrategy;
+		}
+	});
+	Object.defineProperty(exports, "CancellationStrategy", {
+		enumerable: true,
+		get: function() {
+			return connection_1.CancellationStrategy;
+		}
+	});
+	Object.defineProperty(exports, "MessageStrategy", {
+		enumerable: true,
+		get: function() {
+			return connection_1.MessageStrategy;
+		}
+	});
+	const ral_1 = require_ral();
+	exports.RAL = ral_1.default;
+}));
+
+//#endregion
+//#region node_modules/.pnpm/vscode-jsonrpc@8.2.1/node_modules/vscode-jsonrpc/lib/browser/ril.js
+var require_ril = /* @__PURE__ */ __commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	const api_1 = require_api();
+	var MessageBuffer = class MessageBuffer extends api_1.AbstractMessageBuffer {
+		constructor(encoding = "utf-8") {
+			super(encoding);
+			this.asciiDecoder = new TextDecoder("ascii");
+		}
+		emptyBuffer() {
+			return MessageBuffer.emptyBuffer;
+		}
+		fromString(value, _encoding) {
+			return new TextEncoder().encode(value);
+		}
+		toString(value, encoding) {
+			if (encoding === "ascii") return this.asciiDecoder.decode(value);
+			else return new TextDecoder(encoding).decode(value);
+		}
+		asNative(buffer, length) {
+			if (length === void 0) return buffer;
+			else return buffer.slice(0, length);
+		}
+		allocNative(length) {
+			return new Uint8Array(length);
+		}
+	};
+	MessageBuffer.emptyBuffer = new Uint8Array(0);
+	var ReadableStreamWrapper = class {
+		constructor(socket) {
+			this.socket = socket;
+			this._onData = new api_1.Emitter();
+			this._messageListener = (event) => {
+				event.data.arrayBuffer().then((buffer) => {
+					this._onData.fire(new Uint8Array(buffer));
+				}, () => {
+					(0, api_1.RAL)().console.error(`Converting blob to array buffer failed.`);
+				});
+			};
+			this.socket.addEventListener("message", this._messageListener);
+		}
+		onClose(listener) {
+			this.socket.addEventListener("close", listener);
+			return api_1.Disposable.create(() => this.socket.removeEventListener("close", listener));
+		}
+		onError(listener) {
+			this.socket.addEventListener("error", listener);
+			return api_1.Disposable.create(() => this.socket.removeEventListener("error", listener));
+		}
+		onEnd(listener) {
+			this.socket.addEventListener("end", listener);
+			return api_1.Disposable.create(() => this.socket.removeEventListener("end", listener));
+		}
+		onData(listener) {
+			return this._onData.event(listener);
+		}
+	};
+	var WritableStreamWrapper = class {
+		constructor(socket) {
+			this.socket = socket;
+		}
+		onClose(listener) {
+			this.socket.addEventListener("close", listener);
+			return api_1.Disposable.create(() => this.socket.removeEventListener("close", listener));
+		}
+		onError(listener) {
+			this.socket.addEventListener("error", listener);
+			return api_1.Disposable.create(() => this.socket.removeEventListener("error", listener));
+		}
+		onEnd(listener) {
+			this.socket.addEventListener("end", listener);
+			return api_1.Disposable.create(() => this.socket.removeEventListener("end", listener));
+		}
+		write(data, encoding) {
+			if (typeof data === "string") {
+				if (encoding !== void 0 && encoding !== "utf-8") throw new Error(`In a Browser environments only utf-8 text encoding is supported. But got encoding: ${encoding}`);
+				this.socket.send(data);
+			} else this.socket.send(data);
+			return Promise.resolve();
+		}
+		end() {
+			this.socket.close();
+		}
+	};
+	const _textEncoder = new TextEncoder();
+	const _ril = Object.freeze({
+		messageBuffer: Object.freeze({ create: (encoding) => new MessageBuffer(encoding) }),
+		applicationJson: Object.freeze({
+			encoder: Object.freeze({
+				name: "application/json",
+				encode: (msg, options) => {
+					if (options.charset !== "utf-8") throw new Error(`In a Browser environments only utf-8 text encoding is supported. But got encoding: ${options.charset}`);
+					return Promise.resolve(_textEncoder.encode(JSON.stringify(msg, void 0, 0)));
+				}
+			}),
+			decoder: Object.freeze({
+				name: "application/json",
+				decode: (buffer, options) => {
+					if (!(buffer instanceof Uint8Array)) throw new Error(`In a Browser environments only Uint8Arrays are supported.`);
+					return Promise.resolve(JSON.parse(new TextDecoder(options.charset).decode(buffer)));
+				}
+			})
+		}),
+		stream: Object.freeze({
+			asReadableStream: (socket) => new ReadableStreamWrapper(socket),
+			asWritableStream: (socket) => new WritableStreamWrapper(socket)
+		}),
+		console,
+		timer: Object.freeze({
+			setTimeout(callback, ms, ...args) {
+				const handle = setTimeout(callback, ms, ...args);
+				return { dispose: () => clearTimeout(handle) };
+			},
+			setImmediate(callback, ...args) {
+				const handle = setTimeout(callback, 0, ...args);
+				return { dispose: () => clearTimeout(handle) };
+			},
+			setInterval(callback, ms, ...args) {
+				const handle = setInterval(callback, ms, ...args);
+				return { dispose: () => clearInterval(handle) };
+			}
+		})
+	});
+	function RIL() {
+		return _ril;
+	}
+	(function(RIL) {
+		function install() {
+			api_1.RAL.install(_ril);
+		}
+		RIL.install = install;
+	})(RIL || (RIL = {}));
+	exports.default = RIL;
+}));
+
+//#endregion
+//#region node_modules/.pnpm/vscode-jsonrpc@8.2.1/node_modules/vscode-jsonrpc/lib/browser/main.js
+var require_main = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+		if (k2 === void 0) k2 = k;
+		var desc = Object.getOwnPropertyDescriptor(m, k);
+		if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) desc = {
+			enumerable: true,
+			get: function() {
+				return m[k];
+			}
+		};
+		Object.defineProperty(o, k2, desc);
+	}) : (function(o, m, k, k2) {
+		if (k2 === void 0) k2 = k;
+		o[k2] = m[k];
+	}));
+	var __exportStar = exports && exports.__exportStar || function(m, exports$1) {
+		for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports$1, p)) __createBinding(exports$1, m, p);
+	};
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.createMessageConnection = exports.BrowserMessageWriter = exports.BrowserMessageReader = void 0;
+	require_ril().default.install();
+	const api_1 = require_api();
+	__exportStar(require_api(), exports);
+	var BrowserMessageReader = class extends api_1.AbstractMessageReader {
+		constructor(port) {
+			super();
+			this._onData = new api_1.Emitter();
+			this._messageListener = (event) => {
+				this._onData.fire(event.data);
+			};
+			port.addEventListener("error", (event) => this.fireError(event));
+			port.onmessage = this._messageListener;
+		}
+		listen(callback) {
+			return this._onData.event(callback);
+		}
+	};
+	exports.BrowserMessageReader = BrowserMessageReader;
+	var BrowserMessageWriter = class extends api_1.AbstractMessageWriter {
+		constructor(port) {
+			super();
+			this.port = port;
+			this.errorCount = 0;
+			port.addEventListener("error", (event) => this.fireError(event));
+		}
+		write(msg) {
+			try {
+				this.port.postMessage(msg);
+				return Promise.resolve();
+			} catch (error) {
+				this.handleError(error, msg);
+				return Promise.reject(error);
+			}
+		}
+		handleError(error, msg) {
+			this.errorCount++;
+			this.fireError(error, msg, this.errorCount);
+		}
+		end() {}
+	};
+	exports.BrowserMessageWriter = BrowserMessageWriter;
+	function createMessageConnection(reader, writer, logger, options) {
+		if (logger === void 0) logger = api_1.NullLogger;
+		if (api_1.ConnectionStrategy.is(options)) options = { connectionStrategy: options };
+		return (0, api_1.createMessageConnection)(reader, writer, logger, options);
+	}
+	exports.createMessageConnection = createMessageConnection;
+}));
+
+//#endregion
+//#region node_modules/.pnpm/thumbdrive@0.3.0_tslib@2.8.1/node_modules/thumbdrive/dist/MultiTabWorkerBroker.js
+var import_main = require_main();
+function generateBrokerId() {
+	return `broker-${Date.now()}-${Math.random().toString(36).substring(2, 15)}`;
+}
+var MultiTabWorkerBrokerError = class extends Error {
+	details;
+	constructor(message, details) {
+		super(message);
+		this.details = details;
+		this.name = "MultiTabWorkerBrokerError";
+	}
+};
+/**
+* A worker broker that allows multiple tabs open on the same origin to all talk to one active tab's worker
+* Supports tabs coming and going and re-electing the active tab as leader
+*/
+var MultiTabWorkerBroker = class {
+	lockName;
+	makeWorker;
+	isLeader = false;
+	started = false;
+	brokerId;
+	broadcastChannel = null;
+	worker = null;
+	lockAbortController = new AbortController();
+	pendingRequests = /* @__PURE__ */ new Map();
+	nextRequestId = 0;
+	timeout;
+	onStateChange;
+	leaderRequestQueue = [];
+	workerReadyPromise = null;
+	workerReadyResolver = null;
+	rewrittenIdMap = /* @__PURE__ */ new Map();
+	connections = /* @__PURE__ */ new Map();
+	nextConnectionId = 0;
+	shouldDebug = false;
+	activeLockPromise = null;
+	stopPromise = null;
+	constructor(lockName, makeWorker, options) {
+		this.lockName = lockName;
+		this.makeWorker = makeWorker;
+		this.brokerId = generateBrokerId();
+		this.timeout = options?.timeout ?? 2e4;
+		this.onStateChange = options?.onStateChange;
+		this.shouldDebug = options?.debug ?? false;
+	}
+	/** Central debug logging function */
+	debug(message, ...args) {
+		if (this.shouldDebug) {
+			const role = this.isLeader ? "LEADER" : "FOLLOWER";
+			const prefix = `[MTB:${this.brokerId.slice(0, 20)}:${role}]`;
+			console.debug(prefix, message, ...args);
+		}
+	}
+	/** Central error logging function */
+	error(message, ...args) {
+		const role = this.isLeader ? "LEADER" : "FOLLOWER";
+		const prefix = `[MTB:${this.brokerId.slice(0, 20)}:${role}]`;
+		console.error(prefix, message, ...args);
+	}
+	/** Create a new connection with independent reader and writer */
+	createConnection() {
+		const connectionId = String(this.nextConnectionId++);
+		const reader = new MultiTabMessageReader();
+		const writer = new MultiTabMessageWriter();
+		writer._setWriteHandler(async (message) => {
+			await this.sendMessage(message);
+		});
+		this.connections.set(connectionId, {
+			reader,
+			writer
+		});
+		this.debug(`createConnection: Created connection ${connectionId}`);
+		const dispose = () => {
+			this.debug(`Connection ${connectionId} disposed`);
+			const conn = this.connections.get(connectionId);
+			if (conn) {
+				conn.reader.dispose();
+				conn.writer.dispose();
+				this.connections.delete(connectionId);
+			}
+		};
+		return {
+			reader,
+			writer,
+			dispose
+		};
+	}
+	/** Start the broker and attempt to acquire leadership */
+	async start() {
+		if (this.stopPromise) await this.stopPromise;
+		if (this.started) return;
+		this.started = true;
+		this.lockAbortController = new AbortController();
+		this.broadcastChannel = new BroadcastChannel(this.lockName);
+		this.broadcastChannel.addEventListener("message", this.handleBroadcastMessage);
+		await this.tryAcquireLock();
+		this.debug(`Broker started, isLeader=${this.isLeader}`);
+	}
+	async tryAcquireLock() {
+		let outcomeKnown;
+		let outcomeKnownError;
+		const outcome = new Promise((resolve, reject) => {
+			outcomeKnown = resolve;
+			outcomeKnownError = reject;
+		});
+		this.activeLockPromise = navigator.locks.request(this.lockName, { ifAvailable: true }, async (lock) => {
+			if (lock === null) {
+				outcomeKnown(false);
+				return false;
+			}
+			await this.becomeLeader();
+			outcomeKnown(true);
+			return new Promise((resolve) => {
+				this.lockAbortController.signal.addEventListener("abort", () => {
+					resolve();
+				});
+			});
+		}).catch(outcomeKnownError);
+		if (!await outcome) {
+			this.isLeader = false;
+			this.lockAbortController = new AbortController();
+			this.waitForLockAndBecomeLeader();
+			this.onStateChange?.({ isLeader: this.isLeader });
+		}
+	}
+	waitForLockAndBecomeLeader() {
+		this.activeLockPromise = navigator.locks.request(this.lockName, { signal: this.lockAbortController.signal }, async () => {
+			await this.becomeLeader();
+			return new Promise((resolve) => {
+				this.lockAbortController.signal.addEventListener("abort", () => {
+					resolve();
+				});
+			});
+		}).catch((error) => {
+			if (error.name !== "AbortError") {
+				this.error(`Lock acquisition failed:`, error);
+				this.emitErrorToAllConnections(error instanceof Error ? error : new Error(String(error)));
+			}
+		});
+	}
+	async becomeLeader() {
+		this.debug(`Becoming leader...`);
+		this.isLeader = true;
+		this.workerReadyPromise = new Promise((resolve) => {
+			this.workerReadyResolver = resolve;
+		});
+		this.worker = await this.makeWorker();
+		const messageHandler = (event) => {
+			this.handleWorkerMessage(event);
+		};
+		const errorHandler = (event) => {
+			this.handleWorkerError(event);
+		};
+		this.worker.addEventListener("message", messageHandler);
+		this.worker.addEventListener("error", errorHandler);
+		this.debug(`Leader ready with worker`);
+		this.onStateChange?.({ isLeader: this.isLeader });
+		if (this.leaderRequestQueue.length > 0 && this.worker && this.broadcastChannel) {
+			const queued = this.leaderRequestQueue.splice(0, this.leaderRequestQueue.length);
+			for (const { id, message } of queued) {
+				this.worker.postMessage(message);
+				const response = {
+					type: "worker-response",
+					id,
+					message
+				};
+				this.broadcastChannel.postMessage(response);
+			}
+		}
+		if (this.workerReadyResolver) {
+			this.workerReadyResolver();
+			this.workerReadyResolver = null;
+		}
+	}
+	/** Rewrite a JSONRPC ID to make it globally unique */
+	rewriteId(originalId) {
+		const rewrittenId = `${this.brokerId}:${originalId}`;
+		this.rewrittenIdMap.set(rewrittenId, originalId);
+		return rewrittenId;
+	}
+	unrewriteId(rewrittenId) {
+		if (typeof rewrittenId === "string" && rewrittenId.startsWith(`${this.brokerId}:`)) {
+			const originalId = this.rewrittenIdMap.get(rewrittenId);
+			if (originalId !== void 0) {
+				this.rewrittenIdMap.delete(rewrittenId);
+				return {
+					originalId,
+					isOurs: true
+				};
+			}
+		}
+		return {
+			originalId: rewrittenId,
+			isOurs: false
+		};
+	}
+	rewriteMessage(message) {
+		if (message && typeof message === "object" && "method" in message && message.method && "id" in message && message.id !== void 0) return {
+			...message,
+			id: this.rewriteId(message.id)
+		};
+		return message;
+	}
+	unrewriteMessage(message) {
+		if (message && typeof message === "object" && "id" in message && message.id !== void 0) {
+			const { originalId, isOurs } = this.unrewriteId(message.id);
+			return {
+				message: {
+					...message,
+					id: originalId
+				},
+				isOurs
+			};
+		}
+		return {
+			message,
+			isOurs: true
+		};
+	}
+	handleWorkerMessage(event) {
+		const message = event.data;
+		if (message && typeof message === "object" && "method" in message && message.method) {
+			const isNotification = message.id === void 0;
+			this.emitToAllConnections(message);
+			if (isNotification && this.broadcastChannel && this.isLeader) {
+				const brokerMessage = {
+					type: "worker-message",
+					message
+				};
+				this.broadcastChannel.postMessage(brokerMessage);
+			}
+			return;
+		}
+		const { message: unrewrittenMessage, isOurs } = this.unrewriteMessage(message);
+		if (isOurs) this.emitToAllConnections(unrewrittenMessage);
+		else {
+			const rawId = message?.id;
+			if (!(typeof rawId === "string" && rawId.startsWith("broker-"))) this.emitToAllConnections(message);
+		}
+		if (this.broadcastChannel && this.isLeader) {
+			const brokerMessage = {
+				type: "worker-message",
+				message
+			};
+			this.broadcastChannel.postMessage(brokerMessage);
+		}
+	}
+	emitToAllConnections(message) {
+		for (const { reader } of this.connections.values()) reader._emitMessage(message);
+	}
+	emitErrorToAllConnections(error) {
+		for (const { reader, writer } of this.connections.values()) {
+			reader._emitError(error);
+			writer._emitError(error);
+		}
+	}
+	emitCloseToAllConnections() {
+		for (const { reader, writer } of this.connections.values()) {
+			reader._emitClose();
+			writer._emitClose();
+		}
+	}
+	handleWorkerError(event) {
+		const error = new Error(event.message || "Worker error");
+		this.error(`Worker error:`, error, event);
+		this.emitErrorToAllConnections(error);
+	}
+	handleBroadcastMessage = (event) => {
+		if (!this.started) return;
+		const brokerMessage = event.data;
+		if (brokerMessage.type === "worker-message") {
+			if (!this.isLeader) {
+				const { message: unrewrittenMessage, isOurs } = this.unrewriteMessage(brokerMessage.message);
+				if (isOurs) this.emitToAllConnections(unrewrittenMessage);
+			}
+		} else if (brokerMessage.type === "worker-request") {
+			if (this.isLeader) if (this.worker) {
+				this.worker.postMessage(brokerMessage.message);
+				const response = {
+					type: "worker-response",
+					id: brokerMessage.id,
+					message: brokerMessage.message
+				};
+				this.broadcastChannel.postMessage(response);
+			} else this.leaderRequestQueue.push({
+				id: brokerMessage.id,
+				message: brokerMessage.message
+			});
+		} else if (brokerMessage.type === "worker-response") {
+			const pending = this.pendingRequests.get(brokerMessage.id);
+			if (pending) {
+				pending.resolve(brokerMessage.message);
+				this.pendingRequests.delete(brokerMessage.id);
+			}
+		}
+	};
+	async sendMessage(message) {
+		const originalId = message?.id;
+		this.debug(`sendMessage: originalId=${originalId}`, message);
+		const rewrittenMessage = this.rewriteMessage(message);
+		const rewrittenId = rewrittenMessage?.id;
+		if (this.isLeader) {
+			if (!this.worker) {
+				this.debug(`Leader not ready; waiting for worker to initialize`);
+				if (this.workerReadyPromise) await this.workerReadyPromise;
+			}
+			if (this.worker) {
+				this.debug(`Sending to worker with rewrittenId=${rewrittenId}`, message);
+				this.worker.postMessage(rewrittenMessage);
+				return;
+			}
+			this.debug(`Worker still not available after wait; falling back to broadcast`);
+		} else {
+			if (!this.broadcastChannel) throw new Error("Broker not started");
+			const requestId = String(this.nextRequestId++);
+			this.debug(`Sending worker-request: brokerRequestId=${requestId}, rewrittenId=${rewrittenId}`, message);
+			const request = {
+				type: "worker-request",
+				id: requestId,
+				message: rewrittenMessage
+			};
+			await new Promise((resolve, reject) => {
+				const timeout = setTimeout(() => {
+					this.pendingRequests.delete(requestId);
+					reject(new MultiTabWorkerBrokerError(`MultiTabWorkerBroker request timeout - no leader responded within ${this.timeout}ms`, { rpcMessage: message }));
+				}, this.timeout);
+				this.pendingRequests.set(requestId, {
+					resolve: () => {
+						clearTimeout(timeout);
+						resolve();
+					},
+					reject: (error) => {
+						clearTimeout(timeout);
+						reject(error);
+					}
+				});
+				this.broadcastChannel.postMessage(request);
+			});
+		}
+	}
+	/** Stop the broker and release all resources */
+	async stop() {
+		if (this.stopPromise) {
+			await this.stopPromise;
+			return;
+		}
+		if (!this.started) return;
+		this.started = false;
+		const performStop = async () => {
+			if (this.lockAbortController) this.lockAbortController.abort();
+			const lockPromiseToAwait = this.activeLockPromise;
+			if (lockPromiseToAwait) {
+				try {
+					await lockPromiseToAwait;
+				} catch (error) {
+					if (error && error.name !== "AbortError") this.error("Error while waiting for lock release:", error);
+				}
+				this.activeLockPromise = null;
+			}
+			if (this.worker) {
+				this.worker.terminate();
+				this.worker = null;
+			}
+			const channel = this.broadcastChannel;
+			if (channel) {
+				channel.removeEventListener("message", this.handleBroadcastMessage);
+				channel.close();
+				this.broadcastChannel = null;
+			}
+			for (const [id, pending] of this.pendingRequests.entries()) pending.reject(/* @__PURE__ */ new Error("Broker stopped"));
+			this.pendingRequests.clear();
+			this.emitCloseToAllConnections();
+			for (const { reader, writer } of this.connections.values()) {
+				reader.dispose();
+				writer.dispose();
+			}
+			this.connections.clear();
+			this.workerReadyPromise = null;
+			this.workerReadyResolver = null;
+			this.leaderRequestQueue = [];
+			this.rewrittenIdMap.clear();
+			const wasLeader = this.isLeader;
+			this.isLeader = false;
+			if (wasLeader) this.onStateChange?.({ isLeader: false });
+		};
+		this.stopPromise = (async () => {
+			try {
+				await performStop();
+			} finally {
+				this.stopPromise = null;
+			}
+		})();
+		await this.stopPromise;
+	}
+};
+var MultiTabMessageReader = class MultiTabMessageReader {
+	errorEmitter = new import_main.Emitter();
+	closeEmitter = new import_main.Emitter();
+	partialMessageEmitter = new import_main.Emitter();
+	messageEmitter = new import_main.Emitter();
+	disposed = false;
+	hasListener = false;
+	queuedMessages = [];
+	static MAX_QUEUE = 1e3;
+	onError = this.errorEmitter.event;
+	onClose = this.closeEmitter.event;
+	onPartialMessage = this.partialMessageEmitter.event;
+	listen(callback) {
+		const disposable = this.messageEmitter.event((message) => {
+			callback(message);
+		});
+		if (!this.hasListener) {
+			this.hasListener = true;
+			if (this.queuedMessages.length > 0) {
+				const toFlush = this.queuedMessages.splice(0, this.queuedMessages.length);
+				for (const msg of toFlush) this.messageEmitter.fire(msg);
+			}
+		}
+		return disposable;
+	}
+	_emitMessage(message) {
+		if (!this.disposed) if (this.hasListener) this.messageEmitter.fire(message);
+		else {
+			if (this.queuedMessages.length >= MultiTabMessageReader.MAX_QUEUE) this.queuedMessages.shift();
+			this.queuedMessages.push(message);
+		}
+	}
+	_emitError(error) {
+		if (!this.disposed) this.errorEmitter.fire(error);
+	}
+	_emitClose() {
+		if (!this.disposed) this.closeEmitter.fire();
+	}
+	dispose() {
+		if (!this.disposed) {
+			this.disposed = true;
+			this.errorEmitter.dispose();
+			this.closeEmitter.dispose();
+			this.partialMessageEmitter.dispose();
+			this.messageEmitter.dispose();
+			this.queuedMessages = [];
+		}
+	}
+};
+var MultiTabMessageWriter = class {
+	errorEmitter = new import_main.Emitter();
+	closeEmitter = new import_main.Emitter();
+	disposed = false;
+	writeHandler = null;
+	onError = this.errorEmitter.event;
+	onClose = this.closeEmitter.event;
+	async write(message) {
+		if (this.disposed) throw new Error("Writer is disposed");
+		if (!this.writeHandler) throw new Error("Writer not initialized");
+		try {
+			await this.writeHandler(message);
+		} catch (error) {
+			const err = error instanceof Error ? error : new Error(String(error));
+			this.errorEmitter.fire([
+				err,
+				message,
+				void 0
+			]);
+			throw err;
+		}
+	}
+	end() {}
+	_setWriteHandler(handler) {
+		this.writeHandler = handler;
+	}
+	_emitError(error) {
+		if (!this.disposed) this.errorEmitter.fire([
+			error,
+			void 0,
+			void 0
+		]);
+	}
+	_emitClose() {
+		if (!this.disposed) this.closeEmitter.fire();
+	}
+	dispose() {
+		if (!this.disposed) {
+			this.disposed = true;
+			this.writeHandler = null;
+			this.errorEmitter.dispose();
+			this.closeEmitter.dispose();
+		}
+	}
+};
+
+//#endregion
+//#region packages/substrate/src/utils/debug.ts
+/**
+* Substrate Logging Utility
+*
+* A unified logging system with configurable levels and component filtering.
+*
+* Configuration via globals:
+*   - __SUBSTRATE_LOG_LEVEL: "off" | "error" | "warn" | "info" | "debug" | "trace"
+*   - __SUBSTRATE_LOG_COMPONENTS: string[] - filter to specific components (empty = all)
+*
+* Or via API:
+*   - setLogLevel("debug")
+*   - setLogComponents(["vfs", "proc"])
+*/
+/**
+* Capture the original browser console at module load time.
+*
+* CRITICAL: runWithGlobals() replaces globalThis.console with a child process
+* console that routes output to process stdout/stderr. If our internal logging
+* used globalThis.console, it would cause infinite recursion:
+*
+*   1. User code: console.log("hello")
+*   2. Custom console → processContext.writeStdout()
+*   3. writeStdout() → procLog.trace() → console.debug() (OOPS! globalThis.console is replaced)
+*   4. Custom console → processContext.writeStdout()
+*   5. → infinite recursion → stack overflow
+*
+* By capturing the original console here, our internal logging always goes
+* to the real browser console, never to a child process's stdout.
+*/
+const _console = console;
+/** Log level ordering (higher = more verbose) */
+const LOG_LEVEL_ORDER = {
+	off: 0,
+	error: 1,
+	warn: 2,
+	info: 3,
+	debug: 4,
+	trace: 5
+};
+/** Get current log level from global config */
+function getLogLevel() {
+	const level = globalThis.__SUBSTRATE_LOG_LEVEL;
+	if (typeof level === "string" && level in LOG_LEVEL_ORDER) return level;
+	return "info";
+}
+/** Set log level at runtime */
+function setLogLevel(level) {
+	globalThis.__SUBSTRATE_LOG_LEVEL = level;
+}
+/** Get component filter */
+function getLogComponents() {
+	const components = globalThis.__SUBSTRATE_LOG_COMPONENTS;
+	if (Array.isArray(components)) return components;
+	return [];
+}
+/** Set component filter at runtime */
+function setLogComponents(components) {
+	globalThis.__SUBSTRATE_LOG_COMPONENTS = components;
+}
+/** Check if a log should be emitted based on current config */
+function shouldLog(level, component) {
+	const configLevel = getLogLevel();
+	const configComponents = getLogComponents();
+	if (LOG_LEVEL_ORDER[level] > LOG_LEVEL_ORDER[configLevel]) return false;
+	if (configComponents.length > 0) {
+		if (!configComponents.some((pattern) => {
+			if (pattern.endsWith("*")) return component.startsWith(pattern.slice(0, -1));
+			return component === pattern;
+		})) return false;
+	}
+	return true;
+}
+/** Color codes for different log levels (for browser/terminal) */
+const LEVEL_COLORS = {
+	off: "",
+	error: "color: #ff5555; font-weight: bold",
+	warn: "color: #ffaa00; font-weight: bold",
+	info: "color: #55aaff",
+	debug: "color: #888888",
+	trace: "color: #666666"
+};
+/** Create a logger for a specific component */
+function createLogger(component) {
+	const emit = (level, ...args) => {
+		if (level === "off") return;
+		if (!shouldLog(level, component)) return;
+		const prefix = `[${component}]`;
+		const timestamp = (/* @__PURE__ */ new Date()).toISOString().split("T")[1]?.slice(0, -1) ?? "";
+		switch (level) {
+			case "error":
+				_console.error(`%c${timestamp} ${level.toUpperCase()} ${prefix}`, LEVEL_COLORS[level], ...args);
+				break;
+			case "warn":
+				_console.warn(`%c${timestamp} ${level.toUpperCase()} ${prefix}`, LEVEL_COLORS[level], ...args);
+				break;
+			case "info":
+				_console.info(`%c${timestamp} ${level.toUpperCase()} ${prefix}`, LEVEL_COLORS[level], ...args);
+				break;
+			case "debug":
+				_console.debug(`%c${timestamp} ${level.toUpperCase()} ${prefix}`, LEVEL_COLORS[level], ...args);
+				break;
+			case "trace":
+				_console.debug(`%c${timestamp} ${level.toUpperCase()} ${prefix}`, LEVEL_COLORS[level], ...args);
+				break;
+		}
+	};
+	return {
+		error: (...args) => emit("error", ...args),
+		warn: (...args) => emit("warn", ...args),
+		info: (...args) => emit("info", ...args),
+		debug: (...args) => emit("debug", ...args),
+		trace: (...args) => emit("trace", ...args),
+		log: emit
+	};
+}
+/** Kernel logger */
+const kernelLog = createLogger("kernel");
+/** VFS logger */
+const vfsLog = createLogger("vfs");
+/** Process logger */
+const procLog = createLogger("proc");
+/** Network logger */
+const netLog = createLogger("net");
+/** Event loop logger */
+const eventLog = createLogger("events");
+/** Module loader logger */
+const moduleLog = createLogger("module");
+/** ESM loader logger */
+const esmLog = createLogger("esm");
+/** HTTP logger */
+const httpLog = createLogger("http");
+/** WebSocket logger */
+const wsLog = createLogger("ws");
+/** Child process logger */
+const childLog = createLogger("child_process");
+/** Buffer logger */
+const bufferLog = createLogger("buffer");
+/** Stream logger */
+const streamLog = createLogger("stream");
+/** FS logger */
+const fsLog = createLogger("fs");
+/** Worker logger (for worker/client communication) */
+const workerLog = createLogger("worker");
+/** Runtime logger */
+const runtimeLog = createLogger("runtime");
+
+//#endregion
+//#region packages/substrate/src/kernel/wasm.ts
+/**
+* Substrate CDN asset URLs.
+*
+* Assets (kernel WASM, runtime worker, network driver) are distributed via
+* the Gadget CDN at versioned paths. They also ship inside the npm package
+* under dist/assets/ for consumers who want to self-host.
+*/
+/** CDN base URL for all Substrate assets. */
+const SUBSTRATE_CDN_BASE = "https://assets.gadget.dev/substrate";
+/** Package version — kept in sync by scripts/release.mjs. */
+const SUBSTRATE_VERSION = "0.1.0-rc.1";
+/** Get the CDN URL for the kernel WASM binary. */
+function getKernelUrl(version = SUBSTRATE_VERSION) {
+	return `${SUBSTRATE_CDN_BASE}/v${version}/kernel.wasm`;
+}
+/** Get the CDN URL for the Substrate runtime bundle. */
+function getRuntimeUrl(version = SUBSTRATE_VERSION) {
+	return `${SUBSTRATE_CDN_BASE}/v${version}/runtime.js`;
+}
+/** Get the CDN URL for the Substrate network driver bundle. */
+function getNetworkDriverUrl(version = SUBSTRATE_VERSION) {
+	return `${SUBSTRATE_CDN_BASE}/v${version}/network-driver.js`;
+}
+/** Get the CDN URL for a binary tarball (e.g., npm, yarn, pnpm). */
+function getBinaryTarballUrl(binary, binaryVersion, version = SUBSTRATE_VERSION) {
+	return `${SUBSTRATE_CDN_BASE}/v${version}/${binary}-${binaryVersion}-bundle.tgz`;
+}
+
+//#endregion
+//#region packages/substrate/src/utils/path.ts
+/**
+* Normalize a path, resolving '..' and '.' segments
+*/
+function normalize(path) {
+	if (path.length === 0) return ".";
+	const isAbsolute = path.charCodeAt(0) === 47;
+	const trailingSlash = path.charCodeAt(path.length - 1) === 47;
+	const segments = path.split("/");
+	const result = [];
+	for (const segment of segments) {
+		if (segment === "" || segment === ".") continue;
+		if (segment === "..") {
+			if (result.length > 0 && result[result.length - 1] !== "..") result.pop();
+			else if (!isAbsolute) result.push("..");
+		} else result.push(segment);
+	}
+	let normalized = result.join("/");
+	if (isAbsolute) normalized = "/" + normalized;
+	if (trailingSlash && normalized.length > 1) normalized += "/";
+	return normalized || (isAbsolute ? "/" : ".");
+}
+/**
+* Join path segments
+*/
+function join(...paths) {
+	if (paths.length === 0) return ".";
+	let joined = "";
+	for (const path of paths) if (path.length > 0) if (joined.length === 0) joined = path;
+	else joined += "/" + path;
+	return normalize(joined);
+}
+
+//#endregion
+//#region packages/substrate/src/binaries.ts
+/**
+* Binary Configuration
+*
+* Central configuration for all binaries that Substrate can install and run.
+* This module is the source of truth for:
+* - Binary versions
+* - Binary handlers
+* - Tarball URL generation
+* - Binary specs for initialization
+*/
+/**
+* Default versions for each binary.
+* Update these when upgrading binary versions.
+*/
+const BINARY_VERSIONS = {
+	npm: "11.8.0",
+	pnpm: "10.6.4",
+	yarn: "1.22.22"
+};
+/**
+* Get the default tarball URL for a binary.
+*
+* When no baseUrl is provided, returns the CDN URL for the binary tarball.
+* When a baseUrl is provided, returns a relative path under that base.
+*
+* @param binary - The binary name
+* @param baseUrl - Base URL prefix. If omitted, uses the Gadget CDN.
+* @returns The full tarball URL
+*/
+function getDefaultTarballUrl(binary, baseUrl) {
+	const version = BINARY_VERSIONS[binary];
+	if (baseUrl !== void 0) return join(baseUrl, `${binary}-${version}-bundle.tgz`);
+	return getBinaryTarballUrl(binary, version);
+}
+/**
+* Get all binary names
+*/
+function getBinaryNames() {
+	return Object.keys(BINARY_VERSIONS);
+}
+
+//#endregion
+//#region packages/substrate/src/boot/index.ts
+/**
+* Substrate Bootloader
+*
+* Consolidates all Substrate initialization:
+* - Service Worker registration and activation
+* - Multi-tab coordination (via thumbdrive's MultiTabWorkerBroker)
+* - Kernel WASM loading
+* - OPFS filesystem initialization (future)
+*
+* @example
+* ```ts
+* import { bootSubstrate } from '@gadgetinc/substrate/boot';
+*
+* const substrate = await bootSubstrate({
+*   name: 'my-project',
+* });
+*
+* // fetch() and WebSocket just work - SW intercepts transparently
+* const response = await fetch('/api/hello');
+* ```
+*/
+const bootLog = createLogger("boot");
+/** WebSocket ready states */
+const WS_CONNECTING = 0;
+const WS_OPEN = 1;
+const WS_CLOSING = 2;
+const WS_CLOSED = 3;
+/**
+* Internal class that implements the WebSocket API and proxies through the worker.
+*
+* This is NOT exported directly - users access it via `substrate.WebSocket`.
+*/
+var ProxyWebSocket = class extends EventTarget {
+	static CONNECTING = WS_CONNECTING;
+	static OPEN = WS_OPEN;
+	static CLOSING = WS_CLOSING;
+	static CLOSED = WS_CLOSED;
+	url;
+	_readyState = WS_CONNECTING;
+	_protocol = "";
+	_extensions = "";
+	_bufferedAmount = 0;
+	binaryType = "blob";
+	onopen = null;
+	onmessage = null;
+	onerror = null;
+	onclose = null;
+	_wsId;
+	_send;
+	_getNextId;
+	constructor(url, protocols, wsId, send, getNextId) {
+		super();
+		this.url = typeof url === "string" ? url : url.toString();
+		this._wsId = wsId;
+		this._send = send;
+		this._getNextId = getNextId;
+		const protocolArray = Array.isArray(protocols) ? protocols : protocols ? [protocols] : [];
+		queueMicrotask(() => {
+			this._send({
+				type: "ws_connect",
+				id: this._getNextId(),
+				wsId: this._wsId,
+				url: this.url,
+				protocols: protocolArray
+			}).catch((err) => {
+				this._handleError(err instanceof Error ? err.message : String(err));
+			});
+		});
+	}
+	get readyState() {
+		return this._readyState;
+	}
+	get protocol() {
+		return this._protocol;
+	}
+	get extensions() {
+		return this._extensions;
+	}
+	get bufferedAmount() {
+		return this._bufferedAmount;
+	}
+	send(data) {
+		if (this._readyState !== WS_OPEN) throw new DOMException("Failed to execute 'send' on 'WebSocket': Still in CONNECTING state.", "InvalidStateError");
+		let payload;
+		if (typeof data === "string") payload = data;
+		else if (data instanceof ArrayBuffer) payload = new Uint8Array(data);
+		else if (ArrayBuffer.isView(data)) payload = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+		else if (data instanceof Blob) {
+			data.arrayBuffer().then((buffer) => {
+				if (this._readyState === WS_OPEN) this._send({
+					type: "ws_send",
+					id: this._getNextId(),
+					wsId: this._wsId,
+					data: new Uint8Array(buffer)
+				}).catch((err) => {
+					bootLog.error(`Failed to send WebSocket data: ${err instanceof Error ? err.message : String(err)}`);
+				});
+			}).catch((err) => {
+				bootLog.error(`Failed to send WebSocket data: ${err instanceof Error ? err.message : String(err)}`);
+			});
+			return;
+		} else throw new TypeError("Invalid data type");
+		this._send({
+			type: "ws_send",
+			id: this._getNextId(),
+			wsId: this._wsId,
+			data: payload
+		}).catch(() => {});
+	}
+	close(code, reason) {
+		if (this._readyState === WS_CLOSING || this._readyState === WS_CLOSED) return;
+		this._readyState = WS_CLOSING;
+		this._send({
+			type: "ws_close",
+			id: this._getNextId(),
+			wsId: this._wsId,
+			code,
+			reason
+		}).catch(() => {});
+	}
+	_handleOpen(protocol) {
+		if (this._readyState !== WS_CONNECTING) return;
+		this._readyState = WS_OPEN;
+		this._protocol = protocol;
+		const event = new Event("open");
+		this.onopen?.call(this, event);
+		this.dispatchEvent(event);
+	}
+	_handleMessage(data) {
+		if (this._readyState !== WS_OPEN) return;
+		let messageData;
+		if (typeof data === "string") messageData = data;
+		else messageData = data.buffer;
+		const event = new MessageEvent("message", { data: messageData });
+		this.onmessage?.call(this, event);
+		this.dispatchEvent(event);
+	}
+	_handleClose(code, reason, wasClean) {
+		if (this._readyState === WS_CLOSED) return;
+		this._readyState = WS_CLOSED;
+		const event = new CloseEvent("close", {
+			code,
+			reason,
+			wasClean
+		});
+		this.onclose?.call(this, event);
+		this.dispatchEvent(event);
+	}
+	_handleError(message) {
+		const event = new Event("error");
+		event.message = message;
+		this.onerror?.call(this, event);
+		this.dispatchEvent(event);
+		if (this._readyState !== WS_CLOSED) {
+			this._readyState = WS_CLOSED;
+			const closeEvent = new CloseEvent("close", {
+				code: 1006,
+				reason: message,
+				wasClean: false
+			});
+			this.onclose?.call(this, closeEvent);
+			this.dispatchEvent(closeEvent);
+		}
+	}
+};
+/**
+* Register the Service Worker and wait for it to control this page.
+*/
+async function registerServiceWorker(swUrl) {
+	if (!("serviceWorker" in navigator)) throw new Error("Service Workers not supported in this browser");
+	bootLog.debug("Registering Service Worker:", swUrl);
+	const registration = await navigator.serviceWorker.register(swUrl, {
+		scope: "/",
+		type: "module"
+	});
+	if (registration.waiting) registration.waiting.postMessage({ type: "skipWaiting" });
+	if (registration.installing) await new Promise((resolve) => {
+		const worker = registration.installing;
+		worker.addEventListener("statechange", () => {
+			if (worker.state === "activated") resolve();
+		});
+	});
+	registration.addEventListener("updatefound", () => {
+		const newWorker = registration.installing;
+		if (newWorker) {
+			bootLog.debug("SW update found, telling new worker to skip waiting");
+			newWorker.postMessage({ type: "skipWaiting" });
+		}
+	});
+	return registration;
+}
+/**
+* Wait for the Service Worker to control this page.
+*/
+async function waitForServiceWorkerControl() {
+	if (navigator.serviceWorker.controller) {
+		bootLog.debug("Already controlled by Service Worker");
+		return;
+	}
+	bootLog.debug("Waiting for Service Worker control...");
+	return new Promise((resolve) => {
+		navigator.serviceWorker.addEventListener("controllerchange", () => {
+			bootLog.debug("Service Worker now controlling page");
+			resolve();
+		}, { once: true });
+		navigator.serviceWorker.ready.then((registration) => {
+			registration.active?.postMessage({ type: "claim" });
+		});
+	});
+}
+/**
+* Send routing configuration to the Service Worker.
+*
+* Also watches for controller changes (e.g., when a new SW activates via
+* skipWaiting during development) and re-sends the config so the new SW
+* has the basePath and other routing state.
+*/
+function configureServiceWorker(registration, config) {
+	const sendConfig = () => {
+		const worker = registration.active ?? navigator.serviceWorker.controller;
+		if (worker) {
+			bootLog.debug("Sending routing config to SW");
+			worker.postMessage({
+				type: "config",
+				config
+			});
+		}
+	};
+	sendConfig();
+	navigator.serviceWorker.addEventListener("controllerchange", () => {
+		bootLog.debug("SW controller changed, re-sending config");
+		sendConfig();
+	});
+}
+/**
+* Get the URL to the Substrate runtime entrypoint.
+* Returns the CDN URL by default.
+*/
+function getRuntimeURL() {
+	return new URL(getRuntimeUrl());
+}
+/**
+* Boot Substrate with Service Worker network interception and multi-tab coordination.
+*
+* This must be called early in your application, before any requests that should
+* be intercepted by the Service Worker.
+*
+* @example
+* ```ts
+* const substrate = await bootSubstrate({
+*   name: 'my-project',
+* });
+*
+* await substrate.mount({
+*   'server.js': { file: { contents: '...' } }
+* });
+*
+* substrate.spawn('node', ['server.js']);
+*
+* // fetch() just works - SW intercepts automatically
+* await substrate.waitForPort(3000);
+* const res = await fetch('http://localhost:3000/');
+* ```
+*/
+async function bootSubstrate(config = {}) {
+	const networkDriverUrl = config.networkDriverUrl ?? getNetworkDriverUrl();
+	const basePath = config.basePath ?? null;
+	const basePathPort = config.basePathPort ?? null;
+	const registration = await registerServiceWorker(networkDriverUrl);
+	await waitForServiceWorkerControl();
+	const routingConfig = {
+		basePath,
+		basePathPort,
+		listeningPorts: [],
+		proxyUrl: config.proxyUrl,
+		neverProxy: config.neverProxy ?? [],
+		logging: config.logging
+	};
+	const client = await createSubstrateClient(config, routingConfig, registration);
+	patchGlobalWebSocket(client, routingConfig);
+	if (config.persistence?.storeName) window.addEventListener("beforeunload", () => {
+		client.persist().catch(() => {});
+	});
+	return client;
+}
+/**
+* Patch globalThis.WebSocket to route localhost connections through Substrate.
+*
+* This allows code in the boot tab to use `new WebSocket('ws://localhost:PORT')`
+* and have it automatically connect to virtual servers running in Substrate.
+*/
+function patchGlobalWebSocket(client, routingConfig) {
+	const NativeWebSocket = globalThis.WebSocket;
+	const PatchedWebSocket = function(url, protocols) {
+		const urlString = typeof url === "string" ? url : url.toString();
+		const parsedUrl = new URL(urlString, globalThis.location?.href);
+		if (parsedUrl.hostname === "localhost" || parsedUrl.hostname === "127.0.0.1") {
+			const port = parseInt(parsedUrl.port) || (parsedUrl.protocol === "wss:" ? 443 : 80);
+			if (routingConfig.listeningPorts.includes(port)) {
+				bootLog.debug(`Routing WebSocket to Substrate: ${urlString}`);
+				return new client.WebSocket(url, protocols);
+			}
+		}
+		return new NativeWebSocket(url, protocols);
+	};
+	Object.defineProperties(PatchedWebSocket, {
+		CONNECTING: {
+			value: NativeWebSocket.CONNECTING,
+			writable: false
+		},
+		OPEN: {
+			value: NativeWebSocket.OPEN,
+			writable: false
+		},
+		CLOSING: {
+			value: NativeWebSocket.CLOSING,
+			writable: false
+		},
+		CLOSED: {
+			value: NativeWebSocket.CLOSED,
+			writable: false
+		}
+	});
+	Object.setPrototypeOf(PatchedWebSocket.prototype, NativeWebSocket.prototype);
+	globalThis.WebSocket = PatchedWebSocket;
+	bootLog.debug("Patched globalThis.WebSocket for Substrate routing");
+}
+/**
+* Create a Substrate client that communicates with the worker.
+*
+* Uses MultiTabWorkerBroker for leader election - only one tab runs the kernel,
+* other tabs communicate through BroadcastChannel.
+*/
+async function createSubstrateClient(config, routingConfig, registration) {
+	const runtimeUrl = config.runtimeUrl ? new URL(config.runtimeUrl.toString(), location.href) : getRuntimeURL();
+	const lockName = `substrate:${config.name ?? "default"}`;
+	const networkChannel = new BroadcastChannel("substrate:network");
+	let nextId = 1;
+	const pending = /* @__PURE__ */ new Map();
+	const listeningPorts = /* @__PURE__ */ new Set();
+	const portListeners = /* @__PURE__ */ new Map();
+	const processExitResolvers = /* @__PURE__ */ new Map();
+	const pendingExits = /* @__PURE__ */ new Map();
+	const processOutputControllers = /* @__PURE__ */ new Map();
+	const pendingOutput = /* @__PURE__ */ new Map();
+	const leadershipListeners = [];
+	let nextWsId = 1;
+	const activeWebSockets = /* @__PURE__ */ new Map();
+	const servedPageWsClients = /* @__PURE__ */ new Map();
+	let currentIsLeader = false;
+	const { promise: leadershipKnown, resolve: resolveLeadership } = Promise.withResolvers();
+	const broker = new MultiTabWorkerBroker(lockName, () => {
+		bootLog.debug("Creating worker (this tab is becoming leader)");
+		currentIsLeader = true;
+		resolveLeadership(true);
+		return new Worker(runtimeUrl, { type: "module" });
+	});
+	await broker.start();
+	setTimeout(() => resolveLeadership(false), 100);
+	currentIsLeader = await leadershipKnown;
+	bootLog.debug(`Broker started, isLeader=${currentIsLeader}`);
+	const connection = broker.createConnection();
+	let readyResolve = null;
+	const readyPromise = new Promise((resolve, reject) => {
+		readyResolve = resolve;
+		setTimeout(() => reject(/* @__PURE__ */ new Error("Worker timeout")), 1e4);
+	});
+	connection.reader.listen((raw) => {
+		const msg = raw;
+		switch (msg.type) {
+			case "success": {
+				if (msg.id === void 0) break;
+				const p = pending.get(msg.id);
+				if (p) {
+					pending.delete(msg.id);
+					p.resolve(msg.result);
+				}
+				break;
+			}
+			case "error": {
+				if (msg.id === void 0) break;
+				const p = pending.get(msg.id);
+				if (p) {
+					pending.delete(msg.id);
+					const err = new Error(msg.error.message);
+					if (msg.error.code) err.code = msg.error.code;
+					if (msg.error.stack) err.stack = msg.error.stack;
+					p.reject(err);
+				}
+				break;
+			}
+			case "log":
+				config.onConsole?.(msg.level, msg.args);
+				break;
+			case "port_listen": {
+				const port = msg.port;
+				listeningPorts.add(port);
+				if (!routingConfig.listeningPorts.includes(port)) routingConfig.listeningPorts.push(port);
+				registration.active?.postMessage({
+					type: "port_listen",
+					port
+				});
+				networkChannel.postMessage({
+					type: "port_listen",
+					port
+				});
+				config.onPortListen?.(port);
+				const listeners = portListeners.get(port);
+				if (listeners) {
+					for (const resolve of listeners) resolve();
+					portListeners.delete(port);
+				}
+				break;
+			}
+			case "port_close": {
+				const port = msg.port;
+				listeningPorts.delete(port);
+				const idx = routingConfig.listeningPorts.indexOf(port);
+				if (idx !== -1) routingConfig.listeningPorts.splice(idx, 1);
+				registration.active?.postMessage({
+					type: "port_close",
+					port
+				});
+				networkChannel.postMessage({
+					type: "port_close",
+					port
+				});
+				config.onPortClose?.(port);
+				break;
+			}
+			case "proc_exit": {
+				const resolver = processExitResolvers.get(msg.pid);
+				processOutputControllers.delete(msg.pid);
+				pendingOutput.delete(msg.pid);
+				if (resolver) {
+					processExitResolvers.delete(msg.pid);
+					resolver(msg.exitCode);
+				} else pendingExits.set(msg.pid, msg.exitCode);
+				break;
+			}
+			case "proc_stdout": {
+				const controllers = processOutputControllers.get(msg.pid);
+				if (controllers?.stdout) controllers.stdout.enqueue(msg.data);
+				else {
+					let p = pendingOutput.get(msg.pid);
+					if (!p) {
+						p = {
+							stdout: [],
+							stderr: []
+						};
+						pendingOutput.set(msg.pid, p);
+					}
+					p.stdout.push(msg.data);
+				}
+				break;
+			}
+			case "proc_stderr": {
+				const controllers = processOutputControllers.get(msg.pid);
+				if (controllers?.stderr) controllers.stderr.enqueue(msg.data);
+				else {
+					let p = pendingOutput.get(msg.pid);
+					if (!p) {
+						p = {
+							stdout: [],
+							stderr: []
+						};
+						pendingOutput.set(msg.pid, p);
+					}
+					p.stderr.push(msg.data);
+				}
+				break;
+			}
+			case "ws_open": {
+				const openWs = activeWebSockets.get(msg.wsId);
+				if (openWs) openWs._handleOpen(msg.protocol ?? "");
+				if (servedPageWsClients.get(msg.wsId)) networkChannel.postMessage({
+					type: "sw_ws_open",
+					wsId: msg.wsId,
+					protocol: msg.protocol
+				});
+				break;
+			}
+			case "ws_message": {
+				const msgWs = activeWebSockets.get(msg.wsId);
+				if (msgWs) msgWs._handleMessage(msg.data);
+				if (servedPageWsClients.get(msg.wsId)) networkChannel.postMessage({
+					type: "sw_ws_message",
+					wsId: msg.wsId,
+					data: msg.data
+				});
+				break;
+			}
+			case "ws_close": {
+				const closeWs = activeWebSockets.get(msg.wsId);
+				if (closeWs) {
+					closeWs._handleClose(msg.code ?? 1e3, msg.reason ?? "", msg.wasClean ?? true);
+					activeWebSockets.delete(msg.wsId);
+				}
+				if (servedPageWsClients.get(msg.wsId)) {
+					networkChannel.postMessage({
+						type: "sw_ws_close",
+						wsId: msg.wsId,
+						code: msg.code,
+						reason: msg.reason,
+						wasClean: msg.wasClean
+					});
+					servedPageWsClients.delete(msg.wsId);
+				}
+				break;
+			}
+			case "ws_error": {
+				const errorWs = activeWebSockets.get(msg.wsId);
+				if (errorWs) {
+					errorWs._handleError(msg.message ?? "WebSocket error");
+					activeWebSockets.delete(msg.wsId);
+				}
+				if (servedPageWsClients.get(msg.wsId)) {
+					networkChannel.postMessage({
+						type: "sw_ws_error",
+						wsId: msg.wsId,
+						message: msg.message
+					});
+					servedPageWsClients.delete(msg.wsId);
+				}
+				break;
+			}
+			case "ready":
+				if (readyResolve) {
+					readyResolve();
+					readyResolve = null;
+				}
+				break;
+		}
+	});
+	networkChannel.onmessage = async (event) => {
+		const msg = event.data;
+		if (!currentIsLeader) return;
+		if (msg.type === "fetch") {
+			try {
+				const fetchUrl = new URL(msg.url);
+				const fetchPort = parseInt(fetchUrl.port) || (fetchUrl.protocol === "https:" ? 443 : 80);
+				if ((fetchUrl.hostname === "localhost" || fetchUrl.hostname === "127.0.0.1") && !listeningPorts.has(fetchPort)) {
+					networkChannel.postMessage({
+						type: "fetch_response",
+						requestId: msg.requestId,
+						status: 0,
+						statusText: "",
+						headers: [],
+						body: null,
+						error: `connect ECONNREFUSED 127.0.0.1:${fetchPort}`
+					});
+					return;
+				}
+			} catch {}
+			try {
+				const response = await handleFetchFromSWViaBroker(msg, connection.writer, pending, nextId++);
+				networkChannel.postMessage(response);
+			} catch (err) {
+				networkChannel.postMessage({
+					type: "fetch_response",
+					requestId: msg.requestId,
+					status: 500,
+					statusText: "Internal Server Error",
+					headers: [],
+					body: new TextEncoder().encode(String(err))
+				});
+			}
+		} else if (msg.type === "sw_ws_connect") {
+			bootLog.debug("sw_ws_connect:", msg.wsId, msg.url);
+			servedPageWsClients.set(msg.wsId, msg.clientId);
+			send({
+				type: "ws_connect",
+				id: nextId++,
+				wsId: msg.wsId,
+				url: msg.url,
+				protocols: msg.protocols
+			}).catch((err) => {
+				bootLog.error("Error connecting WebSocket:", err);
+				networkChannel.postMessage({
+					type: "sw_ws_error",
+					wsId: msg.wsId,
+					message: err instanceof Error ? err.message : String(err)
+				});
+				servedPageWsClients.delete(msg.wsId);
+			});
+		} else if (msg.type === "sw_ws_send") {
+			bootLog.trace("sw_ws_send:", msg.wsId);
+			send({
+				type: "ws_send",
+				id: nextId++,
+				wsId: msg.wsId,
+				data: msg.data
+			}).catch((err) => {
+				bootLog.error("Error sending WebSocket data:", err);
+			});
+		} else if (msg.type === "sw_ws_close") {
+			bootLog.debug("sw_ws_close:", msg.wsId);
+			send({
+				type: "ws_close",
+				id: nextId++,
+				wsId: msg.wsId,
+				code: msg.code,
+				reason: msg.reason
+			}).catch((err) => {
+				bootLog.error("Error closing WebSocket:", err);
+			});
+		}
+	};
+	const send = (req) => {
+		return new Promise((resolve, reject) => {
+			pending.set(req.id, {
+				resolve,
+				reject
+			});
+			connection.writer.write({
+				...req,
+				method: req.type
+			}).catch(reject);
+		});
+	};
+	if (currentIsLeader) {
+		configureServiceWorker(registration, routingConfig);
+		await readyPromise;
+		const binaries = {};
+		for (const binaryName of getBinaryNames()) {
+			const spec = config.binaries?.[binaryName];
+			if (spec === true || spec === void 0) binaries[binaryName] = { tarUrl: getDefaultTarballUrl(binaryName, config.binaryTarballBaseUrl) };
+			else if (spec) binaries[binaryName] = spec;
+		}
+		await send({
+			type: "init",
+			id: nextId++,
+			kernel: config.kernelUrl ?? getKernelUrl(),
+			cwd: config.cwd ?? "/",
+			env: config.env ?? { NODE_ENV: "development" },
+			config: {
+				features: {
+					net_listen: true,
+					fs_watch: true,
+					timers: true,
+					proc_spawn: true
+				},
+				storeName: config.persistence?.storeName
+			},
+			logging: config.logging,
+			debug: config.debug,
+			binaries,
+			wasmPackages: config.wasmPackages
+		});
+	} else {
+		readyPromise.catch(() => {});
+		readyResolve = null;
+		bootLog.debug("Follower tab connected to existing runtime");
+		try {
+			const result = await send({
+				type: "http_listen",
+				id: nextId++
+			});
+			if (result?.ports) {
+				for (const port of result.ports) {
+					listeningPorts.add(port);
+					if (!routingConfig.listeningPorts.includes(port)) routingConfig.listeningPorts.push(port);
+				}
+				bootLog.debug("Synced listening ports from leader:", result.ports);
+			}
+		} catch {
+			bootLog.debug("Could not sync listening ports from leader");
+		}
+	}
+	const serializeTree = (tree) => {
+		const result = {};
+		for (const [name, node] of Object.entries(tree)) if ("file" in node) {
+			const contents = node.file.contents;
+			result[name] = { file: { contents: typeof contents === "string" ? contents : Array.from(contents) } };
+		} else if ("directory" in node) result[name] = { directory: serializeTree(node.directory) };
+		return result;
+	};
+	return {
+		get isLeader() {
+			return broker.isLeader;
+		},
+		async mount(tree, mountPoint = "/") {
+			await send({
+				type: "syscall",
+				id: nextId++,
+				op: "mount",
+				args: {
+					tree: serializeTree(tree),
+					mountPoint
+				}
+			});
+		},
+		async readFile(path) {
+			return (await send({
+				type: "syscall",
+				id: nextId++,
+				op: "fs_read_file",
+				args: { path }
+			})).content;
+		},
+		async writeFile(path, content) {
+			await send({
+				type: "syscall",
+				id: nextId++,
+				op: "fs_write_file",
+				args: {
+					path,
+					content
+				}
+			});
+		},
+		spawn(command, args = [], options = {}) {
+			let stdoutController;
+			let stderrController;
+			let stdoutClosed = false;
+			let stderrClosed = false;
+			const stdoutStream = new ReadableStream({ start(controller) {
+				stdoutController = controller;
+			} });
+			const stderrStream = new ReadableStream({ start(controller) {
+				stderrController = controller;
+			} });
+			const closeStdout = () => {
+				if (!stdoutClosed) {
+					stdoutClosed = true;
+					try {
+						stdoutController.close();
+					} catch {}
+				}
+			};
+			const closeStderr = () => {
+				if (!stderrClosed) {
+					stderrClosed = true;
+					try {
+						stderrController.close();
+					} catch {}
+				}
+			};
+			const { promise: exit, resolve: resolveExit } = Promise.withResolvers();
+			const { promise: pidPromise, resolve: resolvePid } = Promise.withResolvers();
+			let exitResolved = false;
+			let pid;
+			send({
+				type: "syscall",
+				id: nextId++,
+				op: "spawn",
+				args: {
+					command,
+					args,
+					options: {
+						cwd: options.cwd,
+						env: options.env
+					}
+				}
+			}).then((result) => {
+				pid = result.pid;
+				resolvePid(pid);
+				processOutputControllers.set(pid, {
+					stdout: stdoutController,
+					stderr: stderrController
+				});
+				const p = pendingOutput.get(pid);
+				if (p) {
+					for (const d of p.stdout) stdoutController.enqueue(d);
+					for (const d of p.stderr) stderrController.enqueue(d);
+					pendingOutput.delete(pid);
+				}
+				const pendingExit = pendingExits.get(pid);
+				if (pendingExit !== void 0) {
+					pendingExits.delete(pid);
+					closeStdout();
+					closeStderr();
+					if (!exitResolved) {
+						exitResolved = true;
+						resolveExit(pendingExit);
+					}
+				} else processExitResolvers.set(pid, (code) => {
+					closeStdout();
+					closeStderr();
+					if (!exitResolved) {
+						exitResolved = true;
+						resolveExit(code);
+					}
+				});
+			}).catch((err) => {
+				closeStdout();
+				closeStderr();
+				if (!exitResolved) {
+					exitResolved = true;
+					resolveExit(1);
+				}
+				resolvePid(-1);
+				bootLog.error("Spawn failed:", err);
+			});
+			return {
+				pid: pidPromise,
+				stdout: stdoutStream,
+				stderr: stderrStream,
+				exit,
+				kill: () => {
+					if (pid !== void 0) send({
+						type: "syscall",
+						id: nextId++,
+						op: "proc_kill",
+						args: {
+							pid,
+							signal: "SIGTERM"
+						}
+					});
+				}
+			};
+		},
+		waitForPort(port, timeout = 3e4) {
+			if (listeningPorts.has(port)) return Promise.resolve();
+			return new Promise((resolve, reject) => {
+				const timer = setTimeout(() => reject(/* @__PURE__ */ new Error(`Timeout waiting for port ${port}`)), timeout);
+				if (!portListeners.has(port)) portListeners.set(port, []);
+				portListeners.get(port).push(() => {
+					clearTimeout(timer);
+					resolve();
+				});
+			});
+		},
+		isListening(port) {
+			return listeningPorts.has(port);
+		},
+		getListeningPorts() {
+			return Array.from(listeningPorts);
+		},
+		async persist() {
+			await send({
+				type: "flush",
+				id: nextId++
+			});
+		},
+		async mountStore(storeName) {
+			await send({
+				type: "mount_store",
+				id: nextId++,
+				storeName
+			});
+		},
+		async listStores() {
+			return (await send({
+				type: "list_stores",
+				id: nextId++
+			})).stores;
+		},
+		async deleteStore(storeName) {
+			await send({
+				type: "delete_store",
+				id: nextId++,
+				storeName
+			});
+		},
+		async terminate() {
+			networkChannel.close();
+			await send({
+				type: "shutdown",
+				id: nextId++
+			}).catch(() => {});
+			broker.stop();
+		},
+		async listProcesses(options) {
+			return (await send({
+				type: "syscall",
+				id: nextId++,
+				op: "proc_list",
+				args: { include_exited: options?.includeExited ?? false }
+			})).processes;
+		},
+		on(event, callback) {
+			if (event === "leadership") leadershipListeners.push(callback);
+		},
+		WebSocket: Object.assign(function(url, protocols) {
+			const wsId = nextWsId++;
+			const ws = new ProxyWebSocket(url, protocols, wsId, send, () => nextId++);
+			activeWebSockets.set(wsId, ws);
+			return ws;
+		}, {
+			CONNECTING: WS_CONNECTING,
+			OPEN: WS_OPEN,
+			CLOSING: WS_CLOSING,
+			CLOSED: WS_CLOSED
+		})
+	};
+}
+/**
+* Handle a fetch request forwarded from the Service Worker.
+* Uses the broker to send the request to the worker (via leader tab if not leader).
+*/
+async function handleFetchFromSWViaBroker(msg, writer, pending, id) {
+	const result = await new Promise((resolve, reject) => {
+		pending.set(id, {
+			resolve,
+			reject
+		});
+		writer.write({
+			type: "http_fetch",
+			id,
+			url: msg.url,
+			method: msg.method,
+			headers: msg.headers,
+			body: msg.body
+		}).catch(reject);
+	});
+	return {
+		type: "fetch_response",
+		requestId: msg.requestId,
+		status: result.status,
+		statusText: result.status === 200 ? "OK" : "Error",
+		headers: result.headers,
+		body: result.body
+	};
+}
+
+//#endregion
+export { bootSubstrate, setLogComponents, setLogLevel };
+//# sourceMappingURL=index.js.map