@chrrxs/robloxstudio-mcp-inspector 3.0.2 → 3.0.4

package/dist/index.js

@@ -1,4 +1,1937 @@
 #!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/xmlchars/xml/1.0/ed5.js
+var require_ed5 = __commonJS({
+  "../../node_modules/xmlchars/xml/1.0/ed5.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.CHAR = "	\n\r -\uD7FF\uE000-\uFFFD\u{10000}-\u{10FFFF}";
+    exports.S = " 	\r\n";
+    exports.NAME_START_CHAR = ":A-Z_a-z\xC0-\xD6\xD8-\xF6\xF8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u{10000}-\u{EFFFF}";
+    exports.NAME_CHAR = "-" + exports.NAME_START_CHAR + ".0-9\xB7\u0300-\u036F\u203F-\u2040";
+    exports.CHAR_RE = new RegExp("^[" + exports.CHAR + "]$", "u");
+    exports.S_RE = new RegExp("^[" + exports.S + "]+$", "u");
+    exports.NAME_START_CHAR_RE = new RegExp("^[" + exports.NAME_START_CHAR + "]$", "u");
+    exports.NAME_CHAR_RE = new RegExp("^[" + exports.NAME_CHAR + "]$", "u");
+    exports.NAME_RE = new RegExp("^[" + exports.NAME_START_CHAR + "][" + exports.NAME_CHAR + "]*$", "u");
+    exports.NMTOKEN_RE = new RegExp("^[" + exports.NAME_CHAR + "]+$", "u");
+    var TAB = 9;
+    var NL = 10;
+    var CR = 13;
+    var SPACE = 32;
+    exports.S_LIST = [SPACE, NL, CR, TAB];
+    function isChar(c) {
+      return c >= SPACE && c <= 55295 || c === NL || c === CR || c === TAB || c >= 57344 && c <= 65533 || c >= 65536 && c <= 1114111;
+    }
+    exports.isChar = isChar;
+    function isS(c) {
+      return c === SPACE || c === NL || c === CR || c === TAB;
+    }
+    exports.isS = isS;
+    function isNameStartChar(c) {
+      return c >= 65 && c <= 90 || c >= 97 && c <= 122 || c === 58 || c === 95 || c === 8204 || c === 8205 || c >= 192 && c <= 214 || c >= 216 && c <= 246 || c >= 248 && c <= 767 || c >= 880 && c <= 893 || c >= 895 && c <= 8191 || c >= 8304 && c <= 8591 || c >= 11264 && c <= 12271 || c >= 12289 && c <= 55295 || c >= 63744 && c <= 64975 || c >= 65008 && c <= 65533 || c >= 65536 && c <= 983039;
+    }
+    exports.isNameStartChar = isNameStartChar;
+    function isNameChar(c) {
+      return isNameStartChar(c) || c >= 48 && c <= 57 || c === 45 || c === 46 || c === 183 || c >= 768 && c <= 879 || c >= 8255 && c <= 8256;
+    }
+    exports.isNameChar = isNameChar;
+  }
+});
+
+// ../../node_modules/xmlchars/xml/1.1/ed2.js
+var require_ed2 = __commonJS({
+  "../../node_modules/xmlchars/xml/1.1/ed2.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.CHAR = "
-\uD7FF\uE000-\uFFFD\u{10000}-\u{10FFFF}";
+    exports.RESTRICTED_CHAR = "
-\b\v\f-\x7F-\x84\x86-\x9F";
+    exports.S = " 	\r\n";
+    exports.NAME_START_CHAR = ":A-Z_a-z\xC0-\xD6\xD8-\xF6\xF8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u{10000}-\u{EFFFF}";
+    exports.NAME_CHAR = "-" + exports.NAME_START_CHAR + ".0-9\xB7\u0300-\u036F\u203F-\u2040";
+    exports.CHAR_RE = new RegExp("^[" + exports.CHAR + "]$", "u");
+    exports.RESTRICTED_CHAR_RE = new RegExp("^[" + exports.RESTRICTED_CHAR + "]$", "u");
+    exports.S_RE = new RegExp("^[" + exports.S + "]+$", "u");
+    exports.NAME_START_CHAR_RE = new RegExp("^[" + exports.NAME_START_CHAR + "]$", "u");
+    exports.NAME_CHAR_RE = new RegExp("^[" + exports.NAME_CHAR + "]$", "u");
+    exports.NAME_RE = new RegExp("^[" + exports.NAME_START_CHAR + "][" + exports.NAME_CHAR + "]*$", "u");
+    exports.NMTOKEN_RE = new RegExp("^[" + exports.NAME_CHAR + "]+$", "u");
+    var TAB = 9;
+    var NL = 10;
+    var CR = 13;
+    var SPACE = 32;
+    exports.S_LIST = [SPACE, NL, CR, TAB];
+    function isChar(c) {
+      return c >= 1 && c <= 55295 || c >= 57344 && c <= 65533 || c >= 65536 && c <= 1114111;
+    }
+    exports.isChar = isChar;
+    function isRestrictedChar(c) {
+      return c >= 1 && c <= 8 || c === 11 || c === 12 || c >= 14 && c <= 31 || c >= 127 && c <= 132 || c >= 134 && c <= 159;
+    }
+    exports.isRestrictedChar = isRestrictedChar;
+    function isCharAndNotRestricted(c) {
+      return c === 9 || c === 10 || c === 13 || c > 31 && c < 127 || c === 133 || c > 159 && c <= 55295 || c >= 57344 && c <= 65533 || c >= 65536 && c <= 1114111;
+    }
+    exports.isCharAndNotRestricted = isCharAndNotRestricted;
+    function isS(c) {
+      return c === SPACE || c === NL || c === CR || c === TAB;
+    }
+    exports.isS = isS;
+    function isNameStartChar(c) {
+      return c >= 65 && c <= 90 || c >= 97 && c <= 122 || c === 58 || c === 95 || c === 8204 || c === 8205 || c >= 192 && c <= 214 || c >= 216 && c <= 246 || c >= 248 && c <= 767 || c >= 880 && c <= 893 || c >= 895 && c <= 8191 || c >= 8304 && c <= 8591 || c >= 11264 && c <= 12271 || c >= 12289 && c <= 55295 || c >= 63744 && c <= 64975 || c >= 65008 && c <= 65533 || c >= 65536 && c <= 983039;
+    }
+    exports.isNameStartChar = isNameStartChar;
+    function isNameChar(c) {
+      return isNameStartChar(c) || c >= 48 && c <= 57 || c === 45 || c === 46 || c === 183 || c >= 768 && c <= 879 || c >= 8255 && c <= 8256;
+    }
+    exports.isNameChar = isNameChar;
+  }
+});
+
+// ../../node_modules/xmlchars/xmlns/1.0/ed3.js
+var require_ed3 = __commonJS({
+  "../../node_modules/xmlchars/xmlns/1.0/ed3.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.NC_NAME_START_CHAR = "A-Z_a-z\xC0-\xD6\xD8-\xF6\xF8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u{10000}-\u{EFFFF}";
+    exports.NC_NAME_CHAR = "-" + exports.NC_NAME_START_CHAR + ".0-9\xB7\u0300-\u036F\u203F-\u2040";
+    exports.NC_NAME_START_CHAR_RE = new RegExp("^[" + exports.NC_NAME_START_CHAR + "]$", "u");
+    exports.NC_NAME_CHAR_RE = new RegExp("^[" + exports.NC_NAME_CHAR + "]$", "u");
+    exports.NC_NAME_RE = new RegExp("^[" + exports.NC_NAME_START_CHAR + "][" + exports.NC_NAME_CHAR + "]*$", "u");
+    function isNCNameStartChar(c) {
+      return c >= 65 && c <= 90 || c === 95 || c >= 97 && c <= 122 || c >= 192 && c <= 214 || c >= 216 && c <= 246 || c >= 248 && c <= 767 || c >= 880 && c <= 893 || c >= 895 && c <= 8191 || c >= 8204 && c <= 8205 || c >= 8304 && c <= 8591 || c >= 11264 && c <= 12271 || c >= 12289 && c <= 55295 || c >= 63744 && c <= 64975 || c >= 65008 && c <= 65533 || c >= 65536 && c <= 983039;
+    }
+    exports.isNCNameStartChar = isNCNameStartChar;
+    function isNCNameChar(c) {
+      return isNCNameStartChar(c) || (c === 45 || c === 46 || c >= 48 && c <= 57 || c === 183 || c >= 768 && c <= 879 || c >= 8255 && c <= 8256);
+    }
+    exports.isNCNameChar = isNCNameChar;
+  }
+});
+
+// ../../node_modules/saxes/saxes.js
+var require_saxes = __commonJS({
+  "../../node_modules/saxes/saxes.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.SaxesParser = exports.EVENTS = void 0;
+    var ed5 = require_ed5();
+    var ed2 = require_ed2();
+    var NSed3 = require_ed3();
+    var isS = ed5.isS;
+    var isChar10 = ed5.isChar;
+    var isNameStartChar = ed5.isNameStartChar;
+    var isNameChar = ed5.isNameChar;
+    var S_LIST = ed5.S_LIST;
+    var NAME_RE = ed5.NAME_RE;
+    var isChar11 = ed2.isChar;
+    var isNCNameStartChar = NSed3.isNCNameStartChar;
+    var isNCNameChar = NSed3.isNCNameChar;
+    var NC_NAME_RE = NSed3.NC_NAME_RE;
+    var XML_NAMESPACE = "http://www.w3.org/XML/1998/namespace";
+    var XMLNS_NAMESPACE = "http://www.w3.org/2000/xmlns/";
+    var rootNS = {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment
+      __proto__: null,
+      xml: XML_NAMESPACE,
+      xmlns: XMLNS_NAMESPACE
+    };
+    var XML_ENTITIES = {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment
+      __proto__: null,
+      amp: "&",
+      gt: ">",
+      lt: "<",
+      quot: '"',
+      apos: "'"
+    };
+    var EOC = -1;
+    var NL_LIKE = -2;
+    var S_BEGIN = 0;
+    var S_BEGIN_WHITESPACE = 1;
+    var S_DOCTYPE = 2;
+    var S_DOCTYPE_QUOTE = 3;
+    var S_DTD = 4;
+    var S_DTD_QUOTED = 5;
+    var S_DTD_OPEN_WAKA = 6;
+    var S_DTD_OPEN_WAKA_BANG = 7;
+    var S_DTD_COMMENT = 8;
+    var S_DTD_COMMENT_ENDING = 9;
+    var S_DTD_COMMENT_ENDED = 10;
+    var S_DTD_PI = 11;
+    var S_DTD_PI_ENDING = 12;
+    var S_TEXT = 13;
+    var S_ENTITY = 14;
+    var S_OPEN_WAKA = 15;
+    var S_OPEN_WAKA_BANG = 16;
+    var S_COMMENT = 17;
+    var S_COMMENT_ENDING = 18;
+    var S_COMMENT_ENDED = 19;
+    var S_CDATA = 20;
+    var S_CDATA_ENDING = 21;
+    var S_CDATA_ENDING_2 = 22;
+    var S_PI_FIRST_CHAR = 23;
+    var S_PI_REST = 24;
+    var S_PI_BODY = 25;
+    var S_PI_ENDING = 26;
+    var S_XML_DECL_NAME_START = 27;
+    var S_XML_DECL_NAME = 28;
+    var S_XML_DECL_EQ = 29;
+    var S_XML_DECL_VALUE_START = 30;
+    var S_XML_DECL_VALUE = 31;
+    var S_XML_DECL_SEPARATOR = 32;
+    var S_XML_DECL_ENDING = 33;
+    var S_OPEN_TAG = 34;
+    var S_OPEN_TAG_SLASH = 35;
+    var S_ATTRIB = 36;
+    var S_ATTRIB_NAME = 37;
+    var S_ATTRIB_NAME_SAW_WHITE = 38;
+    var S_ATTRIB_VALUE = 39;
+    var S_ATTRIB_VALUE_QUOTED = 40;
+    var S_ATTRIB_VALUE_CLOSED = 41;
+    var S_ATTRIB_VALUE_UNQUOTED = 42;
+    var S_CLOSE_TAG = 43;
+    var S_CLOSE_TAG_SAW_WHITE = 44;
+    var TAB = 9;
+    var NL = 10;
+    var CR = 13;
+    var SPACE = 32;
+    var BANG = 33;
+    var DQUOTE = 34;
+    var AMP = 38;
+    var SQUOTE = 39;
+    var MINUS = 45;
+    var FORWARD_SLASH = 47;
+    var SEMICOLON = 59;
+    var LESS = 60;
+    var EQUAL = 61;
+    var GREATER = 62;
+    var QUESTION = 63;
+    var OPEN_BRACKET = 91;
+    var CLOSE_BRACKET = 93;
+    var NEL = 133;
+    var LS = 8232;
+    var isQuote = (c) => c === DQUOTE || c === SQUOTE;
+    var QUOTES = [DQUOTE, SQUOTE];
+    var DOCTYPE_TERMINATOR = [...QUOTES, OPEN_BRACKET, GREATER];
+    var DTD_TERMINATOR = [...QUOTES, LESS, CLOSE_BRACKET];
+    var XML_DECL_NAME_TERMINATOR = [EQUAL, QUESTION, ...S_LIST];
+    var ATTRIB_VALUE_UNQUOTED_TERMINATOR = [...S_LIST, GREATER, AMP, LESS];
+    function nsPairCheck(parser, prefix, uri) {
+      switch (prefix) {
+        case "xml":
+          if (uri !== XML_NAMESPACE) {
+            parser.fail(`xml prefix must be bound to ${XML_NAMESPACE}.`);
+          }
+          break;
+        case "xmlns":
+          if (uri !== XMLNS_NAMESPACE) {
+            parser.fail(`xmlns prefix must be bound to ${XMLNS_NAMESPACE}.`);
+          }
+          break;
+        default:
+      }
+      switch (uri) {
+        case XMLNS_NAMESPACE:
+          parser.fail(prefix === "" ? `the default namespace may not be set to ${uri}.` : `may not assign a prefix (even "xmlns") to the URI ${XMLNS_NAMESPACE}.`);
+          break;
+        case XML_NAMESPACE:
+          switch (prefix) {
+            case "xml":
+              break;
+            case "":
+              parser.fail(`the default namespace may not be set to ${uri}.`);
+              break;
+            default:
+              parser.fail("may not assign the xml namespace to another prefix.");
+          }
+          break;
+        default:
+      }
+    }
+    function nsMappingCheck(parser, mapping) {
+      for (const local of Object.keys(mapping)) {
+        nsPairCheck(parser, local, mapping[local]);
+      }
+    }
+    var isNCName = (name) => NC_NAME_RE.test(name);
+    var isName = (name) => NAME_RE.test(name);
+    var FORBIDDEN_START = 0;
+    var FORBIDDEN_BRACKET = 1;
+    var FORBIDDEN_BRACKET_BRACKET = 2;
+    exports.EVENTS = [
+      "xmldecl",
+      "text",
+      "processinginstruction",
+      "doctype",
+      "comment",
+      "opentagstart",
+      "attribute",
+      "opentag",
+      "closetag",
+      "cdata",
+      "error",
+      "end",
+      "ready"
+    ];
+    var EVENT_NAME_TO_HANDLER_NAME = {
+      xmldecl: "xmldeclHandler",
+      text: "textHandler",
+      processinginstruction: "piHandler",
+      doctype: "doctypeHandler",
+      comment: "commentHandler",
+      opentagstart: "openTagStartHandler",
+      attribute: "attributeHandler",
+      opentag: "openTagHandler",
+      closetag: "closeTagHandler",
+      cdata: "cdataHandler",
+      error: "errorHandler",
+      end: "endHandler",
+      ready: "readyHandler"
+    };
+    var SaxesParser2 = class {
+      /**
+       * @param opt The parser options.
+       */
+      constructor(opt) {
+        this.opt = opt !== null && opt !== void 0 ? opt : {};
+        this.fragmentOpt = !!this.opt.fragment;
+        const xmlnsOpt = this.xmlnsOpt = !!this.opt.xmlns;
+        this.trackPosition = this.opt.position !== false;
+        this.fileName = this.opt.fileName;
+        if (xmlnsOpt) {
+          this.nameStartCheck = isNCNameStartChar;
+          this.nameCheck = isNCNameChar;
+          this.isName = isNCName;
+          this.processAttribs = this.processAttribsNS;
+          this.pushAttrib = this.pushAttribNS;
+          this.ns = Object.assign({ __proto__: null }, rootNS);
+          const additional = this.opt.additionalNamespaces;
+          if (additional != null) {
+            nsMappingCheck(this, additional);
+            Object.assign(this.ns, additional);
+          }
+        } else {
+          this.nameStartCheck = isNameStartChar;
+          this.nameCheck = isNameChar;
+          this.isName = isName;
+          this.processAttribs = this.processAttribsPlain;
+          this.pushAttrib = this.pushAttribPlain;
+        }
+        this.stateTable = [
+          /* eslint-disable @typescript-eslint/unbound-method */
+          this.sBegin,
+          this.sBeginWhitespace,
+          this.sDoctype,
+          this.sDoctypeQuote,
+          this.sDTD,
+          this.sDTDQuoted,
+          this.sDTDOpenWaka,
+          this.sDTDOpenWakaBang,
+          this.sDTDComment,
+          this.sDTDCommentEnding,
+          this.sDTDCommentEnded,
+          this.sDTDPI,
+          this.sDTDPIEnding,
+          this.sText,
+          this.sEntity,
+          this.sOpenWaka,
+          this.sOpenWakaBang,
+          this.sComment,
+          this.sCommentEnding,
+          this.sCommentEnded,
+          this.sCData,
+          this.sCDataEnding,
+          this.sCDataEnding2,
+          this.sPIFirstChar,
+          this.sPIRest,
+          this.sPIBody,
+          this.sPIEnding,
+          this.sXMLDeclNameStart,
+          this.sXMLDeclName,
+          this.sXMLDeclEq,
+          this.sXMLDeclValueStart,
+          this.sXMLDeclValue,
+          this.sXMLDeclSeparator,
+          this.sXMLDeclEnding,
+          this.sOpenTag,
+          this.sOpenTagSlash,
+          this.sAttrib,
+          this.sAttribName,
+          this.sAttribNameSawWhite,
+          this.sAttribValue,
+          this.sAttribValueQuoted,
+          this.sAttribValueClosed,
+          this.sAttribValueUnquoted,
+          this.sCloseTag,
+          this.sCloseTagSawWhite
+          /* eslint-enable @typescript-eslint/unbound-method */
+        ];
+        this._init();
+      }
+      /**
+       * Indicates whether or not the parser is closed. If ``true``, wait for
+       * the ``ready`` event to write again.
+       */
+      get closed() {
+        return this._closed;
+      }
+      _init() {
+        var _a;
+        this.openWakaBang = "";
+        this.text = "";
+        this.name = "";
+        this.piTarget = "";
+        this.entity = "";
+        this.q = null;
+        this.tags = [];
+        this.tag = null;
+        this.topNS = null;
+        this.chunk = "";
+        this.chunkPosition = 0;
+        this.i = 0;
+        this.prevI = 0;
+        this.carriedFromPrevious = void 0;
+        this.forbiddenState = FORBIDDEN_START;
+        this.attribList = [];
+        const { fragmentOpt } = this;
+        this.state = fragmentOpt ? S_TEXT : S_BEGIN;
+        this.reportedTextBeforeRoot = this.reportedTextAfterRoot = this.closedRoot = this.sawRoot = fragmentOpt;
+        this.xmlDeclPossible = !fragmentOpt;
+        this.xmlDeclExpects = ["version"];
+        this.entityReturnState = void 0;
+        let { defaultXMLVersion } = this.opt;
+        if (defaultXMLVersion === void 0) {
+          if (this.opt.forceXMLVersion === true) {
+            throw new Error("forceXMLVersion set but defaultXMLVersion is not set");
+          }
+          defaultXMLVersion = "1.0";
+        }
+        this.setXMLVersion(defaultXMLVersion);
+        this.positionAtNewLine = 0;
+        this.doctype = false;
+        this._closed = false;
+        this.xmlDecl = {
+          version: void 0,
+          encoding: void 0,
+          standalone: void 0
+        };
+        this.line = 1;
+        this.column = 0;
+        this.ENTITIES = Object.create(XML_ENTITIES);
+        (_a = this.readyHandler) === null || _a === void 0 ? void 0 : _a.call(this);
+      }
+      /**
+       * The stream position the parser is currently looking at. This field is
+       * zero-based.
+       *
+       * This field is not based on counting Unicode characters but is to be
+       * interpreted as a plain index into a JavaScript string.
+       */
+      get position() {
+        return this.chunkPosition + this.i;
+      }
+      /**
+       * The column number of the next character to be read by the parser.  *
+       * This field is zero-based. (The first column in a line is 0.)
+       *
+       * This field reports the index at which the next character would be in the
+       * line if the line were represented as a JavaScript string.  Note that this
+       * *can* be different to a count based on the number of *Unicode characters*
+       * due to how JavaScript handles astral plane characters.
+       *
+       * See [[column]] for a number that corresponds to a count of Unicode
+       * characters.
+       */
+      get columnIndex() {
+        return this.position - this.positionAtNewLine;
+      }
+      /**
+       * Set an event listener on an event. The parser supports one handler per
+       * event type. If you try to set an event handler over an existing handler,
+       * the old handler is silently overwritten.
+       *
+       * @param name The event to listen to.
+       *
+       * @param handler The handler to set.
+       */
+      on(name, handler) {
+        this[EVENT_NAME_TO_HANDLER_NAME[name]] = handler;
+      }
+      /**
+       * Unset an event handler.
+       *
+       * @parma name The event to stop listening to.
+       */
+      off(name) {
+        this[EVENT_NAME_TO_HANDLER_NAME[name]] = void 0;
+      }
+      /**
+       * Make an error object. The error object will have a message that contains
+       * the ``fileName`` option passed at the creation of the parser. If position
+       * tracking was turned on, it will also have line and column number
+       * information.
+       *
+       * @param message The message describing the error to report.
+       *
+       * @returns An error object with a properly formatted message.
+       */
+      makeError(message) {
+        var _a;
+        let msg = (_a = this.fileName) !== null && _a !== void 0 ? _a : "";
+        if (this.trackPosition) {
+          if (msg.length > 0) {
+            msg += ":";
+          }
+          msg += `${this.line}:${this.column}`;
+        }
+        if (msg.length > 0) {
+          msg += ": ";
+        }
+        return new Error(msg + message);
+      }
+      /**
+       * Report a parsing error. This method is made public so that client code may
+       * check for issues that are outside the scope of this project and can report
+       * errors.
+       *
+       * @param message The error to report.
+       *
+       * @returns this
+       */
+      fail(message) {
+        const err2 = this.makeError(message);
+        const handler = this.errorHandler;
+        if (handler === void 0) {
+          throw err2;
+        } else {
+          handler(err2);
+        }
+        return this;
+      }
+      /**
+       * Write a XML data to the parser.
+       *
+       * @param chunk The XML data to write.
+       *
+       * @returns this
+       */
+      // We do need object for the type here. Yes, it often causes problems
+      // but not in this case.
+      write(chunk) {
+        if (this.closed) {
+          return this.fail("cannot write after close; assign an onready handler.");
+        }
+        let end = false;
+        if (chunk === null) {
+          end = true;
+          chunk = "";
+        } else if (typeof chunk === "object") {
+          chunk = chunk.toString();
+        }
+        if (this.carriedFromPrevious !== void 0) {
+          chunk = `${this.carriedFromPrevious}${chunk}`;
+          this.carriedFromPrevious = void 0;
+        }
+        let limit = chunk.length;
+        const lastCode = chunk.charCodeAt(limit - 1);
+        if (!end && // A trailing CR or surrogate must be carried over to the next
+        // chunk.
+        (lastCode === CR || lastCode >= 55296 && lastCode <= 56319)) {
+          this.carriedFromPrevious = chunk[limit - 1];
+          limit--;
+          chunk = chunk.slice(0, limit);
+        }
+        const { stateTable } = this;
+        this.chunk = chunk;
+        this.i = 0;
+        while (this.i < limit) {
+          stateTable[this.state].call(this);
+        }
+        this.chunkPosition += limit;
+        return end ? this.end() : this;
+      }
+      /**
+       * Close the current stream. Perform final well-formedness checks and reset
+       * the parser tstate.
+       *
+       * @returns this
+       */
+      close() {
+        return this.write(null);
+      }
+      /**
+       * Get a single code point out of the current chunk. This updates the current
+       * position if we do position tracking.
+       *
+       * This is the algorithm to use for XML 1.0.
+       *
+       * @returns The character read.
+       */
+      getCode10() {
+        const { chunk, i } = this;
+        this.prevI = i;
+        this.i = i + 1;
+        if (i >= chunk.length) {
+          return EOC;
+        }
+        const code = chunk.charCodeAt(i);
+        this.column++;
+        if (code < 55296) {
+          if (code >= SPACE || code === TAB) {
+            return code;
+          }
+          switch (code) {
+            case NL:
+              this.line++;
+              this.column = 0;
+              this.positionAtNewLine = this.position;
+              return NL;
+            case CR:
+              if (chunk.charCodeAt(i + 1) === NL) {
+                this.i = i + 2;
+              }
+              this.line++;
+              this.column = 0;
+              this.positionAtNewLine = this.position;
+              return NL_LIKE;
+            default:
+              this.fail("disallowed character.");
+              return code;
+          }
+        }
+        if (code > 56319) {
+          if (!(code >= 57344 && code <= 65533)) {
+            this.fail("disallowed character.");
+          }
+          return code;
+        }
+        const final = 65536 + (code - 55296) * 1024 + (chunk.charCodeAt(i + 1) - 56320);
+        this.i = i + 2;
+        if (final > 1114111) {
+          this.fail("disallowed character.");
+        }
+        return final;
+      }
+      /**
+       * Get a single code point out of the current chunk. This updates the current
+       * position if we do position tracking.
+       *
+       * This is the algorithm to use for XML 1.1.
+       *
+       * @returns {number} The character read.
+       */
+      getCode11() {
+        const { chunk, i } = this;
+        this.prevI = i;
+        this.i = i + 1;
+        if (i >= chunk.length) {
+          return EOC;
+        }
+        const code = chunk.charCodeAt(i);
+        this.column++;
+        if (code < 55296) {
+          if (code > 31 && code < 127 || code > 159 && code !== LS || code === TAB) {
+            return code;
+          }
+          switch (code) {
+            case NL:
+              this.line++;
+              this.column = 0;
+              this.positionAtNewLine = this.position;
+              return NL;
+            case CR: {
+              const next = chunk.charCodeAt(i + 1);
+              if (next === NL || next === NEL) {
+                this.i = i + 2;
+              }
+            }
+            /* yes, fall through */
+            case NEL:
+            // 0x85
+            case LS:
+              this.line++;
+              this.column = 0;
+              this.positionAtNewLine = this.position;
+              return NL_LIKE;
+            default:
+              this.fail("disallowed character.");
+              return code;
+          }
+        }
+        if (code > 56319) {
+          if (!(code >= 57344 && code <= 65533)) {
+            this.fail("disallowed character.");
+          }
+          return code;
+        }
+        const final = 65536 + (code - 55296) * 1024 + (chunk.charCodeAt(i + 1) - 56320);
+        this.i = i + 2;
+        if (final > 1114111) {
+          this.fail("disallowed character.");
+        }
+        return final;
+      }
+      /**
+       * Like ``getCode`` but with the return value normalized so that ``NL`` is
+       * returned for ``NL_LIKE``.
+       */
+      getCodeNorm() {
+        const c = this.getCode();
+        return c === NL_LIKE ? NL : c;
+      }
+      unget() {
+        this.i = this.prevI;
+        this.column--;
+      }
+      /**
+       * Capture characters into a buffer until encountering one of a set of
+       * characters.
+       *
+       * @param chars An array of codepoints. Encountering a character in the array
+       * ends the capture. (``chars`` may safely contain ``NL``.)
+       *
+       * @return The character code that made the capture end, or ``EOC`` if we hit
+       * the end of the chunk. The return value cannot be NL_LIKE: NL is returned
+       * instead.
+       */
+      captureTo(chars) {
+        let { i: start } = this;
+        const { chunk } = this;
+        while (true) {
+          const c = this.getCode();
+          const isNLLike = c === NL_LIKE;
+          const final = isNLLike ? NL : c;
+          if (final === EOC || chars.includes(final)) {
+            this.text += chunk.slice(start, this.prevI);
+            return final;
+          }
+          if (isNLLike) {
+            this.text += `${chunk.slice(start, this.prevI)}
+`;
+            start = this.i;
+          }
+        }
+      }
+      /**
+       * Capture characters into a buffer until encountering a character.
+       *
+       * @param char The codepoint that ends the capture. **NOTE ``char`` MAY NOT
+       * CONTAIN ``NL``.** Passing ``NL`` will result in buggy behavior.
+       *
+       * @return ``true`` if we ran into the character. Otherwise, we ran into the
+       * end of the current chunk.
+       */
+      captureToChar(char) {
+        let { i: start } = this;
+        const { chunk } = this;
+        while (true) {
+          let c = this.getCode();
+          switch (c) {
+            case NL_LIKE:
+              this.text += `${chunk.slice(start, this.prevI)}
+`;
+              start = this.i;
+              c = NL;
+              break;
+            case EOC:
+              this.text += chunk.slice(start);
+              return false;
+            default:
+          }
+          if (c === char) {
+            this.text += chunk.slice(start, this.prevI);
+            return true;
+          }
+        }
+      }
+      /**
+       * Capture characters that satisfy ``isNameChar`` into the ``name`` field of
+       * this parser.
+       *
+       * @return The character code that made the test fail, or ``EOC`` if we hit
+       * the end of the chunk. The return value cannot be NL_LIKE: NL is returned
+       * instead.
+       */
+      captureNameChars() {
+        const { chunk, i: start } = this;
+        while (true) {
+          const c = this.getCode();
+          if (c === EOC) {
+            this.name += chunk.slice(start);
+            return EOC;
+          }
+          if (!isNameChar(c)) {
+            this.name += chunk.slice(start, this.prevI);
+            return c === NL_LIKE ? NL : c;
+          }
+        }
+      }
+      /**
+       * Skip white spaces.
+       *
+       * @return The character that ended the skip, or ``EOC`` if we hit
+       * the end of the chunk. The return value cannot be NL_LIKE: NL is returned
+       * instead.
+       */
+      skipSpaces() {
+        while (true) {
+          const c = this.getCodeNorm();
+          if (c === EOC || !isS(c)) {
+            return c;
+          }
+        }
+      }
+      setXMLVersion(version) {
+        this.currentXMLVersion = version;
+        if (version === "1.0") {
+          this.isChar = isChar10;
+          this.getCode = this.getCode10;
+        } else {
+          this.isChar = isChar11;
+          this.getCode = this.getCode11;
+        }
+      }
+      // STATE ENGINE METHODS
+      // This needs to be a state separate from S_BEGIN_WHITESPACE because we want
+      // to be sure never to come back to this state later.
+      sBegin() {
+        if (this.chunk.charCodeAt(0) === 65279) {
+          this.i++;
+          this.column++;
+        }
+        this.state = S_BEGIN_WHITESPACE;
+      }
+      sBeginWhitespace() {
+        const iBefore = this.i;
+        const c = this.skipSpaces();
+        if (this.prevI !== iBefore) {
+          this.xmlDeclPossible = false;
+        }
+        switch (c) {
+          case LESS:
+            this.state = S_OPEN_WAKA;
+            if (this.text.length !== 0) {
+              throw new Error("no-empty text at start");
+            }
+            break;
+          case EOC:
+            break;
+          default:
+            this.unget();
+            this.state = S_TEXT;
+            this.xmlDeclPossible = false;
+        }
+      }
+      sDoctype() {
+        var _a;
+        const c = this.captureTo(DOCTYPE_TERMINATOR);
+        switch (c) {
+          case GREATER: {
+            (_a = this.doctypeHandler) === null || _a === void 0 ? void 0 : _a.call(this, this.text);
+            this.text = "";
+            this.state = S_TEXT;
+            this.doctype = true;
+            break;
+          }
+          case EOC:
+            break;
+          default:
+            this.text += String.fromCodePoint(c);
+            if (c === OPEN_BRACKET) {
+              this.state = S_DTD;
+            } else if (isQuote(c)) {
+              this.state = S_DOCTYPE_QUOTE;
+              this.q = c;
+            }
+        }
+      }
+      sDoctypeQuote() {
+        const q = this.q;
+        if (this.captureToChar(q)) {
+          this.text += String.fromCodePoint(q);
+          this.q = null;
+          this.state = S_DOCTYPE;
+        }
+      }
+      sDTD() {
+        const c = this.captureTo(DTD_TERMINATOR);
+        if (c === EOC) {
+          return;
+        }
+        this.text += String.fromCodePoint(c);
+        if (c === CLOSE_BRACKET) {
+          this.state = S_DOCTYPE;
+        } else if (c === LESS) {
+          this.state = S_DTD_OPEN_WAKA;
+        } else if (isQuote(c)) {
+          this.state = S_DTD_QUOTED;
+          this.q = c;
+        }
+      }
+      sDTDQuoted() {
+        const q = this.q;
+        if (this.captureToChar(q)) {
+          this.text += String.fromCodePoint(q);
+          this.state = S_DTD;
+          this.q = null;
+        }
+      }
+      sDTDOpenWaka() {
+        const c = this.getCodeNorm();
+        this.text += String.fromCodePoint(c);
+        switch (c) {
+          case BANG:
+            this.state = S_DTD_OPEN_WAKA_BANG;
+            this.openWakaBang = "";
+            break;
+          case QUESTION:
+            this.state = S_DTD_PI;
+            break;
+          default:
+            this.state = S_DTD;
+        }
+      }
+      sDTDOpenWakaBang() {
+        const char = String.fromCodePoint(this.getCodeNorm());
+        const owb = this.openWakaBang += char;
+        this.text += char;
+        if (owb !== "-") {
+          this.state = owb === "--" ? S_DTD_COMMENT : S_DTD;
+          this.openWakaBang = "";
+        }
+      }
+      sDTDComment() {
+        if (this.captureToChar(MINUS)) {
+          this.text += "-";
+          this.state = S_DTD_COMMENT_ENDING;
+        }
+      }
+      sDTDCommentEnding() {
+        const c = this.getCodeNorm();
+        this.text += String.fromCodePoint(c);
+        this.state = c === MINUS ? S_DTD_COMMENT_ENDED : S_DTD_COMMENT;
+      }
+      sDTDCommentEnded() {
+        const c = this.getCodeNorm();
+        this.text += String.fromCodePoint(c);
+        if (c === GREATER) {
+          this.state = S_DTD;
+        } else {
+          this.fail("malformed comment.");
+          this.state = S_DTD_COMMENT;
+        }
+      }
+      sDTDPI() {
+        if (this.captureToChar(QUESTION)) {
+          this.text += "?";
+          this.state = S_DTD_PI_ENDING;
+        }
+      }
+      sDTDPIEnding() {
+        const c = this.getCodeNorm();
+        this.text += String.fromCodePoint(c);
+        if (c === GREATER) {
+          this.state = S_DTD;
+        }
+      }
+      sText() {
+        if (this.tags.length !== 0) {
+          this.handleTextInRoot();
+        } else {
+          this.handleTextOutsideRoot();
+        }
+      }
+      sEntity() {
+        let { i: start } = this;
+        const { chunk } = this;
+        loop:
+          while (true) {
+            switch (this.getCode()) {
+              case NL_LIKE:
+                this.entity += `${chunk.slice(start, this.prevI)}
+`;
+                start = this.i;
+                break;
+              case SEMICOLON: {
+                const { entityReturnState } = this;
+                const entity = this.entity + chunk.slice(start, this.prevI);
+                this.state = entityReturnState;
+                let parsed;
+                if (entity === "") {
+                  this.fail("empty entity name.");
+                  parsed = "&;";
+                } else {
+                  parsed = this.parseEntity(entity);
+                  this.entity = "";
+                }
+                if (entityReturnState !== S_TEXT || this.textHandler !== void 0) {
+                  this.text += parsed;
+                }
+                break loop;
+              }
+              case EOC:
+                this.entity += chunk.slice(start);
+                break loop;
+              default:
+            }
+          }
+      }
+      sOpenWaka() {
+        const c = this.getCode();
+        if (isNameStartChar(c)) {
+          this.state = S_OPEN_TAG;
+          this.unget();
+          this.xmlDeclPossible = false;
+        } else {
+          switch (c) {
+            case FORWARD_SLASH:
+              this.state = S_CLOSE_TAG;
+              this.xmlDeclPossible = false;
+              break;
+            case BANG:
+              this.state = S_OPEN_WAKA_BANG;
+              this.openWakaBang = "";
+              this.xmlDeclPossible = false;
+              break;
+            case QUESTION:
+              this.state = S_PI_FIRST_CHAR;
+              break;
+            default:
+              this.fail("disallowed character in tag name");
+              this.state = S_TEXT;
+              this.xmlDeclPossible = false;
+          }
+        }
+      }
+      sOpenWakaBang() {
+        this.openWakaBang += String.fromCodePoint(this.getCodeNorm());
+        switch (this.openWakaBang) {
+          case "[CDATA[":
+            if (!this.sawRoot && !this.reportedTextBeforeRoot) {
+              this.fail("text data outside of root node.");
+              this.reportedTextBeforeRoot = true;
+            }
+            if (this.closedRoot && !this.reportedTextAfterRoot) {
+              this.fail("text data outside of root node.");
+              this.reportedTextAfterRoot = true;
+            }
+            this.state = S_CDATA;
+            this.openWakaBang = "";
+            break;
+          case "--":
+            this.state = S_COMMENT;
+            this.openWakaBang = "";
+            break;
+          case "DOCTYPE":
+            this.state = S_DOCTYPE;
+            if (this.doctype || this.sawRoot) {
+              this.fail("inappropriately located doctype declaration.");
+            }
+            this.openWakaBang = "";
+            break;
+          default:
+            if (this.openWakaBang.length >= 7) {
+              this.fail("incorrect syntax.");
+            }
+        }
+      }
+      sComment() {
+        if (this.captureToChar(MINUS)) {
+          this.state = S_COMMENT_ENDING;
+        }
+      }
+      sCommentEnding() {
+        var _a;
+        const c = this.getCodeNorm();
+        if (c === MINUS) {
+          this.state = S_COMMENT_ENDED;
+          (_a = this.commentHandler) === null || _a === void 0 ? void 0 : _a.call(this, this.text);
+          this.text = "";
+        } else {
+          this.text += `-${String.fromCodePoint(c)}`;
+          this.state = S_COMMENT;
+        }
+      }
+      sCommentEnded() {
+        const c = this.getCodeNorm();
+        if (c !== GREATER) {
+          this.fail("malformed comment.");
+          this.text += `--${String.fromCodePoint(c)}`;
+          this.state = S_COMMENT;
+        } else {
+          this.state = S_TEXT;
+        }
+      }
+      sCData() {
+        if (this.captureToChar(CLOSE_BRACKET)) {
+          this.state = S_CDATA_ENDING;
+        }
+      }
+      sCDataEnding() {
+        const c = this.getCodeNorm();
+        if (c === CLOSE_BRACKET) {
+          this.state = S_CDATA_ENDING_2;
+        } else {
+          this.text += `]${String.fromCodePoint(c)}`;
+          this.state = S_CDATA;
+        }
+      }
+      sCDataEnding2() {
+        var _a;
+        const c = this.getCodeNorm();
+        switch (c) {
+          case GREATER: {
+            (_a = this.cdataHandler) === null || _a === void 0 ? void 0 : _a.call(this, this.text);
+            this.text = "";
+            this.state = S_TEXT;
+            break;
+          }
+          case CLOSE_BRACKET:
+            this.text += "]";
+            break;
+          default:
+            this.text += `]]${String.fromCodePoint(c)}`;
+            this.state = S_CDATA;
+        }
+      }
+      // We need this separate state to check the first character fo the pi target
+      // with this.nameStartCheck which allows less characters than this.nameCheck.
+      sPIFirstChar() {
+        const c = this.getCodeNorm();
+        if (this.nameStartCheck(c)) {
+          this.piTarget += String.fromCodePoint(c);
+          this.state = S_PI_REST;
+        } else if (c === QUESTION || isS(c)) {
+          this.fail("processing instruction without a target.");
+          this.state = c === QUESTION ? S_PI_ENDING : S_PI_BODY;
+        } else {
+          this.fail("disallowed character in processing instruction name.");
+          this.piTarget += String.fromCodePoint(c);
+          this.state = S_PI_REST;
+        }
+      }
+      sPIRest() {
+        const { chunk, i: start } = this;
+        while (true) {
+          const c = this.getCodeNorm();
+          if (c === EOC) {
+            this.piTarget += chunk.slice(start);
+            return;
+          }
+          if (!this.nameCheck(c)) {
+            this.piTarget += chunk.slice(start, this.prevI);
+            const isQuestion = c === QUESTION;
+            if (isQuestion || isS(c)) {
+              if (this.piTarget === "xml") {
+                if (!this.xmlDeclPossible) {
+                  this.fail("an XML declaration must be at the start of the document.");
+                }
+                this.state = isQuestion ? S_XML_DECL_ENDING : S_XML_DECL_NAME_START;
+              } else {
+                this.state = isQuestion ? S_PI_ENDING : S_PI_BODY;
+              }
+            } else {
+              this.fail("disallowed character in processing instruction name.");
+              this.piTarget += String.fromCodePoint(c);
+            }
+            break;
+          }
+        }
+      }
+      sPIBody() {
+        if (this.text.length === 0) {
+          const c = this.getCodeNorm();
+          if (c === QUESTION) {
+            this.state = S_PI_ENDING;
+          } else if (!isS(c)) {
+            this.text = String.fromCodePoint(c);
+          }
+        } else if (this.captureToChar(QUESTION)) {
+          this.state = S_PI_ENDING;
+        }
+      }
+      sPIEnding() {
+        var _a;
+        const c = this.getCodeNorm();
+        if (c === GREATER) {
+          const { piTarget } = this;
+          if (piTarget.toLowerCase() === "xml") {
+            this.fail("the XML declaration must appear at the start of the document.");
+          }
+          (_a = this.piHandler) === null || _a === void 0 ? void 0 : _a.call(this, {
+            target: piTarget,
+            body: this.text
+          });
+          this.piTarget = this.text = "";
+          this.state = S_TEXT;
+        } else if (c === QUESTION) {
+          this.text += "?";
+        } else {
+          this.text += `?${String.fromCodePoint(c)}`;
+          this.state = S_PI_BODY;
+        }
+        this.xmlDeclPossible = false;
+      }
+      sXMLDeclNameStart() {
+        const c = this.skipSpaces();
+        if (c === QUESTION) {
+          this.state = S_XML_DECL_ENDING;
+          return;
+        }
+        if (c !== EOC) {
+          this.state = S_XML_DECL_NAME;
+          this.name = String.fromCodePoint(c);
+        }
+      }
+      sXMLDeclName() {
+        const c = this.captureTo(XML_DECL_NAME_TERMINATOR);
+        if (c === QUESTION) {
+          this.state = S_XML_DECL_ENDING;
+          this.name += this.text;
+          this.text = "";
+          this.fail("XML declaration is incomplete.");
+          return;
+        }
+        if (!(isS(c) || c === EQUAL)) {
+          return;
+        }
+        this.name += this.text;
+        this.text = "";
+        if (!this.xmlDeclExpects.includes(this.name)) {
+          switch (this.name.length) {
+            case 0:
+              this.fail("did not expect any more name/value pairs.");
+              break;
+            case 1:
+              this.fail(`expected the name ${this.xmlDeclExpects[0]}.`);
+              break;
+            default:
+              this.fail(`expected one of ${this.xmlDeclExpects.join(", ")}`);
+          }
+        }
+        this.state = c === EQUAL ? S_XML_DECL_VALUE_START : S_XML_DECL_EQ;
+      }
+      sXMLDeclEq() {
+        const c = this.getCodeNorm();
+        if (c === QUESTION) {
+          this.state = S_XML_DECL_ENDING;
+          this.fail("XML declaration is incomplete.");
+          return;
+        }
+        if (isS(c)) {
+          return;
+        }
+        if (c !== EQUAL) {
+          this.fail("value required.");
+        }
+        this.state = S_XML_DECL_VALUE_START;
+      }
+      sXMLDeclValueStart() {
+        const c = this.getCodeNorm();
+        if (c === QUESTION) {
+          this.state = S_XML_DECL_ENDING;
+          this.fail("XML declaration is incomplete.");
+          return;
+        }
+        if (isS(c)) {
+          return;
+        }
+        if (!isQuote(c)) {
+          this.fail("value must be quoted.");
+          this.q = SPACE;
+        } else {
+          this.q = c;
+        }
+        this.state = S_XML_DECL_VALUE;
+      }
+      sXMLDeclValue() {
+        const c = this.captureTo([this.q, QUESTION]);
+        if (c === QUESTION) {
+          this.state = S_XML_DECL_ENDING;
+          this.text = "";
+          this.fail("XML declaration is incomplete.");
+          return;
+        }
+        if (c === EOC) {
+          return;
+        }
+        const value = this.text;
+        this.text = "";
+        switch (this.name) {
+          case "version": {
+            this.xmlDeclExpects = ["encoding", "standalone"];
+            const version = value;
+            this.xmlDecl.version = version;
+            if (!/^1\.[0-9]+$/.test(version)) {
+              this.fail("version number must match /^1\\.[0-9]+$/.");
+            } else if (!this.opt.forceXMLVersion) {
+              this.setXMLVersion(version);
+            }
+            break;
+          }
+          case "encoding":
+            if (!/^[A-Za-z][A-Za-z0-9._-]*$/.test(value)) {
+              this.fail("encoding value must match /^[A-Za-z0-9][A-Za-z0-9._-]*$/.");
+            }
+            this.xmlDeclExpects = ["standalone"];
+            this.xmlDecl.encoding = value;
+            break;
+          case "standalone":
+            if (value !== "yes" && value !== "no") {
+              this.fail('standalone value must match "yes" or "no".');
+            }
+            this.xmlDeclExpects = [];
+            this.xmlDecl.standalone = value;
+            break;
+          default:
+        }
+        this.name = "";
+        this.state = S_XML_DECL_SEPARATOR;
+      }
+      sXMLDeclSeparator() {
+        const c = this.getCodeNorm();
+        if (c === QUESTION) {
+          this.state = S_XML_DECL_ENDING;
+          return;
+        }
+        if (!isS(c)) {
+          this.fail("whitespace required.");
+          this.unget();
+        }
+        this.state = S_XML_DECL_NAME_START;
+      }
+      sXMLDeclEnding() {
+        var _a;
+        const c = this.getCodeNorm();
+        if (c === GREATER) {
+          if (this.piTarget !== "xml") {
+            this.fail("processing instructions are not allowed before root.");
+          } else if (this.name !== "version" && this.xmlDeclExpects.includes("version")) {
+            this.fail("XML declaration must contain a version.");
+          }
+          (_a = this.xmldeclHandler) === null || _a === void 0 ? void 0 : _a.call(this, this.xmlDecl);
+          this.name = "";
+          this.piTarget = this.text = "";
+          this.state = S_TEXT;
+        } else {
+          this.fail("The character ? is disallowed anywhere in XML declarations.");
+        }
+        this.xmlDeclPossible = false;
+      }
+      sOpenTag() {
+        var _a;
+        const c = this.captureNameChars();
+        if (c === EOC) {
+          return;
+        }
+        const tag = this.tag = {
+          name: this.name,
+          attributes: /* @__PURE__ */ Object.create(null)
+        };
+        this.name = "";
+        if (this.xmlnsOpt) {
+          this.topNS = tag.ns = /* @__PURE__ */ Object.create(null);
+        }
+        (_a = this.openTagStartHandler) === null || _a === void 0 ? void 0 : _a.call(this, tag);
+        this.sawRoot = true;
+        if (!this.fragmentOpt && this.closedRoot) {
+          this.fail("documents may contain only one root.");
+        }
+        switch (c) {
+          case GREATER:
+            this.openTag();
+            break;
+          case FORWARD_SLASH:
+            this.state = S_OPEN_TAG_SLASH;
+            break;
+          default:
+            if (!isS(c)) {
+              this.fail("disallowed character in tag name.");
+            }
+            this.state = S_ATTRIB;
+        }
+      }
+      sOpenTagSlash() {
+        if (this.getCode() === GREATER) {
+          this.openSelfClosingTag();
+        } else {
+          this.fail("forward-slash in opening tag not followed by >.");
+          this.state = S_ATTRIB;
+        }
+      }
+      sAttrib() {
+        const c = this.skipSpaces();
+        if (c === EOC) {
+          return;
+        }
+        if (isNameStartChar(c)) {
+          this.unget();
+          this.state = S_ATTRIB_NAME;
+        } else if (c === GREATER) {
+          this.openTag();
+        } else if (c === FORWARD_SLASH) {
+          this.state = S_OPEN_TAG_SLASH;
+        } else {
+          this.fail("disallowed character in attribute name.");
+        }
+      }
+      sAttribName() {
+        const c = this.captureNameChars();
+        if (c === EQUAL) {
+          this.state = S_ATTRIB_VALUE;
+        } else if (isS(c)) {
+          this.state = S_ATTRIB_NAME_SAW_WHITE;
+        } else if (c === GREATER) {
+          this.fail("attribute without value.");
+          this.pushAttrib(this.name, this.name);
+          this.name = this.text = "";
+          this.openTag();
+        } else if (c !== EOC) {
+          this.fail("disallowed character in attribute name.");
+        }
+      }
+      sAttribNameSawWhite() {
+        const c = this.skipSpaces();
+        switch (c) {
+          case EOC:
+            return;
+          case EQUAL:
+            this.state = S_ATTRIB_VALUE;
+            break;
+          default:
+            this.fail("attribute without value.");
+            this.text = "";
+            this.name = "";
+            if (c === GREATER) {
+              this.openTag();
+            } else if (isNameStartChar(c)) {
+              this.unget();
+              this.state = S_ATTRIB_NAME;
+            } else {
+              this.fail("disallowed character in attribute name.");
+              this.state = S_ATTRIB;
+            }
+        }
+      }
+      sAttribValue() {
+        const c = this.getCodeNorm();
+        if (isQuote(c)) {
+          this.q = c;
+          this.state = S_ATTRIB_VALUE_QUOTED;
+        } else if (!isS(c)) {
+          this.fail("unquoted attribute value.");
+          this.state = S_ATTRIB_VALUE_UNQUOTED;
+          this.unget();
+        }
+      }
+      sAttribValueQuoted() {
+        const { q, chunk } = this;
+        let { i: start } = this;
+        while (true) {
+          switch (this.getCode()) {
+            case q:
+              this.pushAttrib(this.name, this.text + chunk.slice(start, this.prevI));
+              this.name = this.text = "";
+              this.q = null;
+              this.state = S_ATTRIB_VALUE_CLOSED;
+              return;
+            case AMP:
+              this.text += chunk.slice(start, this.prevI);
+              this.state = S_ENTITY;
+              this.entityReturnState = S_ATTRIB_VALUE_QUOTED;
+              return;
+            case NL:
+            case NL_LIKE:
+            case TAB:
+              this.text += `${chunk.slice(start, this.prevI)} `;
+              start = this.i;
+              break;
+            case LESS:
+              this.text += chunk.slice(start, this.prevI);
+              this.fail("disallowed character.");
+              return;
+            case EOC:
+              this.text += chunk.slice(start);
+              return;
+            default:
+          }
+        }
+      }
+      sAttribValueClosed() {
+        const c = this.getCodeNorm();
+        if (isS(c)) {
+          this.state = S_ATTRIB;
+        } else if (c === GREATER) {
+          this.openTag();
+        } else if (c === FORWARD_SLASH) {
+          this.state = S_OPEN_TAG_SLASH;
+        } else if (isNameStartChar(c)) {
+          this.fail("no whitespace between attributes.");
+          this.unget();
+          this.state = S_ATTRIB_NAME;
+        } else {
+          this.fail("disallowed character in attribute name.");
+        }
+      }
+      sAttribValueUnquoted() {
+        const c = this.captureTo(ATTRIB_VALUE_UNQUOTED_TERMINATOR);
+        switch (c) {
+          case AMP:
+            this.state = S_ENTITY;
+            this.entityReturnState = S_ATTRIB_VALUE_UNQUOTED;
+            break;
+          case LESS:
+            this.fail("disallowed character.");
+            break;
+          case EOC:
+            break;
+          default:
+            if (this.text.includes("]]>")) {
+              this.fail('the string "]]>" is disallowed in char data.');
+            }
+            this.pushAttrib(this.name, this.text);
+            this.name = this.text = "";
+            if (c === GREATER) {
+              this.openTag();
+            } else {
+              this.state = S_ATTRIB;
+            }
+        }
+      }
+      sCloseTag() {
+        const c = this.captureNameChars();
+        if (c === GREATER) {
+          this.closeTag();
+        } else if (isS(c)) {
+          this.state = S_CLOSE_TAG_SAW_WHITE;
+        } else if (c !== EOC) {
+          this.fail("disallowed character in closing tag.");
+        }
+      }
+      sCloseTagSawWhite() {
+        switch (this.skipSpaces()) {
+          case GREATER:
+            this.closeTag();
+            break;
+          case EOC:
+            break;
+          default:
+            this.fail("disallowed character in closing tag.");
+        }
+      }
+      // END OF STATE ENGINE METHODS
+      handleTextInRoot() {
+        let { i: start, forbiddenState } = this;
+        const { chunk, textHandler: handler } = this;
+        scanLoop:
+          while (true) {
+            switch (this.getCode()) {
+              case LESS: {
+                this.state = S_OPEN_WAKA;
+                if (handler !== void 0) {
+                  const { text } = this;
+                  const slice = chunk.slice(start, this.prevI);
+                  if (text.length !== 0) {
+                    handler(text + slice);
+                    this.text = "";
+                  } else if (slice.length !== 0) {
+                    handler(slice);
+                  }
+                }
+                forbiddenState = FORBIDDEN_START;
+                break scanLoop;
+              }
+              case AMP:
+                this.state = S_ENTITY;
+                this.entityReturnState = S_TEXT;
+                if (handler !== void 0) {
+                  this.text += chunk.slice(start, this.prevI);
+                }
+                forbiddenState = FORBIDDEN_START;
+                break scanLoop;
+              case CLOSE_BRACKET:
+                switch (forbiddenState) {
+                  case FORBIDDEN_START:
+                    forbiddenState = FORBIDDEN_BRACKET;
+                    break;
+                  case FORBIDDEN_BRACKET:
+                    forbiddenState = FORBIDDEN_BRACKET_BRACKET;
+                    break;
+                  case FORBIDDEN_BRACKET_BRACKET:
+                    break;
+                  default:
+                    throw new Error("impossible state");
+                }
+                break;
+              case GREATER:
+                if (forbiddenState === FORBIDDEN_BRACKET_BRACKET) {
+                  this.fail('the string "]]>" is disallowed in char data.');
+                }
+                forbiddenState = FORBIDDEN_START;
+                break;
+              case NL_LIKE:
+                if (handler !== void 0) {
+                  this.text += `${chunk.slice(start, this.prevI)}
+`;
+                }
+                start = this.i;
+                forbiddenState = FORBIDDEN_START;
+                break;
+              case EOC:
+                if (handler !== void 0) {
+                  this.text += chunk.slice(start);
+                }
+                break scanLoop;
+              default:
+                forbiddenState = FORBIDDEN_START;
+            }
+          }
+        this.forbiddenState = forbiddenState;
+      }
+      handleTextOutsideRoot() {
+        let { i: start } = this;
+        const { chunk, textHandler: handler } = this;
+        let nonSpace = false;
+        outRootLoop:
+          while (true) {
+            const code = this.getCode();
+            switch (code) {
+              case LESS: {
+                this.state = S_OPEN_WAKA;
+                if (handler !== void 0) {
+                  const { text } = this;
+                  const slice = chunk.slice(start, this.prevI);
+                  if (text.length !== 0) {
+                    handler(text + slice);
+                    this.text = "";
+                  } else if (slice.length !== 0) {
+                    handler(slice);
+                  }
+                }
+                break outRootLoop;
+              }
+              case AMP:
+                this.state = S_ENTITY;
+                this.entityReturnState = S_TEXT;
+                if (handler !== void 0) {
+                  this.text += chunk.slice(start, this.prevI);
+                }
+                nonSpace = true;
+                break outRootLoop;
+              case NL_LIKE:
+                if (handler !== void 0) {
+                  this.text += `${chunk.slice(start, this.prevI)}
+`;
+                }
+                start = this.i;
+                break;
+              case EOC:
+                if (handler !== void 0) {
+                  this.text += chunk.slice(start);
+                }
+                break outRootLoop;
+              default:
+                if (!isS(code)) {
+                  nonSpace = true;
+                }
+            }
+          }
+        if (!nonSpace) {
+          return;
+        }
+        if (!this.sawRoot && !this.reportedTextBeforeRoot) {
+          this.fail("text data outside of root node.");
+          this.reportedTextBeforeRoot = true;
+        }
+        if (this.closedRoot && !this.reportedTextAfterRoot) {
+          this.fail("text data outside of root node.");
+          this.reportedTextAfterRoot = true;
+        }
+      }
+      pushAttribNS(name, value) {
+        var _a;
+        const { prefix, local } = this.qname(name);
+        const attr = { name, prefix, local, value };
+        this.attribList.push(attr);
+        (_a = this.attributeHandler) === null || _a === void 0 ? void 0 : _a.call(this, attr);
+        if (prefix === "xmlns") {
+          const trimmed = value.trim();
+          if (this.currentXMLVersion === "1.0" && trimmed === "") {
+            this.fail("invalid attempt to undefine prefix in XML 1.0");
+          }
+          this.topNS[local] = trimmed;
+          nsPairCheck(this, local, trimmed);
+        } else if (name === "xmlns") {
+          const trimmed = value.trim();
+          this.topNS[""] = trimmed;
+          nsPairCheck(this, "", trimmed);
+        }
+      }
+      pushAttribPlain(name, value) {
+        var _a;
+        const attr = { name, value };
+        this.attribList.push(attr);
+        (_a = this.attributeHandler) === null || _a === void 0 ? void 0 : _a.call(this, attr);
+      }
+      /**
+       * End parsing. This performs final well-formedness checks and resets the
+       * parser to a clean state.
+       *
+       * @returns this
+       */
+      end() {
+        var _a, _b;
+        if (!this.sawRoot) {
+          this.fail("document must contain a root element.");
+        }
+        const { tags } = this;
+        while (tags.length > 0) {
+          const tag = tags.pop();
+          this.fail(`unclosed tag: ${tag.name}`);
+        }
+        if (this.state !== S_BEGIN && this.state !== S_TEXT) {
+          this.fail("unexpected end.");
+        }
+        const { text } = this;
+        if (text.length !== 0) {
+          (_a = this.textHandler) === null || _a === void 0 ? void 0 : _a.call(this, text);
+          this.text = "";
+        }
+        this._closed = true;
+        (_b = this.endHandler) === null || _b === void 0 ? void 0 : _b.call(this);
+        this._init();
+        return this;
+      }
+      /**
+       * Resolve a namespace prefix.
+       *
+       * @param prefix The prefix to resolve.
+       *
+       * @returns The namespace URI or ``undefined`` if the prefix is not defined.
+       */
+      resolve(prefix) {
+        var _a, _b;
+        let uri = this.topNS[prefix];
+        if (uri !== void 0) {
+          return uri;
+        }
+        const { tags } = this;
+        for (let index = tags.length - 1; index >= 0; index--) {
+          uri = tags[index].ns[prefix];
+          if (uri !== void 0) {
+            return uri;
+          }
+        }
+        uri = this.ns[prefix];
+        if (uri !== void 0) {
+          return uri;
+        }
+        return (_b = (_a = this.opt).resolvePrefix) === null || _b === void 0 ? void 0 : _b.call(_a, prefix);
+      }
+      /**
+       * Parse a qname into its prefix and local name parts.
+       *
+       * @param name The name to parse
+       *
+       * @returns
+       */
+      qname(name) {
+        const colon = name.indexOf(":");
+        if (colon === -1) {
+          return { prefix: "", local: name };
+        }
+        const local = name.slice(colon + 1);
+        const prefix = name.slice(0, colon);
+        if (prefix === "" || local === "" || local.includes(":")) {
+          this.fail(`malformed name: ${name}.`);
+        }
+        return { prefix, local };
+      }
+      processAttribsNS() {
+        var _a;
+        const { attribList } = this;
+        const tag = this.tag;
+        {
+          const { prefix, local } = this.qname(tag.name);
+          tag.prefix = prefix;
+          tag.local = local;
+          const uri = tag.uri = (_a = this.resolve(prefix)) !== null && _a !== void 0 ? _a : "";
+          if (prefix !== "") {
+            if (prefix === "xmlns") {
+              this.fail('tags may not have "xmlns" as prefix.');
+            }
+            if (uri === "") {
+              this.fail(`unbound namespace prefix: ${JSON.stringify(prefix)}.`);
+              tag.uri = prefix;
+            }
+          }
+        }
+        if (attribList.length === 0) {
+          return;
+        }
+        const { attributes } = tag;
+        const seen = /* @__PURE__ */ new Set();
+        for (const attr of attribList) {
+          const { name, prefix, local } = attr;
+          let uri;
+          let eqname;
+          if (prefix === "") {
+            uri = name === "xmlns" ? XMLNS_NAMESPACE : "";
+            eqname = name;
+          } else {
+            uri = this.resolve(prefix);
+            if (uri === void 0) {
+              this.fail(`unbound namespace prefix: ${JSON.stringify(prefix)}.`);
+              uri = prefix;
+            }
+            eqname = `{${uri}}${local}`;
+          }
+          if (seen.has(eqname)) {
+            this.fail(`duplicate attribute: ${eqname}.`);
+          }
+          seen.add(eqname);
+          attr.uri = uri;
+          attributes[name] = attr;
+        }
+        this.attribList = [];
+      }
+      processAttribsPlain() {
+        const { attribList } = this;
+        const attributes = this.tag.attributes;
+        for (const { name, value } of attribList) {
+          if (attributes[name] !== void 0) {
+            this.fail(`duplicate attribute: ${name}.`);
+          }
+          attributes[name] = value;
+        }
+        this.attribList = [];
+      }
+      /**
+       * Handle a complete open tag. This parser code calls this once it has seen
+       * the whole tag. This method checks for well-formeness and then emits
+       * ``onopentag``.
+       */
+      openTag() {
+        var _a;
+        this.processAttribs();
+        const { tags } = this;
+        const tag = this.tag;
+        tag.isSelfClosing = false;
+        (_a = this.openTagHandler) === null || _a === void 0 ? void 0 : _a.call(this, tag);
+        tags.push(tag);
+        this.state = S_TEXT;
+        this.name = "";
+      }
+      /**
+       * Handle a complete self-closing tag. This parser code calls this once it has
+       * seen the whole tag. This method checks for well-formeness and then emits
+       * ``onopentag`` and ``onclosetag``.
+       */
+      openSelfClosingTag() {
+        var _a, _b, _c;
+        this.processAttribs();
+        const { tags } = this;
+        const tag = this.tag;
+        tag.isSelfClosing = true;
+        (_a = this.openTagHandler) === null || _a === void 0 ? void 0 : _a.call(this, tag);
+        (_b = this.closeTagHandler) === null || _b === void 0 ? void 0 : _b.call(this, tag);
+        const top = this.tag = (_c = tags[tags.length - 1]) !== null && _c !== void 0 ? _c : null;
+        if (top === null) {
+          this.closedRoot = true;
+        }
+        this.state = S_TEXT;
+        this.name = "";
+      }
+      /**
+       * Handle a complete close tag. This parser code calls this once it has seen
+       * the whole tag. This method checks for well-formeness and then emits
+       * ``onclosetag``.
+       */
+      closeTag() {
+        const { tags, name } = this;
+        this.state = S_TEXT;
+        this.name = "";
+        if (name === "") {
+          this.fail("weird empty close tag.");
+          this.text += "</>";
+          return;
+        }
+        const handler = this.closeTagHandler;
+        let l = tags.length;
+        while (l-- > 0) {
+          const tag = this.tag = tags.pop();
+          this.topNS = tag.ns;
+          handler === null || handler === void 0 ? void 0 : handler(tag);
+          if (tag.name === name) {
+            break;
+          }
+          this.fail("unexpected close tag.");
+        }
+        if (l === 0) {
+          this.closedRoot = true;
+        } else if (l < 0) {
+          this.fail(`unmatched closing tag: ${name}.`);
+          this.text += `</${name}>`;
+        }
+      }
+      /**
+       * Resolves an entity. Makes any necessary well-formedness checks.
+       *
+       * @param entity The entity to resolve.
+       *
+       * @returns The parsed entity.
+       */
+      parseEntity(entity) {
+        if (entity[0] !== "#") {
+          const defined = this.ENTITIES[entity];
+          if (defined !== void 0) {
+            return defined;
+          }
+          this.fail(this.isName(entity) ? "undefined entity." : "disallowed character in entity name.");
+          return `&${entity};`;
+        }
+        let num = NaN;
+        if (entity[1] === "x" && /^#x[0-9a-f]+$/i.test(entity)) {
+          num = parseInt(entity.slice(2), 16);
+        } else if (/^#[0-9]+$/.test(entity)) {
+          num = parseInt(entity.slice(1), 10);
+        }
+        if (!this.isChar(num)) {
+          this.fail("malformed character entity.");
+          return `&${entity};`;
+        }
+        return String.fromCodePoint(num);
+      }
+    };
+    exports.SaxesParser = SaxesParser2;
+  }
+});
 
 // ../core/dist/server.js
 import { serveStdio } from "@modelcontextprotocol/server/stdio";
@@ -29,7 +1962,6 @@ function toPublic(inst) {
     pluginVersion: inst.pluginVersion,
     pluginVariant: inst.pluginVariant,
     serverVersion: inst.serverVersion,
-    versionMismatch: inst.versionMismatch,
     lastActivity: inst.lastActivity,
     connectedAt: inst.connectedAt
   };
@@ -37,8 +1969,10 @@ function toPublic(inst) {
 var STALE_INSTANCE_MS = 3e4;
 var DUPLICATE_TAKEOVER_MS = 3e3;
 var INSTANCE_ALIAS_TTL_MS = 5 * 60 * 1e3;
-var DEFAULT_POLL_WAIT_TIMEOUT_MS = 15e3;
-var MAX_ACTIVE_POLLS = 128;
+var ACCEPTED_REQUEST_TOMBSTONE_TTL_MS = 6e4;
+var MAX_ACCEPTED_REQUEST_TOMBSTONES = 4096;
+var CANCELLATION_TOMBSTONE_TTL_MS = 6e4;
+var MAX_CANCELLATION_TOMBSTONES = 4096;
 function publishedInstanceId(placeId) {
   if (placeId === void 0 || !Number.isFinite(placeId) || placeId <= 0)
     return void 0;
@@ -46,11 +1980,15 @@ function publishedInstanceId(placeId) {
 }
 var BridgeService = class {
   pendingRequests = /* @__PURE__ */ new Map();
+  acceptedRequestIds = /* @__PURE__ */ new Map();
+  pendingCancellations = /* @__PURE__ */ new Map();
   // Keyed by pluginSessionId (the per-plugin GUID).
   instances = /* @__PURE__ */ new Map();
   instanceAliases = /* @__PURE__ */ new Map();
   instanceRegisteredListeners = /* @__PURE__ */ new Set();
-  pendingPolls = /* @__PURE__ */ new Map();
+  requestAvailableListeners = /* @__PURE__ */ new Set();
+  sessionClosedListeners = /* @__PURE__ */ new Set();
+  deliveryOwnersByPhysicalSession = /* @__PURE__ */ new Map();
   requestTimeout = 3e4;
   onInstanceRegistered(listener) {
     this.instanceRegisteredListeners.add(listener);
@@ -70,6 +2008,62 @@ var BridgeService = class {
       }
     }
   }
+  onRequestAvailable(listener) {
+    this.requestAvailableListeners.add(listener);
+    return () => this.requestAvailableListeners.delete(listener);
+  }
+  onSessionClosed(listener) {
+    this.sessionClosedListeners.add(listener);
+    return () => this.sessionClosedListeners.delete(listener);
+  }
+  setDeliveryActive(physicalSessionId, owner, active) {
+    let owners = this.deliveryOwnersByPhysicalSession.get(physicalSessionId);
+    if (active) {
+      if (!owners) {
+        owners = /* @__PURE__ */ new Set();
+        this.deliveryOwnersByPhysicalSession.set(physicalSessionId, owners);
+      }
+      owners.add(owner);
+      return;
+    }
+    if (!owners)
+      return;
+    owners.delete(owner);
+    if (owners.size === 0)
+      this.deliveryOwnersByPhysicalSession.delete(physicalSessionId);
+  }
+  notifyRequestAvailable(physicalSessionId) {
+    for (const listener of this.requestAvailableListeners) {
+      try {
+        listener(physicalSessionId);
+      } catch {
+      }
+    }
+  }
+  notifyRequestCancelled(request, reason) {
+    const physicalSessionId = request.lastDeliveryPhysicalSessionId;
+    if (!physicalSessionId || this.pendingCancellations.has(request.id))
+      return;
+    const now = Date.now();
+    this.prunePendingCancellations(now);
+    this.pendingCancellations.set(request.id, {
+      requestId: request.id,
+      reason,
+      physicalSessionId,
+      createdAt: now
+    });
+    this.prunePendingCancellations(now);
+    this.notifyRequestAvailable(physicalSessionId);
+  }
+  physicalSessionsForTarget(targetInstanceId, targetRole) {
+    const physicalSessionIds = /* @__PURE__ */ new Set();
+    for (const instance of this.instances.values()) {
+      if (instance.instanceId === targetInstanceId && instance.role === targetRole) {
+        physicalSessionIds.add(instance.physicalSessionId);
+      }
+    }
+    return Array.from(physicalSessionIds);
+  }
   canonicalInstanceId(instanceId, placeId) {
     return publishedInstanceId(placeId) ?? instanceId;
   }
@@ -140,7 +2134,6 @@ var BridgeService = class {
     const pluginVersion = input.pluginVersion ?? "";
     const pluginVariant = input.pluginVariant ?? "unknown";
     const serverVersion = input.serverVersion ?? "";
-    const versionMismatch = pluginVersion !== "" && serverVersion !== "" && pluginVersion !== serverVersion;
     this.rememberInstanceAlias(rawInstanceId, instanceId);
     if (prior && prior.instanceId !== instanceId) {
       this.rememberInstanceAlias(prior.instanceId, instanceId);
@@ -166,7 +2159,8 @@ var BridgeService = class {
     }
     const existing = Array.from(this.instances.values()).find((i) => i.instanceId === instanceId && i.role === assignedRole && i.pluginSessionId !== pluginSessionId);
     if (existing) {
-      if (!this.pendingPolls.has(existing.pluginSessionId) && Date.now() - existing.lastActivity > DUPLICATE_TAKEOVER_MS) {
+      const existingDeliveryActive = (this.deliveryOwnersByPhysicalSession.get(existing.physicalSessionId)?.size ?? 0) > 0;
+      if (!existingDeliveryActive && Date.now() - existing.lastActivity > DUPLICATE_TAKEOVER_MS) {
         this.unregisterInstance(existing.pluginSessionId);
       } else {
         return {
@@ -181,6 +2175,7 @@ var BridgeService = class {
     }
     const registered = {
       pluginSessionId,
+      physicalSessionId: input.physicalSessionId,
       instanceId,
       role: assignedRole,
       placeId: input.placeId ?? 0,
@@ -190,29 +2185,39 @@ var BridgeService = class {
       pluginVersion,
       pluginVariant,
       serverVersion,
-      versionMismatch,
       lastActivity: Date.now(),
       connectedAt: prior?.connectedAt ?? Date.now()
     };
     this.instances.set(pluginSessionId, registered);
     this.notifyInstanceRegistered(toPublic(registered));
-    this.dispatchPendingPolls(instanceId, assignedRole);
+    this.notifyRequestAvailable(registered.physicalSessionId);
     return { ok: true, assignedRole, instanceId };
   }
   unregisterInstance(pluginSessionId) {
     const removed = this.instances.get(pluginSessionId);
-    this.instances.delete(pluginSessionId);
-    const pendingPoll = this.pendingPolls.get(pluginSessionId);
-    if (pendingPoll) {
-      this.settlePendingPoll(pendingPoll, { kind: "session_closed" });
-    }
     if (!removed)
       return;
-    for (const [id, req] of this.pendingRequests.entries()) {
+    const logicalChildren = removed.physicalSessionId === pluginSessionId ? Array.from(this.instances.values()).filter((instance) => instance.pluginSessionId !== pluginSessionId && instance.physicalSessionId === pluginSessionId) : [];
+    this.instances.delete(pluginSessionId);
+    const session = {
+      logicalSessionId: pluginSessionId,
+      physicalSessionId: removed.physicalSessionId
+    };
+    for (const listener of this.sessionClosedListeners) {
+      try {
+        listener(session);
+      } catch {
+      }
+    }
+    if (removed.physicalSessionId === pluginSessionId) {
+      this.deliveryOwnersByPhysicalSession.delete(pluginSessionId);
+    }
+    for (const child of logicalChildren)
+      this.unregisterInstance(child.pluginSessionId);
+    for (const req of Array.from(this.pendingRequests.values())) {
       const stillHasHandler = Array.from(this.instances.values()).some((i) => i.instanceId === req.targetInstanceId && i.role === req.targetRole);
       if (!stillHasHandler) {
-        clearTimeout(req.timeoutId);
-        this.pendingRequests.delete(id);
+        this.removePendingRequest(req);
         req.reject(new Error(`Target (${req.targetInstanceId}, ${req.targetRole}) disconnected`));
       }
     }
@@ -241,9 +2246,14 @@ var BridgeService = class {
     return this.pendingRequests.size;
   }
   updateInstanceActivity(pluginSessionId) {
-    const inst = this.instances.get(pluginSessionId);
-    if (inst) {
-      inst.lastActivity = Date.now();
+    const instance = this.instances.get(pluginSessionId);
+    if (!instance)
+      return;
+    const now = Date.now();
+    for (const candidate of this.instances.values()) {
+      if (candidate.physicalSessionId === instance.physicalSessionId) {
+        candidate.lastActivity = now;
+      }
     }
   }
   updateInstanceMetadata(pluginSessionId, metadata) {
@@ -266,14 +2276,15 @@ var BridgeService = class {
         this.rememberInstanceAlias(priorInstanceId, canonicalInstanceId);
         this.migratePendingRequests(priorInstanceId, canonicalInstanceId);
         inst.instanceId = canonicalInstanceId;
-        this.dispatchPendingPolls(canonicalInstanceId, inst.role);
+        this.notifyRequestAvailable(inst.physicalSessionId);
       }
     }
   }
   cleanupStaleInstances() {
     const now = Date.now();
     for (const [id, inst] of this.instances.entries()) {
-      if (!this.pendingPolls.has(id) && now - inst.lastActivity > STALE_INSTANCE_MS) {
+      const deliveryActive = (this.deliveryOwnersByPhysicalSession.get(inst.physicalSessionId)?.size ?? 0) > 0;
+      if (!deliveryActive && now - inst.lastActivity > STALE_INSTANCE_MS) {
         this.unregisterInstance(id);
       }
     }
@@ -389,23 +2400,28 @@ var BridgeService = class {
       };
     }
     if (distinctInstanceIds.size > 1) {
-      const errorCode = role ? "ambiguous_target" : "multiple_instances_connected";
+      const errorCode2 = role ? "ambiguous_target" : "multiple_instances_connected";
       const msg = role ? `target=${role} is ambiguous because multiple Studio places are connected. Pass instance_id to choose a place.` : "Multiple Studio places are connected. Pass instance_id to disambiguate.";
-      return { ok: false, error: { code: errorCode, message: msg, data: errorData } };
+      return { ok: false, error: { code: errorCode2, message: msg, data: errorData } };
     }
     const onlyInstanceId = distinctInstanceIds.values().next().value;
     return this.resolveTarget({ instance_id: onlyInstanceId, target });
   }
-  async sendRequest(endpoint, data, targetInstanceId, targetRole, timeoutMs = this.requestTimeout) {
+  async sendRequest(endpoint, data, targetInstanceId, targetRole, timeoutMs = this.requestTimeout, signal) {
     const requestId = randomUUID();
     const effectiveTimeoutMs = Math.max(1, timeoutMs);
+    if (signal?.aborted)
+      throw new Error("Request aborted");
     return new Promise((resolve5, reject) => {
-      const timeoutId = setTimeout(() => {
-        if (this.pendingRequests.has(requestId)) {
-          this.pendingRequests.delete(requestId);
-          reject(new Error("Request timeout"));
-        }
-      }, effectiveTimeoutMs);
+      const cancelPending = (reason, error) => {
+        const pending = this.pendingRequests.get(requestId);
+        if (!pending || !this.removePendingRequest(pending))
+          return;
+        this.notifyRequestCancelled(pending, reason);
+        pending.reject(error);
+      };
+      const timeoutId = setTimeout(() => cancelPending("timeout", new Error("Request timeout")), effectiveTimeoutMs);
+      const abortListener = () => cancelPending("aborted", new Error("Request aborted"));
       const request = {
         id: requestId,
         endpoint,
@@ -413,159 +2429,158 @@ var BridgeService = class {
         targetInstanceId,
         targetRole,
         timestamp: Date.now(),
-        inFlight: false,
         resolve: resolve5,
         reject,
         timeoutId,
-        timeoutMs: effectiveTimeoutMs
+        timeoutMs: effectiveTimeoutMs,
+        abortSignal: signal,
+        abortListener
       };
       this.pendingRequests.set(requestId, request);
-      this.dispatchPendingPolls(targetInstanceId, targetRole);
+      signal?.addEventListener("abort", abortListener, { once: true });
+      if (signal?.aborted)
+        abortListener();
+      if (this.pendingRequests.has(requestId)) {
+        for (const physicalSessionId of this.physicalSessionsForTarget(targetInstanceId, targetRole)) {
+          this.notifyRequestAvailable(physicalSessionId);
+        }
+      }
     });
   }
-  getPendingRequest(callerInstanceId, callerRole) {
-    let oldestRequest = null;
+  removePendingRequest(request) {
+    if (this.pendingRequests.get(request.id) !== request)
+      return false;
+    clearTimeout(request.timeoutId);
+    if (request.abortSignal && request.abortListener) {
+      request.abortSignal.removeEventListener("abort", request.abortListener);
+    }
+    this.pendingRequests.delete(request.id);
+    return true;
+  }
+  claimNextRequestForPhysical(physicalSessionId, claimOwner) {
+    let oldestRequest;
+    let logicalSessionId = "";
     for (const request of this.pendingRequests.values()) {
-      if (request.targetInstanceId !== callerInstanceId)
+      if (request.claimOwner !== void 0)
         continue;
-      if (request.targetRole !== callerRole)
-        continue;
-      if (request.inFlight)
+      let matchingSessionId;
+      for (const candidate of this.instances.values()) {
+        if (candidate.physicalSessionId === physicalSessionId && candidate.instanceId === request.targetInstanceId && candidate.role === request.targetRole) {
+          matchingSessionId = candidate.pluginSessionId;
+          break;
+        }
+      }
+      if (!matchingSessionId)
         continue;
       if (!oldestRequest || request.timestamp < oldestRequest.timestamp) {
         oldestRequest = request;
+        logicalSessionId = matchingSessionId;
       }
     }
-    if (oldestRequest) {
-      oldestRequest.inFlight = true;
-      return {
-        requestId: oldestRequest.id,
-        request: {
-          endpoint: oldestRequest.endpoint,
-          data: oldestRequest.data
-        }
-      };
-    }
-    return null;
-  }
-  waitForPendingRequest(pluginSessionId, options = {}) {
-    const instance = this.instances.get(pluginSessionId);
-    if (!instance) {
-      return Promise.resolve({ kind: "unknown_session" });
-    }
-    if (options.signal?.aborted) {
-      return Promise.resolve({ kind: "aborted" });
-    }
-    this.updateInstanceActivity(pluginSessionId);
-    const existingPoll = this.pendingPolls.get(pluginSessionId);
-    if (existingPoll) {
-      this.settlePendingPoll(existingPoll, { kind: "superseded" });
-    }
-    const pendingRequest = this.getPendingRequest(instance.instanceId, instance.role);
-    if (pendingRequest) {
-      return Promise.resolve({
-        kind: "request",
-        requestId: pendingRequest.requestId,
-        request: pendingRequest.request
-      });
-    }
-    if (this.pendingPolls.size >= MAX_ACTIVE_POLLS) {
-      return Promise.resolve({ kind: "capacity" });
-    }
-    const timeoutMs = Math.min(DEFAULT_POLL_WAIT_TIMEOUT_MS, Math.max(1, options.timeoutMs ?? DEFAULT_POLL_WAIT_TIMEOUT_MS));
-    let resolvePoll;
-    const promise = new Promise((resolve5) => {
-      resolvePoll = resolve5;
-    });
-    let waiter;
-    const timeoutId = setTimeout(() => {
-      this.settlePendingPoll(waiter, { kind: "timeout" }, true);
-    }, timeoutMs);
-    timeoutId.unref();
-    waiter = {
-      pluginSessionId,
-      timeoutId,
-      signal: options.signal,
-      resolve: resolvePoll
+    if (!oldestRequest)
+      return null;
+    oldestRequest.claimOwner = claimOwner;
+    oldestRequest.lastDeliveryPhysicalSessionId = physicalSessionId;
+    return {
+      requestId: oldestRequest.id,
+      logicalSessionId,
+      target: oldestRequest.targetRole,
+      endpoint: oldestRequest.endpoint,
+      data: oldestRequest.data,
+      remainingMs: Math.max(1, oldestRequest.timeoutMs - (Date.now() - oldestRequest.timestamp))
     };
-    if (options.signal) {
-      waiter.onAbort = () => {
-        this.settlePendingPoll(waiter, { kind: "aborted" });
-      };
-      options.signal.addEventListener("abort", waiter.onAbort, { once: true });
-    }
-    this.pendingPolls.set(pluginSessionId, waiter);
-    return promise;
   }
-  dispatchPendingPolls(targetInstanceId, targetRole) {
-    for (const waiter of Array.from(this.pendingPolls.values())) {
-      const instance = this.instances.get(waiter.pluginSessionId);
-      if (!instance) {
-        this.settlePendingPoll(waiter, { kind: "session_closed" });
+  claimNextCancellationForPhysical(physicalSessionId, claimOwner) {
+    this.prunePendingCancellations(Date.now());
+    for (const cancellation of this.pendingCancellations.values()) {
+      if (cancellation.physicalSessionId !== physicalSessionId || cancellation.claimOwner !== void 0) {
         continue;
       }
-      if (targetInstanceId !== void 0 && instance.instanceId !== targetInstanceId)
-        continue;
-      if (targetRole !== void 0 && instance.role !== targetRole)
-        continue;
-      const pendingRequest = this.getPendingRequest(instance.instanceId, instance.role);
-      if (!pendingRequest)
-        continue;
-      this.settlePendingPoll(waiter, {
-        kind: "request",
-        requestId: pendingRequest.requestId,
-        request: pendingRequest.request
-      }, true);
+      cancellation.claimOwner = claimOwner;
+      return { requestId: cancellation.requestId, reason: cancellation.reason };
     }
+    return null;
   }
-  settlePendingPoll(waiter, result, refreshActivity = false) {
-    if (this.pendingPolls.get(waiter.pluginSessionId) !== waiter)
-      return;
-    this.pendingPolls.delete(waiter.pluginSessionId);
-    clearTimeout(waiter.timeoutId);
-    if (waiter.signal && waiter.onAbort) {
-      waiter.signal.removeEventListener("abort", waiter.onAbort);
+  releaseDeliveryClaims(claimOwner) {
+    const physicalSessionIds = /* @__PURE__ */ new Set();
+    for (const request of this.pendingRequests.values()) {
+      if (request.claimOwner !== claimOwner)
+        continue;
+      request.claimOwner = void 0;
+      for (const physicalSessionId of this.physicalSessionsForTarget(request.targetInstanceId, request.targetRole)) {
+        physicalSessionIds.add(physicalSessionId);
+      }
+    }
+    for (const cancellation of this.pendingCancellations.values()) {
+      if (cancellation.claimOwner !== claimOwner)
+        continue;
+      cancellation.claimOwner = void 0;
+      physicalSessionIds.add(cancellation.physicalSessionId);
     }
-    if (refreshActivity) {
-      this.updateInstanceActivity(waiter.pluginSessionId);
+    for (const physicalSessionId of physicalSessionIds) {
+      this.notifyRequestAvailable(physicalSessionId);
     }
-    waiter.resolve(result);
   }
   resolveRequest(requestId, response) {
-    const request = this.pendingRequests.get(requestId);
-    if (request) {
-      clearTimeout(request.timeoutId);
-      this.pendingRequests.delete(requestId);
-      request.resolve(response);
-    }
+    return this.settleRequest(requestId, (request) => request.resolve(response));
   }
   rejectRequest(requestId, error) {
+    return this.settleRequest(requestId, (request) => request.reject(error));
+  }
+  settleRequest(requestId, settle) {
+    const now = Date.now();
+    this.pruneAcceptedRequestIds(now);
     const request = this.pendingRequests.get(requestId);
-    if (request) {
-      clearTimeout(request.timeoutId);
-      this.pendingRequests.delete(requestId);
-      request.reject(error);
+    if (!request) {
+      return this.acceptedRequestIds.has(requestId) ? "already_settled" : "unknown";
+    }
+    this.removePendingRequest(request);
+    this.acceptedRequestIds.set(requestId, now);
+    this.pruneAcceptedRequestIds(now);
+    settle(request);
+    return "accepted";
+  }
+  pruneAcceptedRequestIds(now) {
+    for (const [requestId, acceptedAt] of this.acceptedRequestIds) {
+      if (now - acceptedAt < ACCEPTED_REQUEST_TOMBSTONE_TTL_MS)
+        break;
+      this.acceptedRequestIds.delete(requestId);
+    }
+    while (this.acceptedRequestIds.size > MAX_ACCEPTED_REQUEST_TOMBSTONES) {
+      const oldestRequestId = this.acceptedRequestIds.keys().next().value;
+      if (oldestRequestId === void 0)
+        break;
+      this.acceptedRequestIds.delete(oldestRequestId);
+    }
+  }
+  prunePendingCancellations(now) {
+    for (const [requestId, cancellation] of this.pendingCancellations) {
+      if (now - cancellation.createdAt < CANCELLATION_TOMBSTONE_TTL_MS)
+        break;
+      this.pendingCancellations.delete(requestId);
+    }
+    while (this.pendingCancellations.size > MAX_CANCELLATION_TOMBSTONES) {
+      const oldestRequestId = this.pendingCancellations.keys().next().value;
+      if (oldestRequestId === void 0)
+        break;
+      this.pendingCancellations.delete(oldestRequestId);
     }
   }
   cleanupOldRequests() {
     const now = Date.now();
-    for (const [id, request] of this.pendingRequests.entries()) {
-      if (now - request.timestamp > request.timeoutMs) {
-        clearTimeout(request.timeoutId);
-        this.pendingRequests.delete(id);
+    for (const request of this.pendingRequests.values()) {
+      if (now - request.timestamp > request.timeoutMs && this.removePendingRequest(request)) {
+        this.notifyRequestCancelled(request, "timeout");
         request.reject(new Error("Request timeout"));
       }
     }
   }
   clearAllPendingRequests() {
-    for (const [, request] of this.pendingRequests.entries()) {
-      clearTimeout(request.timeoutId);
+    for (const request of Array.from(this.pendingRequests.values())) {
+      this.removePendingRequest(request);
       request.reject(new Error("Connection closed"));
     }
-    this.pendingRequests.clear();
-    for (const waiter of Array.from(this.pendingPolls.values())) {
-      this.settlePendingPoll(waiter, { kind: "bridge_closed" });
-    }
+    this.pendingCancellations.clear();
   }
 };
 
@@ -3377,8 +5392,7 @@ var INTERNAL_RESULT_KEYS = /* @__PURE__ */ new Set([
   "pluginVariant",
   "pluginVersion",
   "requestId",
-  "serverVersion",
-  "versionMismatch"
+  "serverVersion"
 ]);
 var TEXT_RESULT_TOOLS = /* @__PURE__ */ new Set(["get_roblox_docs"]);
 var SIDE_EFFECTING_READ_TOOLS = /* @__PURE__ */ new Set([
@@ -3591,9 +5605,9 @@ function createToolServer(options) {
       inputSchema: fromJsonSchema(publicDefinition.inputSchema),
       ...publicDefinition.outputSchema ? { outputSchema: fromJsonSchema(publicDefinition.outputSchema) } : {},
       annotations: publicDefinition.annotations
-    }, async (args) => {
+    }, async (args, context) => {
       try {
-        const raw = await options.invoke(options.getTools(), definition.name, args);
+        const raw = await options.invoke(options.getTools(), definition.name, args, { signal: context.mcpReq.signal });
         return normalizeToolResult(raw, options.era);
       } catch (error) {
         return normalizeToolResult({
@@ -3649,12 +5663,196 @@ function resolveAuthToken() {
     console.error(`[auth] Could not read/create ${filePath} (${err2 instanceof Error ? err2.message : err2}). Using an in-memory token for this process; set ROBLOX_STUDIO_AUTH_TOKEN to share one across sessions.`);
     return { token: randomBytes(32).toString("hex"), source: "file" };
   }
-}
-function tokensMatch(provided, expected) {
-  const a = createHash("sha256").update(provided).digest();
-  const b = createHash("sha256").update(expected).digest();
-  return timingSafeEqual(a, b);
-}
+}
+function tokensMatch(provided, expected) {
+  const a = createHash("sha256").update(provided).digest();
+  const b = createHash("sha256").update(expected).digest();
+  return timingSafeEqual(a, b);
+}
+
+// ../core/dist/studio-transport.js
+var HEARTBEAT_INTERVAL_MS = 1e4;
+var MAX_ACTIVE_EVENT_STREAMS = 64;
+var SseStudioTransport = class {
+  queue;
+  streams = /* @__PURE__ */ new Map();
+  unsubscribeRequestAvailable;
+  unsubscribeSessionClosed;
+  nextGeneration = 0;
+  constructor(queue) {
+    this.queue = queue;
+    this.unsubscribeRequestAvailable = queue.onRequestAvailable((physicalSessionId) => {
+      const stream = this.streams.get(physicalSessionId);
+      if (stream)
+        this.pump(stream);
+    });
+    this.unsubscribeSessionClosed = queue.onSessionClosed((route) => {
+      if (route.logicalSessionId === route.physicalSessionId) {
+        this.closePhysical(route.physicalSessionId);
+      }
+    });
+  }
+  get activeStreamCount() {
+    return this.streams.size;
+  }
+  canOpen(physicalSessionId) {
+    return this.streams.has(physicalSessionId) || this.streams.size < MAX_ACTIVE_EVENT_STREAMS;
+  }
+  open(physicalSessionId, sink, status) {
+    if (!this.canOpen(physicalSessionId))
+      return void 0;
+    this.nextGeneration += 1;
+    const claimOwner = `sse:${physicalSessionId}:${this.nextGeneration}`;
+    const stream = {
+      physicalSessionId,
+      claimOwner,
+      sink,
+      status,
+      closed: false,
+      blocked: false,
+      statusPending: true,
+      onClose: () => this.closeStream(stream),
+      onDrain: () => {
+        if (stream.closed)
+          return;
+        stream.blocked = false;
+        this.pump(stream);
+      }
+    };
+    this.queue.setDeliveryActive(physicalSessionId, claimOwner, true);
+    this.queue.updateInstanceActivity(physicalSessionId);
+    const replaced = this.streams.get(physicalSessionId);
+    if (replaced)
+      this.closeStream(replaced, true);
+    this.streams.set(physicalSessionId, stream);
+    sink.on("close", stream.onClose);
+    sink.on("error", stream.onClose);
+    sink.on("drain", stream.onDrain);
+    stream.heartbeatTimer = setInterval(() => {
+      if (!stream.closed && !stream.blocked) {
+        this.queue.updateInstanceActivity(physicalSessionId);
+        stream.statusPending = true;
+        this.pump(stream);
+        if (!stream.blocked) {
+          this.write(stream, { kind: "heartbeat", timestamp: Date.now() });
+        }
+      }
+    }, HEARTBEAT_INTERVAL_MS);
+    stream.heartbeatTimer.unref();
+    this.pump(stream);
+    return {
+      physicalSessionId,
+      close: () => this.closeStream(stream, true)
+    };
+  }
+  refreshStatus(physicalSessionId) {
+    if (physicalSessionId !== void 0) {
+      const stream = this.streams.get(physicalSessionId);
+      if (stream) {
+        stream.lastStatusJson = void 0;
+        stream.statusPending = true;
+        this.pump(stream);
+      }
+      return;
+    }
+    for (const stream of this.streams.values()) {
+      stream.lastStatusJson = void 0;
+      stream.statusPending = true;
+      this.pump(stream);
+    }
+  }
+  closePhysical(physicalSessionId) {
+    const stream = this.streams.get(physicalSessionId);
+    if (stream)
+      this.closeStream(stream, true);
+  }
+  close() {
+    for (const stream of Array.from(this.streams.values())) {
+      this.closeStream(stream, true);
+    }
+    this.unsubscribeRequestAvailable();
+    this.unsubscribeSessionClosed();
+  }
+  pump(stream) {
+    if (stream.closed || stream.blocked || this.streams.get(stream.physicalSessionId) !== stream)
+      return;
+    if (stream.statusPending) {
+      stream.statusPending = false;
+      let status;
+      try {
+        status = stream.status();
+      } catch {
+        this.closeStream(stream);
+        return;
+      }
+      const statusJson = JSON.stringify(status);
+      if (statusJson !== stream.lastStatusJson) {
+        stream.lastStatusJson = statusJson;
+        if (!this.write(stream, status))
+          return;
+      }
+    }
+    while (!stream.closed && !stream.blocked) {
+      const cancellation = this.queue.claimNextCancellationForPhysical(stream.physicalSessionId, stream.claimOwner);
+      if (!cancellation)
+        break;
+      if (!this.write(stream, { kind: "cancel", ...cancellation }))
+        return;
+    }
+    while (!stream.closed && !stream.blocked) {
+      const request = this.queue.claimNextRequestForPhysical(stream.physicalSessionId, stream.claimOwner);
+      if (!request)
+        return;
+      const event = {
+        kind: "request",
+        requestId: request.requestId,
+        logicalSessionId: request.logicalSessionId,
+        target: request.target,
+        endpoint: request.endpoint,
+        data: request.data === void 0 ? null : request.data,
+        remainingMs: request.remainingMs
+      };
+      if (!this.write(stream, event))
+        return;
+    }
+  }
+  write(stream, event) {
+    if (stream.closed)
+      return false;
+    try {
+      const writable = stream.sink.write(`data: ${JSON.stringify(event)}
+
+`);
+      if (!writable)
+        stream.blocked = true;
+      return writable;
+    } catch {
+      this.closeStream(stream);
+      return false;
+    }
+  }
+  closeStream(stream, endSink = false) {
+    if (stream.closed)
+      return;
+    stream.closed = true;
+    clearInterval(stream.heartbeatTimer);
+    stream.sink.removeListener("close", stream.onClose);
+    stream.sink.removeListener("error", stream.onClose);
+    stream.sink.removeListener("drain", stream.onDrain);
+    if (this.streams.get(stream.physicalSessionId) === stream) {
+      this.streams.delete(stream.physicalSessionId);
+    }
+    this.queue.updateInstanceActivity(stream.physicalSessionId);
+    this.queue.setDeliveryActive(stream.physicalSessionId, stream.claimOwner, false);
+    this.queue.releaseDeliveryClaims(stream.claimOwner);
+    if (endSink) {
+      try {
+        stream.sink.end();
+      } catch {
+      }
+    }
+  }
+};
 
 // ../core/dist/http-server.js
 function parseLineRange(lineRange) {
@@ -3713,7 +5911,7 @@ var TOOL_HANDLERS = {
   get_instance_properties: (tools, body) => tools.getInstanceProperties(body.instancePath, body.excludeSource, body.instance_id),
   get_project_structure: (tools, body) => tools.getProjectStructure(body.path, body.maxDepth, body.scriptsOnly, body.instance_id),
   set_properties: (tools, body) => tools.setProperties(body.instancePath, body.properties, body.instance_id),
-  grep_scripts: (tools, body) => tools.grepScripts(body.pattern, {
+  grep_scripts: (tools, body, context) => tools.grepScripts(body.pattern, {
     caseSensitive: body.caseSensitive,
     usePattern: body.usePattern,
     contextLines: body.contextLines,
@@ -3722,7 +5920,7 @@ var TOOL_HANDLERS = {
     filesOnly: body.filesOnly,
     path: body.path,
     classFilter: body.classFilter
-  }, body.instance_id),
+  }, body.instance_id, context?.signal),
   get_script_source: (tools, body) => {
     const { startLine, endLine } = optionalLineRange(body, "get_script_source");
     return tools.getScriptSource(body.instancePath, startLine, endLine, body.instance_id);
@@ -3812,26 +6010,26 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig, security) {
   let lastMCPActivity = 0;
   let mcpServerStartTime = 0;
   const proxyInstances = /* @__PURE__ */ new Set();
-  const warnedVersionMismatches = /* @__PURE__ */ new Set();
-  let activePollEpoch = new AbortController();
-  activePollEpoch.abort();
+  const rejectedVersionSessions = /* @__PURE__ */ new Set();
+  const eventTransport = new SseStudioTransport(bridge);
+  const eventStreamHandles = /* @__PURE__ */ new Set();
   const setMCPServerActive = (active) => {
     mcpServerActive = active;
     if (active) {
-      if (activePollEpoch.signal.aborted) {
-        activePollEpoch = new AbortController();
-      }
       mcpServerStartTime = Date.now();
       lastMCPActivity = Date.now();
     } else {
-      activePollEpoch.abort();
       mcpServerStartTime = 0;
       lastMCPActivity = 0;
     }
+    eventTransport.refreshStatus();
   };
   const trackMCPActivity = () => {
     if (mcpServerActive) {
+      const wasConnected = Date.now() - lastMCPActivity < 3e4;
       lastMCPActivity = Date.now();
+      if (!wasConnected)
+        eventTransport.refreshStatus();
     }
   };
   const isMCPServerActive = () => {
@@ -3839,6 +6037,18 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig, security) {
       return false;
     return Date.now() - lastMCPActivity < 3e4;
   };
+  const eventStatus = (physicalSessionId) => {
+    const instance = bridge.getInstanceBySessionId(physicalSessionId);
+    const knownInstance = instance?.physicalSessionId === physicalSessionId;
+    return {
+      kind: "status",
+      knownInstance,
+      mcpConnected: isMCPServerActive(),
+      serverVersion: serverConfig?.version,
+      pluginVersion: instance?.pluginVersion,
+      pluginVariant: instance?.pluginVariant
+    };
+  };
   const isPluginConnected = () => {
     return bridge.getInstances().length > 0;
   };
@@ -3908,17 +6118,18 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig, security) {
       pluginConnected: instances.length > 0,
       instanceCount: instances.length,
       instances: publicInstances,
-      versionMismatch: publicInstances.some((inst) => inst.versionMismatch),
       mcpServerActive: isMCPServerActive(),
       uptime: mcpServerActive ? Date.now() - mcpServerStartTime : 0,
       pendingRequests: bridge.getPendingRequestCount(),
       proxyInstanceCount: proxyInstances.size,
+      activeEventStreams: eventTransport.activeStreamCount,
       streamableHttp: !!serverConfig
     });
   });
   app.post("/ready", (req, res) => {
-    const { pluginSessionId, instanceId, role, placeId, placeName, dataModelName, isRunning, pluginVersion, pluginVariant } = req.body;
+    const { pluginSessionId, physicalSessionId, instanceId, role, placeId, placeName, dataModelName, isRunning, pluginVersion, pluginVariant } = req.body;
     const requestContext = {
+      physicalSessionId: typeof physicalSessionId === "string" ? physicalSessionId : void 0,
       instanceId: typeof instanceId === "string" ? instanceId : void 0,
       role: typeof role === "string" ? role : void 0,
       placeId: typeof placeId === "number" ? placeId : void 0,
@@ -3928,12 +6139,15 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig, security) {
       pluginVersion: typeof pluginVersion === "string" ? pluginVersion : void 0,
       pluginVariant: typeof pluginVariant === "string" ? pluginVariant : void 0
     };
-    if (!pluginSessionId || !instanceId || !role) {
-      const missingFields = [
-        !pluginSessionId ? "pluginSessionId" : void 0,
-        !instanceId ? "instanceId" : void 0,
-        !role ? "role" : void 0
-      ].filter((field) => !!field);
+    const missingFields = [
+      typeof pluginSessionId !== "string" || pluginSessionId === "" ? "pluginSessionId" : void 0,
+      typeof physicalSessionId !== "string" || physicalSessionId === "" ? "physicalSessionId" : void 0,
+      typeof instanceId !== "string" || instanceId === "" ? "instanceId" : void 0,
+      typeof role !== "string" || role === "" ? "role" : void 0,
+      typeof pluginVersion !== "string" || pluginVersion === "" ? "pluginVersion" : void 0,
+      typeof pluginVariant !== "string" || pluginVariant === "" ? "pluginVariant" : void 0
+    ].filter((field) => !!field);
+    if (missingFields.length > 0) {
       res.status(400).json({
         success: false,
         error: "missing_ready_fields",
@@ -3943,19 +6157,71 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig, security) {
       });
       return;
     }
+    const serverVersion = serverConfig?.version;
+    if (!serverVersion) {
+      res.status(503).json({
+        success: false,
+        error: "server_version_unavailable",
+        message: "The MCP server cannot accept Studio connections without a configured version.",
+        request: requestContext
+      });
+      return;
+    }
+    if (pluginVersion !== serverVersion) {
+      if (!rejectedVersionSessions.has(pluginSessionId)) {
+        if (rejectedVersionSessions.size >= 256)
+          rejectedVersionSessions.clear();
+        rejectedVersionSessions.add(pluginSessionId);
+        console.error(`[plugin-version-rejected] Studio plugin v${pluginVersion} (${pluginVariant}) does not match MCP server v${serverVersion} for ${instanceId}/${role}`);
+      }
+      res.status(426).json({
+        success: false,
+        error: "plugin_version_mismatch",
+        message: `Studio plugin v${pluginVersion} does not match MCP server v${serverVersion}.`,
+        pluginVersion,
+        serverVersion,
+        request: requestContext
+      });
+      return;
+    }
+    const isClientRole = role === "client" || /^client-[1-9]\d*$/.test(role);
+    const isLogicalSession = physicalSessionId !== pluginSessionId;
+    if (isLogicalSession && !isClientRole || !isLogicalSession && isClientRole || !isClientRole && role !== "edit" && role !== "server") {
+      res.status(400).json({
+        success: false,
+        error: "invalid_session_topology",
+        message: "Physical sessions must use the edit or server role; client roles must use a distinct physical server session.",
+        request: requestContext
+      });
+      return;
+    }
+    if (isLogicalSession) {
+      const physicalOwner = bridge.getInstanceBySessionId(physicalSessionId);
+      const requestedInstanceId = typeof placeId === "number" && Number.isFinite(placeId) && placeId > 0 ? `place:${Math.trunc(placeId)}` : bridge.resolveInstanceId(instanceId);
+      if (!physicalOwner || physicalOwner.pluginSessionId !== physicalSessionId || physicalOwner.physicalSessionId !== physicalSessionId || physicalOwner.role !== "server" || physicalOwner.instanceId !== requestedInstanceId) {
+        res.status(409).json({
+          success: false,
+          error: "physical_session_unavailable",
+          message: "A logical client requires a registered physical server session for the same Studio instance.",
+          request: requestContext
+        });
+        return;
+      }
+    }
     let result;
     try {
       result = bridge.registerInstance({
         pluginSessionId,
+        physicalSessionId,
         instanceId,
         role,
         placeId: typeof placeId === "number" ? placeId : 0,
         placeName: typeof placeName === "string" ? placeName : "",
         dataModelName: typeof dataModelName === "string" ? dataModelName : "",
         isRunning: !!isRunning,
-        pluginVersion: typeof pluginVersion === "string" ? pluginVersion : "",
-        pluginVariant: typeof pluginVariant === "string" ? pluginVariant : "unknown",
-        serverVersion: serverConfig?.version ?? ""
+        pluginVersion,
+        pluginVariant,
+        serverVersion
       });
     } catch (err2) {
       res.status(500).json({
@@ -3976,17 +6242,12 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig, security) {
       });
       return;
     }
-    const registered = bridge.getInstanceBySessionId(pluginSessionId);
-    if (registered?.versionMismatch && !warnedVersionMismatches.has(pluginSessionId)) {
-      warnedVersionMismatches.add(pluginSessionId);
-      console.error(`[version-mismatch] Studio plugin v${registered.pluginVersion} (${registered.pluginVariant}) does not match MCP server v${registered.serverVersion} for ${registered.instanceId}/${registered.role}`);
-    }
+    eventTransport.refreshStatus(physicalSessionId);
     res.json({
       success: true,
       assignedRole: result.assignedRole,
       instanceId: result.instanceId,
-      serverVersion: serverConfig?.version,
-      versionMismatch: registered?.versionMismatch ?? false
+      serverVersion
     });
   });
   app.post("/disconnect", (req, res) => {
@@ -4013,7 +6274,6 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig, security) {
       instanceCount: instances.length,
       instances: publicInstances,
       serverVersion: serverConfig?.version,
-      versionMismatch: publicInstances.some((inst) => inst.versionMismatch),
       mcpServerActive: isMCPServerActive(),
       lastMCPActivity,
       uptime: mcpServerActive ? Date.now() - mcpServerStartTime : 0
@@ -4023,205 +6283,112 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig, security) {
     const instances = bridge.getInstances();
     res.json({
       instances,
-      serverVersion: serverConfig?.version,
-      versionMismatch: instances.some((inst) => inst.versionMismatch)
+      serverVersion: serverConfig?.version
     });
   });
-  app.get("/poll", async (req, res, next) => {
+  app.get("/events", (req, res) => {
     const pluginSessionId = typeof req.query.pluginSessionId === "string" ? req.query.pluginSessionId : void 0;
-    const longPollRequested = req.query.pollMode === "long";
-    if (pluginSessionId) {
-      bridge.updateInstanceActivity(pluginSessionId);
-    }
-    const pollMetadata = () => {
-      const instance = pluginSessionId ? bridge.getInstanceBySessionId(pluginSessionId) : void 0;
-      return {
-        knownInstance: instance !== void 0,
-        pluginVersion: instance?.pluginVersion,
-        pluginVariant: instance?.pluginVariant,
-        versionMismatch: instance?.versionMismatch ?? false
-      };
-    };
-    let metadata = pollMetadata();
-    if (!isMCPServerActive()) {
-      res.status(503).json({
-        error: "MCP server not connected",
-        pluginConnected: true,
-        mcpConnected: false,
-        knownInstance: metadata.knownInstance,
-        serverVersion: serverConfig?.version,
-        pluginVersion: metadata.pluginVersion,
-        pluginVariant: metadata.pluginVariant,
-        versionMismatch: metadata.versionMismatch,
-        request: null
+    if (!pluginSessionId) {
+      res.status(400).json({
+        error: "missing_plugin_session_id",
+        message: "pluginSessionId is required"
       });
       return;
     }
-    if (!pluginSessionId || !metadata.knownInstance) {
-      res.json({
-        request: null,
-        mcpConnected: true,
-        pluginConnected: true,
-        knownInstance: false,
-        serverVersion: serverConfig?.version,
-        pluginVersion: metadata.pluginVersion,
-        pluginVariant: metadata.pluginVariant,
-        versionMismatch: metadata.versionMismatch,
-        proxyInstanceCount: proxyInstances.size,
-        pollMode: longPollRequested ? "long" : void 0
+    const instance = bridge.getInstanceBySessionId(pluginSessionId);
+    if (!instance) {
+      res.status(404).json({
+        error: "unknown_session",
+        knownInstance: false
       });
       return;
     }
-    if (!longPollRequested) {
-      const instance = bridge.getInstanceBySessionId(pluginSessionId);
-      const pendingRequest = instance ? bridge.getPendingRequest(instance.instanceId, instance.role) : null;
-      metadata = pollMetadata();
-      res.json({
-        request: pendingRequest?.request ?? null,
-        requestId: pendingRequest?.requestId,
-        mcpConnected: true,
-        pluginConnected: true,
-        knownInstance: metadata.knownInstance,
-        serverVersion: serverConfig?.version,
-        pluginVersion: metadata.pluginVersion,
-        pluginVariant: metadata.pluginVariant,
-        versionMismatch: metadata.versionMismatch,
-        proxyInstanceCount: proxyInstances.size
+    if (instance.physicalSessionId !== pluginSessionId) {
+      res.status(409).json({
+        error: "logical_session_has_no_event_stream",
+        physicalSessionId: instance.physicalSessionId
       });
       return;
     }
-    const pollEpoch = activePollEpoch;
-    const pollController = new AbortController();
-    let socketClosed = false;
-    let mcpBecameInactive = false;
-    const detachListeners = () => {
-      req.removeListener("aborted", onSocketClosed);
-      res.removeListener("close", onSocketClosed);
-      res.removeListener("finish", onResponseFinished);
-      pollEpoch.signal.removeEventListener("abort", onMCPInactive);
-    };
-    const onSocketClosed = () => {
-      socketClosed = true;
-      pollController.abort();
-      detachListeners();
-    };
-    const onResponseFinished = () => {
-      detachListeners();
-    };
-    const onMCPInactive = () => {
-      mcpBecameInactive = true;
-      pollController.abort();
-    };
-    req.once("aborted", onSocketClosed);
-    res.once("close", onSocketClosed);
-    res.once("finish", onResponseFinished);
-    pollEpoch.signal.addEventListener("abort", onMCPInactive, { once: true });
-    if (req.aborted || res.destroyed) {
-      onSocketClosed();
-    } else if (pollEpoch.signal.aborted) {
-      onMCPInactive();
-    }
-    try {
-      const result = await bridge.waitForPendingRequest(pluginSessionId, {
-        signal: pollController.signal
-      });
-      if (socketClosed || res.destroyed) {
-        return;
-      }
-      metadata = pollMetadata();
-      if (result.kind === "request" && metadata.knownInstance) {
-        res.json({
-          request: result.request,
-          requestId: result.requestId,
-          mcpConnected: true,
-          pluginConnected: true,
-          knownInstance: true,
-          serverVersion: serverConfig?.version,
-          pluginVersion: metadata.pluginVersion,
-          pluginVariant: metadata.pluginVariant,
-          versionMismatch: metadata.versionMismatch,
-          proxyInstanceCount: proxyInstances.size,
-          pollMode: "long"
-        });
-        return;
-      }
-      if (mcpBecameInactive || pollEpoch.signal.aborted || !isMCPServerActive()) {
-        res.status(503).json({
-          error: "MCP server not connected",
-          pluginConnected: true,
-          mcpConnected: false,
-          knownInstance: metadata.knownInstance,
-          serverVersion: serverConfig?.version,
-          pluginVersion: metadata.pluginVersion,
-          pluginVariant: metadata.pluginVariant,
-          versionMismatch: metadata.versionMismatch,
-          request: null
-        });
-        return;
-      }
-      if (result.kind === "capacity") {
-        res.setHeader("Retry-After", "1");
-        res.status(503).json({
-          error: "Poll capacity reached",
-          code: "poll_capacity_reached",
-          pluginConnected: true,
-          mcpConnected: true,
-          knownInstance: metadata.knownInstance,
-          request: null
-        });
-        return;
-      }
-      res.json({
-        request: null,
-        mcpConnected: true,
-        pluginConnected: true,
-        knownInstance: metadata.knownInstance,
-        serverVersion: serverConfig?.version,
-        pluginVersion: metadata.pluginVersion,
-        pluginVariant: metadata.pluginVariant,
-        versionMismatch: metadata.versionMismatch,
-        proxyInstanceCount: proxyInstances.size,
-        pollMode: "long"
+    if (!eventTransport.canOpen(pluginSessionId)) {
+      res.setHeader("Retry-After", "1");
+      res.status(503).json({
+        error: "event_stream_capacity_reached",
+        capacity: MAX_ACTIVE_EVENT_STREAMS
       });
-    } catch (error) {
-      detachListeners();
-      next(error);
+      return;
+    }
+    bridge.updateInstanceActivity(pluginSessionId);
+    res.status(200);
+    res.setHeader("Content-Type", "text/event-stream; charset=utf-8");
+    res.setHeader("Cache-Control", "no-cache, no-transform");
+    res.setHeader("Connection", "keep-alive");
+    res.setHeader("X-Accel-Buffering", "no");
+    res.flushHeaders();
+    const handle = eventTransport.open(pluginSessionId, res, () => eventStatus(pluginSessionId));
+    if (!handle) {
+      res.end();
+      return;
     }
+    eventStreamHandles.add(handle);
+    res.once("close", () => eventStreamHandles.delete(handle));
   });
   app.post("/response", (req, res) => {
     const { requestId, response, error } = req.body;
-    if (error) {
-      bridge.rejectRequest(requestId, error);
-    } else {
-      bridge.resolveRequest(requestId, response);
+    if (typeof requestId !== "string" || requestId.length === 0) {
+      res.status(400).json({
+        success: false,
+        error: "invalid_request_id"
+      });
+      return;
     }
-    res.json({ success: true });
+    const disposition = error !== void 0 ? bridge.rejectRequest(requestId, error) : bridge.resolveRequest(requestId, response);
+    if (disposition === "unknown") {
+      res.status(404).json({ success: false, disposition });
+      return;
+    }
+    res.json({ success: true, disposition });
   });
   app.post("/proxy", async (req, res) => {
-    const { endpoint, data, targetInstanceId, targetRole, proxyInstanceId } = req.body;
+    const { endpoint, data, targetInstanceId, targetRole, proxyInstanceId, timeoutMs } = req.body;
     if (!endpoint || !targetInstanceId || !targetRole) {
       res.status(400).json({ error: "endpoint, targetInstanceId, and targetRole are required" });
       return;
     }
+    if (timeoutMs !== void 0 && (!Number.isInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 3e5)) {
+      res.status(400).json({ error: "timeoutMs must be an integer between 1 and 300000" });
+      return;
+    }
     if (proxyInstanceId) {
       proxyInstances.add(proxyInstanceId);
     }
+    const controller = new AbortController();
+    const abort = () => controller.abort();
+    req.once("aborted", abort);
+    res.once("close", abort);
     try {
-      const response = await bridge.sendRequest(endpoint, data, targetInstanceId, targetRole);
+      const response = await bridge.sendRequest(endpoint, data, targetInstanceId, targetRole, timeoutMs, controller.signal);
       res.json({ response });
-    } catch (err2) {
-      res.status(500).json({ error: err2.message || "Proxy request failed" });
+    } catch (error) {
+      if (!res.headersSent && !res.destroyed) {
+        res.status(500).json({
+          error: error instanceof Error ? error.message : "Proxy request failed"
+        });
+      }
+    } finally {
+      req.removeListener("aborted", abort);
+      res.removeListener("close", abort);
     }
   });
   const mcpHandler = serverConfig ? createToolHttpHandler({
     config: serverConfig,
     getTools: () => tools,
     allowedTools,
-    invoke: async (currentTools, name, args) => {
+    invoke: async (currentTools, name, args, context) => {
       const handler = TOOL_HANDLERS[name];
       if (!handler)
         throw new Error(`Unknown tool: ${name}`);
-      return handler(currentTools, args);
+      return handler(currentTools, args, context);
     }
   }) : void 0;
   const nodeMcpHandler = mcpHandler ? toNodeHandler(mcpHandler) : void 0;
@@ -4257,27 +6424,30 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig, security) {
   app.isMCPServerActive = isMCPServerActive;
   app.trackMCPActivity = trackMCPActivity;
   app.closeMcpHandler = () => mcpHandler?.close();
+  app.cleanup = async () => {
+    for (const handle of eventStreamHandles)
+      handle.close();
+    eventStreamHandles.clear();
+    eventTransport.close();
+    await mcpHandler?.close();
+  };
   return app;
 }
-function listenWithRetry(app, host, startPort, maxAttempts = 5) {
-  return new Promise(async (resolve5, reject) => {
-    for (let i = 0; i < maxAttempts; i++) {
-      const port = startPort + i;
-      try {
-        const server = await bindPort(app, host, port);
-        resolve5({ server, port });
-        return;
-      } catch (err2) {
-        if (err2.code === "EADDRINUSE") {
-          console.error(`Port ${port} in use, trying next...`);
-          continue;
-        }
-        reject(err2);
-        return;
+async function listenWithRetry(app, host, startPort, maxAttempts = 5) {
+  for (let i = 0; i < maxAttempts; i++) {
+    const port = startPort + i;
+    try {
+      const server = await bindPort(app, host, port);
+      return { server, port };
+    } catch (error) {
+      if (error !== null && typeof error === "object" && "code" in error && error.code === "EADDRINUSE") {
+        console.error(`Port ${port} in use, trying next...`);
+        continue;
       }
+      throw error;
     }
-    reject(new Error(`All ports ${startPort}-${startPort + maxAttempts - 1} are in use. Stop some MCP server instances and retry.`));
-  });
+  }
+  throw new Error(`All ports ${startPort}-${startPort + maxAttempts - 1} are in use. Stop some MCP server instances and retry.`);
 }
 function bindPort(app, host, port) {
   return new Promise((resolve5, reject) => {
@@ -4300,9 +6470,9 @@ var StudioHttpClient = class {
   constructor(bridge) {
     this.bridge = bridge;
   }
-  async request(endpoint, data, targetInstanceId, targetRole, timeoutMs) {
+  async request(endpoint, data, targetInstanceId, targetRole, timeoutMs, signal) {
     try {
-      const response = await this.bridge.sendRequest(endpoint, data, targetInstanceId, targetRole, timeoutMs);
+      const response = await this.bridge.sendRequest(endpoint, data, targetInstanceId, targetRole, timeoutMs, signal);
       return response;
     } catch (error) {
       if (error instanceof Error && error.message === "Request timeout") {
@@ -7106,6 +9276,7 @@ function rgbaToPng(rgba, width, height) {
 import * as fs3 from "fs";
 import * as path5 from "path";
 var MAX_INLINE_IMAGE_BYTES = 6e6;
+var MAX_MATRIX_IMAGE_BYTES = 8e6;
 var DEFAULT_ASSET_AUDIO_PREVIEWS = 3;
 var MAX_ASSET_AUDIO_PREVIEWS = 5;
 var MAX_INLINE_AUDIO_PREVIEW_BYTES = 3e6;
@@ -7116,6 +9287,8 @@ var MAX_SEARCH_ASSET_DESCRIPTION_LENGTH = 240;
 var ROBLOX_CREATOR_USER_ID = 1;
 var MAX_DEVICE_MATRIX_ENTRIES = 6;
 var MAX_NETWORK_PACKET_LOSS_PERCENT = 0.5;
+var GREP_SCRIPTS_TIMEOUT_MS = 12e4;
+var MAX_GREP_PATTERN_UTF8_BYTES = 4096;
 var STUDIO_ASSISTANT_SOURCE_IMAGE_LABEL = "Studio Assistant Source Image";
 var CREATOR_STORE_SEARCH_TYPES = /* @__PURE__ */ new Set([
   "Audio",
@@ -7942,7 +10115,7 @@ var RobloxStudioTools = class {
   // ambiguous, missing, or asks for fanout on a non-fanout-capable tool —
   // the MCP transport layer surfaces it as a structured error result so
   // the LLM can recover via the embedded data.instances list.
-  async _callSingle(endpoint, data, target, instance_id, timeoutMs) {
+  async _callSingle(endpoint, data, target, instance_id, timeoutMs, signal) {
     const r = this.bridge.resolveTarget({ instance_id, target });
     if (!r.ok)
       throw new RoutingFailure(r.error);
@@ -7956,7 +10129,10 @@ var RobloxStudioTools = class {
         }
       });
     }
-    return this.client.request(endpoint, data, r.targetInstanceId, r.targetRole, timeoutMs);
+    if (signal === void 0) {
+      return this.client.request(endpoint, data, r.targetInstanceId, r.targetRole, timeoutMs);
+    }
+    return this.client.request(endpoint, data, r.targetInstanceId, r.targetRole, timeoutMs, signal);
   }
   // Resolves which connected place a tool should target and whether a playtest
   // CLIENT peer is present on it. Used by capture/input to auto-route to the
@@ -8047,7 +10223,7 @@ var RobloxStudioTools = class {
   }
   _resolveDeviceSimulatorSingleTarget(target, instance_id, toolName) {
     const selectedTarget = target ?? "edit";
-    if (selectedTarget === "server" || selectedTarget === "all" || selectedTarget === "all-clients" || selectedTarget === "edit-proxy") {
+    if (selectedTarget === "server" || selectedTarget === "all" || selectedTarget === "all-clients") {
       throw new Error(`${toolName} target must be "edit" or "client-N" (got: ${selectedTarget})`);
     }
     if (selectedTarget !== "edit" && !/^client-\d+$/.test(selectedTarget)) {
@@ -8085,7 +10261,7 @@ var RobloxStudioTools = class {
   }
   _resolveSimulationTargets(target, instance_id, toolName) {
     const selectedTarget = target ?? "edit-and-clients";
-    if (selectedTarget === "server" || selectedTarget === "all" || selectedTarget === "edit-proxy") {
+    if (selectedTarget === "server" || selectedTarget === "all") {
       throw new Error(`${toolName} target must be "edit", "client-N", "all-clients", or "edit-and-clients" (got: ${selectedTarget})`);
     }
     const instanceId = this._resolveInstanceIdOnly(instance_id);
@@ -8456,14 +10632,17 @@ var RobloxStudioTools = class {
       ]
     };
   }
-  async grepScripts(pattern, options, instance_id) {
+  async grepScripts(pattern, options, instance_id, signal) {
     if (!pattern) {
       throw new Error("Pattern is required for grep_scripts");
     }
+    if (Buffer.byteLength(pattern, "utf8") > MAX_GREP_PATTERN_UTF8_BYTES) {
+      throw new Error(`Pattern must not exceed ${MAX_GREP_PATTERN_UTF8_BYTES} UTF-8 bytes`);
+    }
     const response = await this._callSingle("/api/grep-scripts", {
       pattern,
       ...options ?? {}
-    }, void 0, instance_id);
+    }, void 0, instance_id, GREP_SCRIPTS_TIMEOUT_MS, signal);
     return {
       content: [
         {
@@ -8886,6 +11065,7 @@ var RobloxStudioTools = class {
     const entrySummaries = summary.entries;
     const content = [];
     const failures = [];
+    let imageBudget = MAX_MATRIX_IMAGE_BYTES;
     try {
       for (let i = 0; i < matrixEntries.length; i++) {
         const entry = matrixEntries[i];
@@ -8903,8 +11083,10 @@ var RobloxStudioTools = class {
           entrySummary.applied = applied;
           if (settleMs > 0)
             await sleep(settleMs);
-          const capture = await this._captureViewportImage(resolved.instanceId, resolved.role, format, quality);
+          const entryBudget = Math.max(1, Math.floor(imageBudget / (matrixEntries.length - i)));
+          const capture = await this._captureViewportImage(resolved.instanceId, resolved.role, format, quality, entryBudget);
           if (capture.success) {
+            imageBudget -= Math.ceil(capture.data.length * 3 / 4);
             entrySummary.screenshot = {
               width: capture.width,
               height: capture.height,
@@ -9001,7 +11183,7 @@ var RobloxStudioTools = class {
         content: [{ type: "text", text: JSON.stringify(response) }]
       };
     }
-    const targets = resolved.targets.filter((t) => t.targetRole !== "edit-proxy");
+    const targets = resolved.targets;
     const originPeerReliable = targets.length > 0 ? await this._isMultiplayerTestRunning(targets[0].targetInstanceId) : false;
     const responses = await Promise.allSettled(targets.map(async (t) => {
       const r = await this.client.request("/api/get-runtime-logs", data, t.targetInstanceId, t.targetRole);
@@ -10646,7 +12828,7 @@ var RobloxStudioTools = class {
       const response = await this.client.request("/api/get-memory-breakdown", data, resolved.targetInstanceId, resolved.targetRole);
       return { content: [{ type: "text", text: JSON.stringify(response) }] };
     }
-    const targets = resolved.targets.filter((t) => t.targetRole !== "edit-proxy");
+    const targets = resolved.targets;
     const responses = await Promise.allSettled(targets.map(async (t) => ({
       peer: t.targetRole,
       result: await this.client.request("/api/get-memory-breakdown", data, t.targetInstanceId, t.targetRole)
@@ -10679,7 +12861,7 @@ var RobloxStudioTools = class {
       const response = await this.client.request("/api/get-scene-analysis", data, resolved.targetInstanceId, resolved.targetRole);
       return { content: [{ type: "text", text: JSON.stringify(response) }] };
     }
-    const targets = resolved.targets.filter((t) => t.targetRole !== "edit-proxy");
+    const targets = resolved.targets;
     const responses = await Promise.allSettled(targets.map(async (t) => ({
       peer: t.targetRole,
       result: await this.client.request("/api/get-scene-analysis", data, t.targetInstanceId, t.targetRole)
@@ -10803,7 +12985,7 @@ var RobloxStudioTools = class {
     }, tgt, instance_id);
     return { content: [{ type: "text", text: JSON.stringify(response) }] };
   }
-  async _captureViewportImage(instanceId, targetRole, format, quality) {
+  async _captureViewportImage(instanceId, targetRole, format, quality, maxBytes = MAX_INLINE_IMAGE_BYTES) {
     let response;
     if (targetRole.startsWith("client-")) {
       const begin = await this._callSingle("/api/capture-begin", {}, targetRole, instanceId);
@@ -10836,21 +13018,29 @@ var RobloxStudioTools = class {
     const { mimeType } = encoded;
     let usedQ = q;
     let note = "";
-    if (buffer.length > MAX_INLINE_IMAGE_BYTES) {
+    if (buffer.length > maxBytes) {
       if (fmt === "png") {
         const mb = (buffer.length / 1048576).toFixed(1);
         return {
           success: false,
-          error: `PNG screenshot is ${mb}MB, over the ~${(MAX_INLINE_IMAGE_BYTES / 1048576).toFixed(0)}MB inline image limit. Use the default jpeg format (optionally with a "quality" value) or make the Studio window smaller for a lossless capture.`
+          error: `PNG screenshot is ${mb}MB, over the ~${(maxBytes / 1048576).toFixed(1)}MB inline image limit. Use the default jpeg format (optionally with a "quality" value) or make the Studio window smaller for a lossless capture.`
         };
       }
-      while (buffer.length > MAX_INLINE_IMAGE_BYTES && usedQ > 25) {
+      while (buffer.length > maxBytes && usedQ > 25) {
         usedQ = Math.max(25, usedQ - 20);
         buffer = encodeImageFromRgbaResponse(response, "jpeg", usedQ).buffer;
       }
+      if (buffer.length > maxBytes) {
+        return {
+          success: false,
+          error: `JPEG screenshot is still ${(buffer.length / 1048576).toFixed(1)}MB at q${usedQ}, over the ${(maxBytes / 1048576).toFixed(1)}MB inline budget. Make the Studio window smaller or capture fewer images per call.`
+        };
+      }
       note = ` \u2014 auto-reduced to q${usedQ} to fit the inline size limit; enlarge the Studio window or capture a smaller region for finer detail`;
     }
-    const message = `Screenshot ${w}x${h}px (${fmt}${fmt === "jpeg" ? ` q${usedQ}` : ""})${note}. For simulate_mouse_input, x/y are pixel coordinates in this exact image with (0,0) at the top-left; it is not downscaled, so use coordinates as you read them off the image.`;
+    const nativeW = response.nativeWidth ?? w;
+    const nativeH = response.nativeHeight ?? h;
+    const message = nativeW !== w || nativeH !== h ? `Screenshot ${w}x${h}px (${fmt}${fmt === "jpeg" ? ` q${usedQ}` : ""})${note}, downscaled from the ${nativeW}x${nativeH} viewport to fit transport limits. For simulate_mouse_input, multiply x read off this image by ${(nativeW / w).toFixed(4)} and y by ${(nativeH / h).toFixed(4)} to get viewport pixel coordinates ((0,0) at the top-left).` : `Screenshot ${w}x${h}px (${fmt}${fmt === "jpeg" ? ` q${usedQ}` : ""})${note}. For simulate_mouse_input, x/y are pixel coordinates in this exact image with (0,0) at the top-left; it is not downscaled, so use coordinates as you read them off the image.`;
     return {
       success: true,
       width: w,
@@ -10878,7 +13068,8 @@ var RobloxStudioTools = class {
             height: capture.height,
             format: capture.format,
             mimeType: capture.mimeType,
-            ...capture.quality === void 0 ? {} : { quality: capture.quality }
+            ...capture.quality === void 0 ? {} : { quality: capture.quality },
+            message: capture.message
           })
         },
         {
@@ -10893,6 +13084,7 @@ var RobloxStudioTools = class {
 
 // ../core/dist/proxy-bridge-service.js
 import { randomUUID as randomUUID4 } from "crypto";
+var PROXY_RESPONSE_GRACE_MS = 5e3;
 var ProxyBridgeService = class _ProxyBridgeService extends BridgeService {
   primaryBaseUrl;
   authToken;
@@ -10968,9 +13160,20 @@ var ProxyBridgeService = class _ProxyBridgeService extends BridgeService {
       this.refreshTimer = void 0;
     }
   }
-  async sendRequest(endpoint, data, targetInstanceId, targetRole) {
+  async sendRequest(endpoint, data, targetInstanceId, targetRole, timeoutMs = this.proxyRequestTimeout, signal) {
+    if (signal?.aborted)
+      throw new Error("Request aborted");
     const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), this.proxyRequestTimeout);
+    const effectiveTimeoutMs = Math.max(1, timeoutMs);
+    let timedOut = false;
+    const abortFromCaller = () => controller.abort();
+    signal?.addEventListener("abort", abortFromCaller, { once: true });
+    if (signal?.aborted)
+      controller.abort();
+    const timeoutId = setTimeout(() => {
+      timedOut = true;
+      controller.abort();
+    }, effectiveTimeoutMs + PROXY_RESPONSE_GRACE_MS);
     try {
       const response = await fetch(`${this.primaryBaseUrl}/proxy`, {
         method: "POST",
@@ -10980,26 +13183,34 @@ var ProxyBridgeService = class _ProxyBridgeService extends BridgeService {
           data,
           targetInstanceId,
           targetRole,
-          proxyInstanceId: this.proxyInstanceId
+          proxyInstanceId: this.proxyInstanceId,
+          timeoutMs: effectiveTimeoutMs
         }),
         signal: controller.signal
       });
-      clearTimeout(timeoutId);
       if (!response.ok) {
         const body = await response.text();
         throw new Error(`Proxy request failed (${response.status}): ${body}`);
       }
       const result = await response.json();
-      if (result.error) {
+      if (!result || typeof result !== "object" || Array.isArray(result)) {
+        throw new Error("Proxy returned an invalid response");
+      }
+      if ("error" in result && typeof result.error === "string" && result.error.length > 0) {
         throw new Error(result.error);
       }
-      return result.response;
-    } catch (err2) {
-      clearTimeout(timeoutId);
-      if (err2.name === "AbortError") {
+      return "response" in result ? result.response : void 0;
+    } catch (error) {
+      const isAbortError = error instanceof Error ? error.name === "AbortError" : !!error && typeof error === "object" && "name" in error && error.name === "AbortError";
+      if (isAbortError) {
+        if (!timedOut && signal?.aborted)
+          throw new Error("Request aborted");
         throw new Error("Proxy request timeout");
       }
-      throw err2;
+      throw error;
+    } finally {
+      clearTimeout(timeoutId);
+      signal?.removeEventListener("abort", abortFromCaller);
     }
   }
   cleanupOldRequests() {
@@ -11050,6 +13261,8 @@ var RobloxStudioMCPServer = class {
       console.error(`HTTP server listening on ${host}:${boundPort} for Studio plugin (primary mode)`);
       console.error(`Streamable HTTP MCP endpoint: http://localhost:${boundPort}/mcp`);
     } catch (error) {
+      await primaryApp?.cleanup().catch(() => {
+      });
       if (process.env.ROBLOX_STUDIO_REQUIRE_PRIMARY === "1") {
         console.error(`Port ${basePort} is unavailable and ROBLOX_STUDIO_REQUIRE_PRIMARY=1; refusing proxy mode`);
         throw error;
@@ -11083,33 +13296,21 @@ var RobloxStudioMCPServer = class {
           if (promotionInterval)
             clearInterval(promotionInterval);
         } catch {
+          await candidateApp.cleanup().catch(() => {
+          });
         }
       }, promotionIntervalMs);
     }
-    const LEGACY_PORT = 3002;
-    let legacyHandle;
-    let legacyApp;
-    if (boundPort !== LEGACY_PORT && bridgeMode === "primary") {
-      legacyApp = createHttpServer(this.tools, this.bridge, this.allowedToolNames, this.config, security);
-      try {
-        const result = await listenWithRetry(legacyApp, host, LEGACY_PORT, 1);
-        legacyHandle = result.server;
-        console.error(`Legacy HTTP server also listening on ${host}:${LEGACY_PORT} for old plugins`);
-        legacyApp.setMCPServerActive(true);
-      } catch {
-        console.error(`Legacy port ${LEGACY_PORT} in use, skipping backward-compat listener`);
-      }
-    }
     const stdioHandle = serveStdio((context) => createToolServer({
       config: this.config,
       getTools: () => this.tools,
       allowedTools: this.allowedToolNames,
       era: context.era,
-      invoke: async (tools, name, args) => {
+      invoke: async (tools, name, args, invocation) => {
         const handler = TOOL_HANDLERS[name];
         if (!handler)
           throw new Error(`Unknown tool: ${name}`);
-        return handler(tools, args);
+        return handler(tools, args, invocation);
       }
     }), { onerror: (error) => console.error("[mcp:stdio]", error) });
     console.error(`${this.config.name} v${this.config.version} running on stdio`);
@@ -11121,8 +13322,6 @@ var RobloxStudioMCPServer = class {
     const activityInterval = setInterval(() => {
       if (primaryApp)
         primaryApp.trackMCPActivity();
-      if (legacyApp)
-        legacyApp.trackMCPActivity();
       if (bridgeMode === "primary" && primaryApp) {
         const pluginConnected = primaryApp.isPluginConnected();
         const mcpActive = primaryApp.isMCPServerActive();
@@ -11147,22 +13346,16 @@ var RobloxStudioMCPServer = class {
       if (promotionInterval)
         clearInterval(promotionInterval);
       primaryApp?.setMCPServerActive(false);
-      legacyApp?.setMCPServerActive(false);
       this.bridge.clearAllPendingRequests();
       if (this.bridge instanceof ProxyBridgeService) {
         this.bridge.stop();
       }
       await stdioHandle.close().catch(() => {
       });
-      await Promise.all([
-        primaryApp?.closeMcpHandler(),
-        legacyApp?.closeMcpHandler()
-      ]).catch(() => {
+      await primaryApp?.cleanup().catch(() => {
       });
       if (httpHandle)
         httpHandle.close();
-      if (legacyHandle)
-        legacyHandle.close();
       process.exit(0);
     };
     process.on("SIGTERM", shutdown);
@@ -11564,37 +13757,44 @@ var TOOL_DEFINITIONS = [
   {
     name: "grep_scripts",
     category: "read",
-    description: "Use to locate text or Lua pattern matches across script sources.",
+    description: "Use to search script sources.",
     inputSchema: {
       type: "object",
       properties: {
         pattern: {
           type: "string",
-          description: "Literal text, or a Lua pattern when usePattern is true."
+          maxLength: 4096,
+          description: "Literal or Lua pattern; max 4096 UTF-8 bytes."
         },
         caseSensitive: {
           type: "boolean",
-          description: "Literal match casing; patterns are always case-sensitive."
+          description: "Lua patterns are always case-sensitive."
         },
         usePattern: {
           type: "boolean",
-          description: "Use Lua patterns with top-level | alternation; not PCRE."
+          description: "Enable Lua pattern with top-level | (not PCRE)."
         },
         contextLines: {
-          type: "number",
-          description: "Lines before and after each match; defaults to 0."
+          type: "integer",
+          minimum: 0,
+          maximum: 100,
+          description: "Surrounding lines (0-100; default 0)."
         },
         maxResults: {
-          type: "number",
-          description: "Total match limit; defaults to 100."
+          type: "integer",
+          minimum: 1,
+          maximum: 1e4,
+          description: "Default 100."
         },
         maxResultsPerScript: {
-          type: "number",
-          description: "Match limit per script."
+          type: "integer",
+          minimum: 0,
+          maximum: 1e4,
+          description: "Per-script cap; 0 is unlimited."
         },
         filesOnly: {
           type: "boolean",
-          description: "Return only script paths; defaults to false."
+          description: "Paths only; default false."
         },
         path: {
           type: "string",
@@ -12909,12 +15109,15 @@ var TOOL_DEFINITIONS = [
 var getReadOnlyTools = () => TOOL_DEFINITIONS.filter((t) => t.category === "read");
 
 // ../core/dist/install-plugin-helpers.js
-import { existsSync as existsSync6, unlinkSync } from "fs";
+var import_saxes = __toESM(require_saxes(), 1);
+import { existsSync as existsSync6, lstatSync, mkdirSync as mkdirSync4, readFileSync as readFileSync6, renameSync, rmSync as rmSync2, statSync as statSync3, unlinkSync, writeFileSync as writeFileSync3 } from "fs";
 import { execSync } from "child_process";
-import { join as join5 } from "path";
+import { randomUUID as randomUUID5 } from "crypto";
+import { basename as basename3, join as join5 } from "path";
 import { homedir as homedir4 } from "os";
+import { isUtf8 } from "buffer";
 var DEFAULT_PLUGIN_PORT = 58741;
-var SERVER_URL_SETTING_KEY_PATTERN = /MCP_LAST_SUCCESSFUL_SERVER_URL_GLOBAL_V1|MCP_LAST_SUCCESSFUL_SERVER_URL_|MCP_SERVER_URL_/g;
+var SERVER_URL_SETTING_KEY_PATTERN = /MCP_LAST_SUCCESSFUL_SERVER_URL_GLOBAL_V1|MCP_LAST_SUCCESSFUL_SERVER_URL_/g;
 function configurePluginAssetForPort(source, rawPort = process.env.ROBLOX_STUDIO_PORT) {
   if (rawPort === void 0 || rawPort === "")
     return source;
@@ -12941,19 +15144,19 @@ function configurePluginAssetForPort(source, rawPort = process.env.ROBLOX_STUDIO
 function isWSL() {
   return getStudioPlatformCapabilities().isWsl;
 }
-function getWindowsUserPluginsDir() {
+function getWindowsUserLocalAppData() {
   try {
-    const localAppData = execSync('cmd.exe /c "echo %LOCALAPPDATA%"', {
+    const windowsPath = execSync('cmd.exe /c "echo %LOCALAPPDATA%"', {
       stdio: ["ignore", "pipe", "ignore"]
     }).toString().trim();
-    if (!localAppData || localAppData.includes("%"))
+    if (!windowsPath || windowsPath.includes("%"))
       return null;
-    const linuxPath = execSync(`wslpath -u '${localAppData.replace(/'/g, "'\\''")}'`, {
+    const linuxPath = execSync(`wslpath -u '${windowsPath.replace(/'/g, "'\\''")}'`, {
       stdio: ["ignore", "pipe", "ignore"]
     }).toString().trim();
     if (!linuxPath)
       return null;
-    return join5(linuxPath, "Roblox", "Plugins");
+    return { linuxPath, windowsPath };
   } catch {
     return null;
   }
@@ -12965,13 +15168,78 @@ function getPluginsFolder() {
     return join5(process.env.LOCALAPPDATA || join5(homedir4(), "AppData", "Local"), "Roblox", "Plugins");
   }
   if (isWSL()) {
-    const win = getWindowsUserPluginsDir();
-    if (win)
-      return win;
+    const localAppData = getWindowsUserLocalAppData();
+    if (localAppData)
+      return join5(localAppData.linuxPath, "Roblox", "Plugins");
     console.warn("[install-plugin] WSL detected but could not resolve Windows %LOCALAPPDATA%. Falling back to ~/Documents/Roblox/Plugins/ - you will likely need to copy the rbxmx to /mnt/c/Users/<you>/AppData/Local/Roblox/Plugins/ manually. Set MCP_PLUGINS_DIR to skip detection.");
   }
   return join5(homedir4(), "Documents", "Roblox", "Plugins");
 }
+var STALE_TEST_PLUGINS_DIRECTORY = "RsmcpIsolatedPlugins";
+function pluginDirectorySettingPattern() {
+  return /(<QDir\b[^>]*\bname="PluginsDir"[^>]*>)([\s\S]*?)(<\/QDir>)/gu;
+}
+function escapeXmlText(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function repairStaleStudioPluginDirectorySetting({ settingsPath, studioPluginsDirectory }) {
+  if (!existsSync6(settingsPath))
+    return false;
+  if (studioPluginsDirectory === "") {
+    throw new Error("studioPluginsDirectory must be a non-empty path.");
+  }
+  const contents = readFileSync6(settingsPath, "utf8");
+  const matches = [...contents.matchAll(pluginDirectorySettingPattern())];
+  if (matches.length !== 1) {
+    throw new Error(`Expected exactly one Studio.PluginsDir QDir in ${settingsPath}; found ${matches.length}.`);
+  }
+  if (matches[0][2] !== STALE_TEST_PLUGINS_DIRECTORY)
+    return false;
+  const studioPath = escapeXmlText(studioPluginsDirectory);
+  const updated = contents.replace(pluginDirectorySettingPattern(), (_match, open2, _value, close) => `${open2}${studioPath}${close}`);
+  const temporaryPath = `${settingsPath}.rsmcp-install-${process.pid}-${randomUUID5()}.tmp`;
+  try {
+    writeFileSync3(temporaryPath, updated, {
+      encoding: "utf8",
+      mode: statSync3(settingsPath).mode
+    });
+    renameSync(temporaryPath, settingsPath);
+  } finally {
+    rmSync2(temporaryPath, { force: true });
+  }
+  return true;
+}
+function repairDefaultStudioPluginDirectorySetting(pluginsFolder, log) {
+  if (process.env.MCP_PLUGINS_DIR)
+    return;
+  let settingsPath;
+  let defaultPluginsFolder;
+  let studioPluginsDirectory;
+  if (process.platform === "win32") {
+    const localAppData = process.env.LOCALAPPDATA || join5(homedir4(), "AppData", "Local");
+    defaultPluginsFolder = join5(localAppData, "Roblox", "Plugins");
+    settingsPath = join5(localAppData, "Roblox", "GlobalSettings_13.xml");
+    studioPluginsDirectory = defaultPluginsFolder.replaceAll("\\", "/");
+  } else if (isWSL()) {
+    const localAppData = getWindowsUserLocalAppData();
+    if (!localAppData)
+      return;
+    defaultPluginsFolder = join5(localAppData.linuxPath, "Roblox", "Plugins");
+    settingsPath = join5(localAppData.linuxPath, "Roblox", "GlobalSettings_13.xml");
+    studioPluginsDirectory = [
+      localAppData.windowsPath.replace(/[\\/]+$/u, ""),
+      "Roblox",
+      "Plugins"
+    ].join("/").replaceAll("\\", "/");
+  } else {
+    return;
+  }
+  if (pluginsFolder !== defaultPluginsFolder)
+    return;
+  if (repairStaleStudioPluginDirectorySetting({ settingsPath, studioPluginsDirectory })) {
+    log(`Restored Studio PluginsDir to ${studioPluginsDirectory}.`);
+  }
+}
 function handleVariantConflict({ pluginsFolder, otherAssetName, replace, log = console.log, warn = console.warn }) {
   const otherDest = join5(pluginsFolder, otherAssetName);
   if (!existsSync6(otherDest))
@@ -12991,12 +15259,190 @@ Only one MCP plugin variant should be present. If both variants are in the Studi
 Delete ${otherAssetName} manually or use the default CLI installer behavior to replace it.
 `);
 }
+var PLUGIN_INSTALL_LOCK_NAME = ".robloxstudio-mcp-plugin-install.lock";
+function errorCode(error) {
+  return error.code;
+}
+function acquirePluginInstallLock(pluginsFolder, warn) {
+  const lockPath = join5(pluginsFolder, PLUGIN_INSTALL_LOCK_NAME);
+  const ownerPath = join5(lockPath, "owner.json");
+  const owner = {
+    pid: process.pid,
+    token: randomUUID5(),
+    createdAt: Date.now()
+  };
+  try {
+    mkdirSync4(lockPath);
+  } catch (error) {
+    if (errorCode(error) !== "EEXIST")
+      throw error;
+    throw new Error(`Another Studio plugin installation is already in progress: ${lockPath}. If no installer is running, remove that lock directory and retry.`);
+  }
+  try {
+    writeFileSync3(ownerPath, `${JSON.stringify(owner)}
+`, {
+      encoding: "utf8",
+      flag: "wx"
+    });
+  } catch (error) {
+    try {
+      rmSync2(lockPath, { recursive: true, force: true });
+    } catch (cleanupError) {
+      warn(`[install-plugin] Could not clean failed install lock ${lockPath}: ${cleanupError}`);
+    }
+    throw error;
+  }
+  return () => {
+    try {
+      const currentOwner = JSON.parse(readFileSync6(ownerPath, "utf8"));
+      if (currentOwner.pid === owner.pid && currentOwner.token === owner.token) {
+        rmSync2(lockPath, { recursive: true, force: true });
+      }
+    } catch (error) {
+      if (errorCode(error) !== "ENOENT") {
+        warn(`[install-plugin] Could not release install lock ${lockPath}: ${error}`);
+      }
+    }
+  };
+}
+function assertAssetFileName(name, field) {
+  if (name === "" || basename3(name) !== name) {
+    throw new Error(`${field} must be a file name, received ${JSON.stringify(name)}`);
+  }
+}
+function embeddedPluginValue(source, name, assetName) {
+  const pattern = new RegExp(`\\blocal\\s+${name}\\s*=\\s*"([^"]+)"\\s*;?`, "g");
+  const matches = [...source.matchAll(pattern)];
+  if (matches.length !== 1) {
+    throw new Error(`${assetName} must contain exactly one embedded ${name}; found ${matches.length}.`);
+  }
+  return matches[0][1];
+}
+var PLUGIN_SOURCE_CLASSES = {
+  Script: true,
+  ModuleScript: true,
+  LocalScript: true
+};
+function parsePluginScriptSources(source, assetName) {
+  if (!isUtf8(source)) {
+    throw new Error(`${assetName} is not valid UTF-8 Roblox XML.`);
+  }
+  const text = source.toString("utf8");
+  const elementStack = [];
+  const scriptSources = [];
+  let rootName;
+  let currentSource;
+  const parser = new import_saxes.SaxesParser({ fragment: false, xmlns: false });
+  parser.on("doctype", () => {
+    throw new Error("DOCTYPE declarations are not allowed in plugin artifacts.");
+  });
+  parser.on("opentag", (tag) => {
+    if (elementStack.length === 0)
+      rootName = tag.name;
+    if (currentSource === void 0 && tag.name === "string" && tag.attributes.name === "Source") {
+      const nearestItem = [...elementStack].reverse().find((element) => element.name === "Item");
+      const sourceClass = nearestItem?.attributes.class;
+      if (sourceClass !== void 0 && PLUGIN_SOURCE_CLASSES[sourceClass] === true) {
+        currentSource = { depth: elementStack.length, text: "" };
+      }
+    }
+    elementStack.push({ name: tag.name, attributes: tag.attributes });
+  });
+  parser.on("text", (value) => {
+    if (currentSource !== void 0)
+      currentSource.text += value;
+  });
+  parser.on("cdata", (value) => {
+    if (currentSource !== void 0)
+      currentSource.text += value;
+  });
+  parser.on("closetag", (tag) => {
+    if (currentSource !== void 0 && tag.name === "string" && elementStack.length === currentSource.depth + 1) {
+      scriptSources.push(currentSource.text);
+      currentSource = void 0;
+    }
+    elementStack.pop();
+  });
+  try {
+    parser.write(text).close();
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new Error(`${assetName} is not well-formed Roblox XML: ${detail}`, {
+      cause: error
+    });
+  }
+  if (rootName !== "roblox" || scriptSources.length === 0) {
+    throw new Error(`${assetName} is not a Roblox XML model containing a Script source.`);
+  }
+  return scriptSources;
+}
+function assertPluginAssetIdentity(source, assetName, expectedVersion, expectedVariant) {
+  const pluginSource = parsePluginScriptSources(source, assetName).join("\n");
+  const actualVersion = embeddedPluginValue(pluginSource, "CURRENT_VERSION", assetName);
+  if (actualVersion !== expectedVersion) {
+    throw new Error(`${assetName} embeds version ${actualVersion}; expected ${expectedVersion}.`);
+  }
+  const actualVariant = embeddedPluginValue(pluginSource, "PLUGIN_VARIANT", assetName);
+  if (actualVariant !== expectedVariant) {
+    throw new Error(`${assetName} embeds variant ${actualVariant}; expected ${expectedVariant}.`);
+  }
+}
+function installedFileMatches(source, destination) {
+  if (!existsSync6(destination))
+    return false;
+  if (!lstatSync(destination).isFile())
+    return false;
+  const installed = readFileSync6(destination);
+  return installed.length === source.length && installed.equals(source);
+}
+function installPluginAsset({ pluginsFolder, assetName, otherAssetName, source, expectedVersion, expectedVariant, rawPort, replaceVariant = true, log = console.log, warn = console.warn }) {
+  assertAssetFileName(assetName, "assetName");
+  assertAssetFileName(otherAssetName, "otherAssetName");
+  if (assetName === otherAssetName) {
+    throw new Error("assetName and otherAssetName must identify different files.");
+  }
+  const configured = configurePluginAssetForPort(source, rawPort);
+  assertPluginAssetIdentity(configured, assetName, expectedVersion, expectedVariant);
+  mkdirSync4(pluginsFolder, { recursive: true });
+  const destination = join5(pluginsFolder, assetName);
+  const releaseLock = acquirePluginInstallLock(pluginsFolder, warn);
+  try {
+    let installed = false;
+    if (!installedFileMatches(configured, destination)) {
+      const staged = join5(pluginsFolder, `.${assetName}.${process.pid}.${randomUUID5()}.tmp`);
+      try {
+        writeFileSync3(staged, configured, { flag: "wx" });
+        renameSync(staged, destination);
+        installed = true;
+      } finally {
+        try {
+          unlinkSync(staged);
+        } catch (error) {
+          if (errorCode(error) !== "ENOENT") {
+            warn(`[install-plugin] Could not remove staging file ${staged}: ${error}`);
+          }
+        }
+      }
+    }
+    handleVariantConflict({
+      pluginsFolder,
+      otherAssetName,
+      replace: replaceVariant,
+      log,
+      warn
+    });
+    repairDefaultStudioPluginDirectorySetting(pluginsFolder, log);
+    return { destination, installed };
+  } finally {
+    releaseLock();
+  }
+}
 
 // src/index.ts
 import { createRequire } from "module";
 
 // src/install-plugin.ts
-import { createWriteStream, existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync6, unlinkSync as unlinkSync2, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync7, readFileSync as readFileSync7 } from "fs";
 import { dirname as dirname5, join as join6 } from "path";
 import { fileURLToPath } from "url";
 import { get } from "https";
@@ -13005,6 +15451,7 @@ var ASSET_NAME = "MCPInspectorPlugin.rbxmx";
 var OTHER_VARIANT = "MCPPlugin.rbxmx";
 var TIMEOUT_MS = 3e4;
 var MAX_REDIRECTS = 5;
+var MAX_ASSET_BYTES = 64 * 1024 * 1024;
 function httpsGet(url) {
   return new Promise((resolve5, reject) => {
     const req = get(url, { headers: { "User-Agent": "robloxstudio-mcp-inspector" } }, resolve5);
@@ -13014,36 +15461,33 @@ function httpsGet(url) {
     });
   });
 }
-async function download(url, dest, redirects = 0) {
+async function download(url, redirects = 0) {
   const res = await httpsGet(url);
   if (res.statusCode === 301 || res.statusCode === 302) {
     if (redirects >= MAX_REDIRECTS) throw new Error(`Too many redirects (max ${MAX_REDIRECTS})`);
     const location = res.headers.location;
     if (!location) throw new Error("Redirect with no location header");
-    return download(location, dest, redirects + 1);
+    for await (const _chunk of res) {
+    }
+    return download(location, redirects + 1);
   }
   if (res.statusCode !== 200) {
     throw new Error(`Download failed: HTTP ${res.statusCode}`);
   }
-  return new Promise((resolve5, reject) => {
-    const file = createWriteStream(dest);
-    const cleanup = (err2) => {
-      file.close(() => {
-        try {
-          unlinkSync2(dest);
-        } catch {
-        }
-        reject(err2);
-      });
-    };
-    res.pipe(file);
-    file.on("finish", () => {
-      file.close();
-      resolve5();
-    });
-    file.on("error", cleanup);
-    res.on("error", cleanup);
-  });
+  const chunks = [];
+  let totalBytes = 0;
+  for await (const chunk of res) {
+    const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    totalBytes += bytes.length;
+    if (totalBytes > MAX_ASSET_BYTES) {
+      res.destroy();
+      throw new Error(
+        `${ASSET_NAME} download exceeds the ${MAX_ASSET_BYTES}-byte limit.`
+      );
+    }
+    chunks.push(bytes);
+  }
+  return Buffer.concat(chunks, totalBytes);
 }
 async function fetchJson(url) {
   const res = await httpsGet(url);
@@ -13056,24 +15500,6 @@ async function fetchJson(url) {
   }
   return JSON.parse(Buffer.concat(chunks).toString());
 }
-function prepareInstall({
-  replaceVariant,
-  log,
-  warn
-}) {
-  const pluginsFolder = getPluginsFolder();
-  if (!existsSync7(pluginsFolder)) {
-    mkdirSync4(pluginsFolder, { recursive: true });
-  }
-  handleVariantConflict({
-    pluginsFolder,
-    otherAssetName: OTHER_VARIANT,
-    replace: replaceVariant,
-    log,
-    warn
-  });
-  return pluginsFolder;
-}
 function bundledAssetPath() {
   const currentDir = dirname5(fileURLToPath(import.meta.url));
   const candidates = [
@@ -13088,47 +15514,36 @@ function resolvePluginAssetPath(sourcePath) {
 }
 function packageVersion() {
   const currentDir = dirname5(fileURLToPath(import.meta.url));
-  const pkg = JSON.parse(readFileSync6(join6(currentDir, "..", "package.json"), "utf8"));
+  const pkg = JSON.parse(readFileSync7(join6(currentDir, "..", "package.json"), "utf8"));
   if (!pkg.version) {
     throw new Error("Package version not found");
   }
   return pkg.version;
 }
-function bundledPluginVersion(source) {
-  const match = readFileSync6(source, "utf8").match(/local CURRENT_VERSION = "([^"]+)"/);
-  return match ? match[1] : null;
-}
-function assertBundledPluginVersion(source) {
-  const expected = packageVersion();
-  const actual = bundledPluginVersion(source);
-  if (actual !== expected) {
-    throw new Error(
-      `Bundled ${ASSET_NAME} version ${actual ?? "unknown"} does not match package version ${expected}. Run npm run build:plugin:inspector before starting with --auto-install-plugin.`
-    );
-  }
-}
-function filesMatch(expected, actualPath) {
-  if (!existsSync7(actualPath)) return false;
-  const actual = readFileSync6(actualPath);
-  return expected.length === actual.length && expected.equals(actual);
-}
 async function installBundledPlugin(options = {}) {
   const log = options.log ?? console.log;
   const warn = options.warn ?? console.warn;
   const replaceVariant = options.replaceVariant ?? true;
-  const source = resolvePluginAssetPath(options.sourcePath);
-  if (!source) {
+  const sourcePath = resolvePluginAssetPath(options.sourcePath);
+  if (!sourcePath) {
     throw new Error(
       `Bundled ${ASSET_NAME} not found. Run npm run build:plugin:inspector in this worktree first.`
     );
   }
-  assertBundledPluginVersion(source);
-  const pluginsFolder = prepareInstall({ replaceVariant, log, warn });
-  const dest = join6(pluginsFolder, ASSET_NAME);
-  const configured = configurePluginAssetForPort(readFileSync6(source));
-  if (filesMatch(configured, dest)) return;
-  writeFileSync3(dest, configured);
-  log(`Installed ${ASSET_NAME} to ${dest}`);
+  const result = await installPluginAsset({
+    pluginsFolder: getPluginsFolder(),
+    assetName: ASSET_NAME,
+    otherAssetName: OTHER_VARIANT,
+    source: readFileSync7(sourcePath),
+    expectedVersion: packageVersion(),
+    expectedVariant: "inspector",
+    replaceVariant,
+    log,
+    warn
+  });
+  if (result.installed) {
+    log(`Installed ${ASSET_NAME} to ${result.destination}`);
+  }
 }
 async function installPlugin(options = {}) {
   const replaceVariant = options.replaceVariant ?? true;
@@ -13138,17 +15553,23 @@ async function installPlugin(options = {}) {
   if (options.sourcePath !== void 0 && !bundled) {
     throw new Error(`Plugin asset not found at explicit path ${options.sourcePath}.`);
   }
-  const pluginsFolder = prepareInstall({ replaceVariant, log, warn });
   if (bundled) {
-    assertBundledPluginVersion(bundled);
-    const dest2 = join6(pluginsFolder, ASSET_NAME);
-    const configured2 = configurePluginAssetForPort(readFileSync6(bundled));
-    if (filesMatch(configured2, dest2)) {
+    const result2 = await installPluginAsset({
+      pluginsFolder: getPluginsFolder(),
+      assetName: ASSET_NAME,
+      otherAssetName: OTHER_VARIANT,
+      source: readFileSync7(bundled),
+      expectedVersion: packageVersion(),
+      expectedVariant: "inspector",
+      replaceVariant,
+      log,
+      warn
+    });
+    if (result2.installed) {
+      log(`Installed bundled ${ASSET_NAME} to ${result2.destination}`);
+    } else {
       log(`${ASSET_NAME} already installed.`);
-      return;
     }
-    writeFileSync3(dest2, configured2);
-    log(`Installed bundled ${ASSET_NAME} to ${dest2}`);
     return;
   }
   log("Fetching latest release...");
@@ -13157,13 +15578,24 @@ async function installPlugin(options = {}) {
   if (!asset) {
     throw new Error(`${ASSET_NAME} not found in release ${release.tag_name}`);
   }
-  const dest = join6(pluginsFolder, ASSET_NAME);
   log(`Downloading ${ASSET_NAME} from ${release.tag_name}...`);
-  await download(asset.browser_download_url, dest);
-  const downloaded = readFileSync6(dest);
-  const configured = configurePluginAssetForPort(downloaded);
-  if (configured !== downloaded) writeFileSync3(dest, configured);
-  log(`Installed to ${dest}`);
+  const downloaded = await download(asset.browser_download_url);
+  const result = await installPluginAsset({
+    pluginsFolder: getPluginsFolder(),
+    assetName: ASSET_NAME,
+    otherAssetName: OTHER_VARIANT,
+    source: downloaded,
+    expectedVersion: release.tag_name.replace(/^v/, ""),
+    expectedVariant: "inspector",
+    replaceVariant,
+    log,
+    warn
+  });
+  if (result.installed) {
+    log(`Installed to ${result.destination}`);
+  } else {
+    log(`${ASSET_NAME} already installed.`);
+  }
 }
 
 // src/index.ts
@@ -13201,3 +15633,32 @@ if (installBundledOnly || installWithFallback) {
     process.exit(1);
   });
 }
+/*! Bundled license information:
+
+xmlchars/xml/1.0/ed5.js:
+  (**
+   * Character classes and associated utilities for the 5th edition of XML 1.0.
+   *
+   * @author Louis-Dominique Dubeau
+   * @license MIT
+   * @copyright Louis-Dominique Dubeau
+   *)
+
+xmlchars/xml/1.1/ed2.js:
+  (**
+   * Character classes and associated utilities for the 2nd edition of XML 1.1.
+   *
+   * @author Louis-Dominique Dubeau
+   * @license MIT
+   * @copyright Louis-Dominique Dubeau
+   *)
+
+xmlchars/xmlns/1.0/ed3.js:
+  (**
+   * Character class utilities for XML NS 1.0 edition 3.
+   *
+   * @author Louis-Dominique Dubeau
+   * @license MIT
+   * @copyright Louis-Dominique Dubeau
+   *)
+*/