@chrrxs/robloxstudio-mcp-inspector 2.12.0 → 2.14.0

package/dist/index.js

@@ -43,18 +43,25 @@ var init_bridge_service = __esm({
       requestTimeout = 3e4;
       registerInstance(input) {
         const { pluginSessionId, instanceId, role } = input;
+        const prior = this.instances.get(pluginSessionId);
         let assignedRole = role;
         if (role === "client") {
-          const used = /* @__PURE__ */ new Set();
-          for (const inst of this.instances.values()) {
-            const match = inst.role.match(/^client-(\d+)$/);
-            if (match)
-              used.add(Number(match[1]));
+          if (prior && prior.instanceId === instanceId && prior.role.match(/^client-\d+$/)) {
+            assignedRole = prior.role;
+          } else {
+            const used = /* @__PURE__ */ new Set();
+            for (const inst of this.instances.values()) {
+              if (inst.instanceId !== instanceId || inst.pluginSessionId === pluginSessionId)
+                continue;
+              const match = inst.role.match(/^client-(\d+)$/);
+              if (match)
+                used.add(Number(match[1]));
+            }
+            let idx = 1;
+            while (used.has(idx))
+              idx++;
+            assignedRole = `client-${idx}`;
           }
-          let idx = 1;
-          while (used.has(idx))
-            idx++;
-          assignedRole = `client-${idx}`;
         }
         const existing = Array.from(this.instances.values()).find((i) => i.instanceId === instanceId && i.role === assignedRole && i.pluginSessionId !== pluginSessionId);
         if (existing) {
@@ -76,7 +83,7 @@ var init_bridge_service = __esm({
           dataModelName: input.dataModelName ?? "",
           isRunning: input.isRunning ?? false,
           lastActivity: Date.now(),
-          connectedAt: Date.now()
+          connectedAt: prior?.connectedAt ?? Date.now()
         });
         return { ok: true, assignedRole, instanceId };
       }
@@ -214,7 +221,7 @@ var init_bridge_service = __esm({
         }
         if (distinctInstanceIds.size > 1) {
           const errorCode = role ? "ambiguous_target" : "multiple_instances_connected";
-          const msg = role ? `target=${role} is ambiguous: multiple places have this role. Pass instance_id.` : "Multiple Studio places are connected. Pass instance_id to disambiguate.";
+          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 } };
         }
         const onlyInstanceId = instances[0].instanceId;
@@ -236,6 +243,7 @@ var init_bridge_service = __esm({
             targetInstanceId,
             targetRole,
             timestamp: Date.now(),
+            inFlight: false,
             resolve: resolve2,
             reject,
             timeoutId
@@ -250,11 +258,14 @@ var init_bridge_service = __esm({
             continue;
           if (request.targetRole !== callerRole)
             continue;
+          if (request.inFlight)
+            continue;
           if (!oldestRequest || request.timestamp < oldestRequest.timestamp) {
             oldestRequest = request;
           }
         }
         if (oldestRequest) {
+          oldestRequest.inFlight = true;
           return {
             requestId: oldestRequest.id,
             request: {
@@ -677,6 +688,11 @@ var init_http_server = __esm({
       start_playtest: (tools, body) => tools.startPlaytest(body.mode, body.numPlayers, body.instance_id),
       stop_playtest: (tools, body) => tools.stopPlaytest(body.instance_id),
       get_playtest_output: (tools, body) => tools.getPlaytestOutput(body.target, body.instance_id),
+      multiplayer_test_start: (tools, body) => tools.multiplayerTestStart(body.numPlayers, body.testArgs, body.timeout, body.instance_id),
+      multiplayer_test_state: (tools, body) => tools.multiplayerTestState(body.instance_id),
+      multiplayer_test_add_players: (tools, body) => tools.multiplayerTestAddPlayers(body.numPlayers, body.timeout, body.instance_id),
+      multiplayer_test_leave_client: (tools, body) => tools.multiplayerTestLeaveClient(body.target, body.timeout, body.instance_id),
+      multiplayer_test_end: (tools, body) => tools.multiplayerTestEnd(body.value, body.timeout, body.instance_id),
       get_runtime_logs: (tools, body) => tools.getRuntimeLogs(body.target, body.since, body.tail, body.filter, body.instance_id),
       get_connected_instances: (tools) => tools.getConnectedInstances(),
       export_build: (tools, body) => tools.exportBuild(body.instancePath, body.outputId, body.style, body.instance_id),
@@ -700,9 +716,9 @@ var init_http_server = __esm({
       compare_instances: (tools, body) => tools.compareInstances(body.instancePathA, body.instancePathB, body.instance_id),
       get_output_log: (tools, body) => tools.getOutputLog(body.maxEntries, body.messageType, body.instance_id),
       bulk_set_attributes: (tools, body) => tools.bulkSetAttributes(body.instancePath, body.attributes, body.instance_id),
-      capture_screenshot: (tools, body) => tools.captureScreenshot(body.instance_id),
+      capture_screenshot: (tools, body) => tools.captureScreenshot(body.instance_id, body.format, body.quality),
       simulate_mouse_input: (tools, body) => tools.simulateMouseInput(body.action, body.x, body.y, body.button, body.scrollDirection, body.target, body.instance_id),
-      simulate_keyboard_input: (tools, body) => tools.simulateKeyboardInput(body.keyCode, body.action, body.duration, body.target, body.instance_id),
+      simulate_keyboard_input: (tools, body) => tools.simulateKeyboardInput(body.keyCode, body.action, body.duration, body.text, body.target, body.instance_id),
       character_navigation: (tools, body) => tools.characterNavigation(body.position, body.instancePath, body.waitForCompletion, body.timeout, body.target, body.instance_id),
       get_memory_breakdown: (tools, body) => tools.getMemoryBreakdown(body.target, body.tags, body.instance_id),
       export_rbxm: (tools, body) => tools.exportRbxm(body.instance_paths, body.output_path, body.target, body.instance_id),
@@ -1468,6 +1484,963 @@ var init_roblox_cookie_client = __esm({
   }
 });
 
+// ../core/dist/jpeg-encoder.js
+function rgbaToJpeg(rgba, width, height, quality = 80) {
+  if (width <= 0 || height <= 0)
+    throw new Error(`Invalid JPEG dimensions: ${width}x${height}`);
+  const expected = width * height * 4;
+  if (rgba.length < expected)
+    throw new Error(`Buffer too small: got ${rgba.length}, need ${expected}`);
+  const encoder = new JpegEncoder(quality);
+  return encoder.encode(rgba, width, height);
+}
+var ZIGZAG, STD_DC_LUMINANCE_NRCODES, STD_DC_LUMINANCE_VALUES, STD_AC_LUMINANCE_NRCODES, STD_AC_LUMINANCE_VALUES, STD_DC_CHROMINANCE_NRCODES, STD_DC_CHROMINANCE_VALUES, STD_AC_CHROMINANCE_NRCODES, STD_AC_CHROMINANCE_VALUES, JpegEncoder;
+var init_jpeg_encoder = __esm({
+  "../core/dist/jpeg-encoder.js"() {
+    "use strict";
+    ZIGZAG = [
+      0,
+      1,
+      5,
+      6,
+      14,
+      15,
+      27,
+      28,
+      2,
+      4,
+      7,
+      13,
+      16,
+      26,
+      29,
+      42,
+      3,
+      8,
+      12,
+      17,
+      25,
+      30,
+      41,
+      43,
+      9,
+      11,
+      18,
+      24,
+      31,
+      40,
+      44,
+      53,
+      10,
+      19,
+      23,
+      32,
+      39,
+      45,
+      52,
+      54,
+      20,
+      22,
+      33,
+      38,
+      46,
+      51,
+      55,
+      60,
+      21,
+      34,
+      37,
+      47,
+      50,
+      56,
+      59,
+      61,
+      35,
+      36,
+      48,
+      49,
+      57,
+      58,
+      62,
+      63
+    ];
+    STD_DC_LUMINANCE_NRCODES = [0, 0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0];
+    STD_DC_LUMINANCE_VALUES = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
+    STD_AC_LUMINANCE_NRCODES = [0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 125];
+    STD_AC_LUMINANCE_VALUES = [
+      1,
+      2,
+      3,
+      0,
+      4,
+      17,
+      5,
+      18,
+      33,
+      49,
+      65,
+      6,
+      19,
+      81,
+      97,
+      7,
+      34,
+      113,
+      20,
+      50,
+      129,
+      145,
+      161,
+      8,
+      35,
+      66,
+      177,
+      193,
+      21,
+      82,
+      209,
+      240,
+      36,
+      51,
+      98,
+      114,
+      130,
+      9,
+      10,
+      22,
+      23,
+      24,
+      25,
+      26,
+      37,
+      38,
+      39,
+      40,
+      41,
+      42,
+      52,
+      53,
+      54,
+      55,
+      56,
+      57,
+      58,
+      67,
+      68,
+      69,
+      70,
+      71,
+      72,
+      73,
+      74,
+      83,
+      84,
+      85,
+      86,
+      87,
+      88,
+      89,
+      90,
+      99,
+      100,
+      101,
+      102,
+      103,
+      104,
+      105,
+      106,
+      115,
+      116,
+      117,
+      118,
+      119,
+      120,
+      121,
+      122,
+      131,
+      132,
+      133,
+      134,
+      135,
+      136,
+      137,
+      138,
+      146,
+      147,
+      148,
+      149,
+      150,
+      151,
+      152,
+      153,
+      154,
+      162,
+      163,
+      164,
+      165,
+      166,
+      167,
+      168,
+      169,
+      170,
+      178,
+      179,
+      180,
+      181,
+      182,
+      183,
+      184,
+      185,
+      186,
+      194,
+      195,
+      196,
+      197,
+      198,
+      199,
+      200,
+      201,
+      202,
+      210,
+      211,
+      212,
+      213,
+      214,
+      215,
+      216,
+      217,
+      218,
+      225,
+      226,
+      227,
+      228,
+      229,
+      230,
+      231,
+      232,
+      233,
+      234,
+      241,
+      242,
+      243,
+      244,
+      245,
+      246,
+      247,
+      248,
+      249,
+      250
+    ];
+    STD_DC_CHROMINANCE_NRCODES = [0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0];
+    STD_DC_CHROMINANCE_VALUES = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
+    STD_AC_CHROMINANCE_NRCODES = [0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 119];
+    STD_AC_CHROMINANCE_VALUES = [
+      0,
+      1,
+      2,
+      3,
+      17,
+      4,
+      5,
+      33,
+      49,
+      6,
+      18,
+      65,
+      81,
+      7,
+      97,
+      113,
+      19,
+      34,
+      50,
+      129,
+      8,
+      20,
+      66,
+      145,
+      161,
+      177,
+      193,
+      9,
+      35,
+      51,
+      82,
+      240,
+      21,
+      98,
+      114,
+      209,
+      10,
+      22,
+      36,
+      52,
+      225,
+      37,
+      241,
+      23,
+      24,
+      25,
+      26,
+      38,
+      39,
+      40,
+      41,
+      42,
+      53,
+      54,
+      55,
+      56,
+      57,
+      58,
+      67,
+      68,
+      69,
+      70,
+      71,
+      72,
+      73,
+      74,
+      83,
+      84,
+      85,
+      86,
+      87,
+      88,
+      89,
+      90,
+      99,
+      100,
+      101,
+      102,
+      103,
+      104,
+      105,
+      106,
+      115,
+      116,
+      117,
+      118,
+      119,
+      120,
+      121,
+      122,
+      130,
+      131,
+      132,
+      133,
+      134,
+      135,
+      136,
+      137,
+      138,
+      146,
+      147,
+      148,
+      149,
+      150,
+      151,
+      152,
+      153,
+      154,
+      162,
+      163,
+      164,
+      165,
+      166,
+      167,
+      168,
+      169,
+      170,
+      178,
+      179,
+      180,
+      181,
+      182,
+      183,
+      184,
+      185,
+      186,
+      194,
+      195,
+      196,
+      197,
+      198,
+      199,
+      200,
+      201,
+      202,
+      210,
+      211,
+      212,
+      213,
+      214,
+      215,
+      216,
+      217,
+      218,
+      226,
+      227,
+      228,
+      229,
+      230,
+      231,
+      232,
+      233,
+      234,
+      242,
+      243,
+      244,
+      245,
+      246,
+      247,
+      248,
+      249,
+      250
+    ];
+    JpegEncoder = class {
+      YTable = new Int32Array(64);
+      UVTable = new Int32Array(64);
+      fdtbl_Y = new Float32Array(64);
+      fdtbl_UV = new Float32Array(64);
+      YDC_HT;
+      UVDC_HT;
+      YAC_HT;
+      UVAC_HT;
+      bitcode = new Array(65535);
+      category = new Int32Array(65535);
+      outputfDCTQuant = new Float32Array(64);
+      DU = new Int32Array(64);
+      // RGB->YUV lookup tables
+      RGB_YUV_TABLE = new Int32Array(2048);
+      byteout = [];
+      bytenew = 0;
+      bytepos = 7;
+      constructor(quality) {
+        this.initHuffmanTbl();
+        this.initCategoryNumber();
+        this.initRGBYUVTable();
+        this.setQuality(quality);
+      }
+      initQuantTables(sf) {
+        const YQT = [
+          16,
+          11,
+          10,
+          16,
+          24,
+          40,
+          51,
+          61,
+          12,
+          12,
+          14,
+          19,
+          26,
+          58,
+          60,
+          55,
+          14,
+          13,
+          16,
+          24,
+          40,
+          57,
+          69,
+          56,
+          14,
+          17,
+          22,
+          29,
+          51,
+          87,
+          80,
+          62,
+          18,
+          22,
+          37,
+          56,
+          68,
+          109,
+          103,
+          77,
+          24,
+          35,
+          55,
+          64,
+          81,
+          104,
+          113,
+          92,
+          49,
+          64,
+          78,
+          87,
+          103,
+          121,
+          120,
+          101,
+          72,
+          92,
+          95,
+          98,
+          112,
+          100,
+          103,
+          99
+        ];
+        for (let i = 0; i < 64; i++) {
+          let t = Math.floor((YQT[i] * sf + 50) / 100);
+          if (t < 1)
+            t = 1;
+          else if (t > 255)
+            t = 255;
+          this.YTable[ZIGZAG[i]] = t;
+        }
+        const UVQT = [
+          17,
+          18,
+          24,
+          47,
+          99,
+          99,
+          99,
+          99,
+          18,
+          21,
+          26,
+          66,
+          99,
+          99,
+          99,
+          99,
+          24,
+          26,
+          56,
+          99,
+          99,
+          99,
+          99,
+          99,
+          47,
+          66,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99,
+          99
+        ];
+        for (let j = 0; j < 64; j++) {
+          let u = Math.floor((UVQT[j] * sf + 50) / 100);
+          if (u < 1)
+            u = 1;
+          else if (u > 255)
+            u = 255;
+          this.UVTable[ZIGZAG[j]] = u;
+        }
+        const aasf = [
+          1,
+          1.387039845,
+          1.306562965,
+          1.175875602,
+          1,
+          0.785694958,
+          0.5411961,
+          0.275899379
+        ];
+        let k = 0;
+        for (let row = 0; row < 8; row++) {
+          for (let col = 0; col < 8; col++) {
+            this.fdtbl_Y[k] = 1 / (this.YTable[ZIGZAG[k]] * aasf[row] * aasf[col] * 8);
+            this.fdtbl_UV[k] = 1 / (this.UVTable[ZIGZAG[k]] * aasf[row] * aasf[col] * 8);
+            k++;
+          }
+        }
+      }
+      computeHuffmanTbl(nrcodes, std_table) {
+        let codevalue = 0;
+        let pos_in_table = 0;
+        const HT = [];
+        for (let k = 1; k <= 16; k++) {
+          for (let j = 1; j <= nrcodes[k]; j++) {
+            HT[std_table[pos_in_table]] = { code: codevalue, length: k };
+            pos_in_table++;
+            codevalue++;
+          }
+          codevalue *= 2;
+        }
+        return HT;
+      }
+      initHuffmanTbl() {
+        this.YDC_HT = this.computeHuffmanTbl(STD_DC_LUMINANCE_NRCODES, STD_DC_LUMINANCE_VALUES);
+        this.UVDC_HT = this.computeHuffmanTbl(STD_DC_CHROMINANCE_NRCODES, STD_DC_CHROMINANCE_VALUES);
+        this.YAC_HT = this.computeHuffmanTbl(STD_AC_LUMINANCE_NRCODES, STD_AC_LUMINANCE_VALUES);
+        this.UVAC_HT = this.computeHuffmanTbl(STD_AC_CHROMINANCE_NRCODES, STD_AC_CHROMINANCE_VALUES);
+      }
+      initCategoryNumber() {
+        let nrlower = 1;
+        let nrupper = 2;
+        for (let cat = 1; cat <= 15; cat++) {
+          for (let nr = nrlower; nr < nrupper; nr++) {
+            this.category[32767 + nr] = cat;
+            this.bitcode[32767 + nr] = { length: cat, code: nr };
+          }
+          for (let nrneg = -(nrupper - 1); nrneg <= -nrlower; nrneg++) {
+            this.category[32767 + nrneg] = cat;
+            this.bitcode[32767 + nrneg] = { length: cat, code: nrupper - 1 + nrneg };
+          }
+          nrlower <<= 1;
+          nrupper <<= 1;
+        }
+      }
+      initRGBYUVTable() {
+        for (let i = 0; i < 256; i++) {
+          this.RGB_YUV_TABLE[i] = 19595 * i;
+          this.RGB_YUV_TABLE[i + 256 >> 0] = 38470 * i;
+          this.RGB_YUV_TABLE[i + 512 >> 0] = 7471 * i + 32768;
+          this.RGB_YUV_TABLE[i + 768 >> 0] = -11059 * i;
+          this.RGB_YUV_TABLE[i + 1024 >> 0] = -21709 * i;
+          this.RGB_YUV_TABLE[i + 1280 >> 0] = 32768 * i + 8421375;
+          this.RGB_YUV_TABLE[i + 1536 >> 0] = -27439 * i;
+          this.RGB_YUV_TABLE[i + 1792 >> 0] = -5329 * i;
+        }
+      }
+      setQuality(quality) {
+        let q = quality;
+        if (q <= 0)
+          q = 1;
+        if (q > 100)
+          q = 100;
+        const sf = q < 50 ? Math.floor(5e3 / q) : Math.floor(200 - q * 2);
+        this.initQuantTables(sf);
+      }
+      writeBits(bs) {
+        const value = bs.code;
+        let posval = bs.length - 1;
+        while (posval >= 0) {
+          if (value & 1 << posval) {
+            this.bytenew |= 1 << this.bytepos;
+          }
+          posval--;
+          this.bytepos--;
+          if (this.bytepos < 0) {
+            if (this.bytenew === 255) {
+              this.writeByte(255);
+              this.writeByte(0);
+            } else {
+              this.writeByte(this.bytenew);
+            }
+            this.bytepos = 7;
+            this.bytenew = 0;
+          }
+        }
+      }
+      writeByte(value) {
+        this.byteout.push(value & 255);
+      }
+      writeWord(value) {
+        this.writeByte(value >> 8 & 255);
+        this.writeByte(value & 255);
+      }
+      fDCTQuant(data, fdtbl) {
+        let d0, d1, d2, d3, d4, d5, d6, d7;
+        let dataOff = 0;
+        const I8 = 8;
+        const I64 = 64;
+        for (let i = 0; i < I8; ++i) {
+          d0 = data[dataOff];
+          d1 = data[dataOff + 1];
+          d2 = data[dataOff + 2];
+          d3 = data[dataOff + 3];
+          d4 = data[dataOff + 4];
+          d5 = data[dataOff + 5];
+          d6 = data[dataOff + 6];
+          d7 = data[dataOff + 7];
+          const tmp0 = d0 + d7;
+          const tmp7 = d0 - d7;
+          const tmp1 = d1 + d6;
+          const tmp6 = d1 - d6;
+          const tmp2 = d2 + d5;
+          const tmp5 = d2 - d5;
+          const tmp3 = d3 + d4;
+          const tmp4 = d3 - d4;
+          let tmp10 = tmp0 + tmp3;
+          const tmp13 = tmp0 - tmp3;
+          let tmp11 = tmp1 + tmp2;
+          let tmp12 = tmp1 - tmp2;
+          data[dataOff] = tmp10 + tmp11;
+          data[dataOff + 4] = tmp10 - tmp11;
+          const z1 = (tmp12 + tmp13) * 0.707106781;
+          data[dataOff + 2] = tmp13 + z1;
+          data[dataOff + 6] = tmp13 - z1;
+          tmp10 = tmp4 + tmp5;
+          tmp11 = tmp5 + tmp6;
+          tmp12 = tmp6 + tmp7;
+          const z5 = (tmp10 - tmp12) * 0.382683433;
+          const z2 = 0.5411961 * tmp10 + z5;
+          const z4 = 1.306562965 * tmp12 + z5;
+          const z3 = tmp11 * 0.707106781;
+          const z11 = tmp7 + z3;
+          const z13 = tmp7 - z3;
+          data[dataOff + 5] = z13 + z2;
+          data[dataOff + 3] = z13 - z2;
+          data[dataOff + 1] = z11 + z4;
+          data[dataOff + 7] = z11 - z4;
+          dataOff += 8;
+        }
+        dataOff = 0;
+        for (let i = 0; i < I8; ++i) {
+          d0 = data[dataOff];
+          d1 = data[dataOff + 8];
+          d2 = data[dataOff + 16];
+          d3 = data[dataOff + 24];
+          d4 = data[dataOff + 32];
+          d5 = data[dataOff + 40];
+          d6 = data[dataOff + 48];
+          d7 = data[dataOff + 56];
+          const tmp0p2 = d0 + d7;
+          const tmp7p2 = d0 - d7;
+          const tmp1p2 = d1 + d6;
+          const tmp6p2 = d1 - d6;
+          const tmp2p2 = d2 + d5;
+          const tmp5p2 = d2 - d5;
+          const tmp3p2 = d3 + d4;
+          const tmp4p2 = d3 - d4;
+          let tmp10p2 = tmp0p2 + tmp3p2;
+          const tmp13p2 = tmp0p2 - tmp3p2;
+          let tmp11p2 = tmp1p2 + tmp2p2;
+          let tmp12p2 = tmp1p2 - tmp2p2;
+          data[dataOff] = tmp10p2 + tmp11p2;
+          data[dataOff + 32] = tmp10p2 - tmp11p2;
+          const z1p2 = (tmp12p2 + tmp13p2) * 0.707106781;
+          data[dataOff + 16] = tmp13p2 + z1p2;
+          data[dataOff + 48] = tmp13p2 - z1p2;
+          tmp10p2 = tmp4p2 + tmp5p2;
+          tmp11p2 = tmp5p2 + tmp6p2;
+          tmp12p2 = tmp6p2 + tmp7p2;
+          const z5p2 = (tmp10p2 - tmp12p2) * 0.382683433;
+          const z2p2 = 0.5411961 * tmp10p2 + z5p2;
+          const z4p2 = 1.306562965 * tmp12p2 + z5p2;
+          const z3p2 = tmp11p2 * 0.707106781;
+          const z11p2 = tmp7p2 + z3p2;
+          const z13p2 = tmp7p2 - z3p2;
+          data[dataOff + 40] = z13p2 + z2p2;
+          data[dataOff + 24] = z13p2 - z2p2;
+          data[dataOff + 8] = z11p2 + z4p2;
+          data[dataOff + 56] = z11p2 - z4p2;
+          dataOff++;
+        }
+        for (let i = 0; i < I64; ++i) {
+          const fDCTVal = data[i] * fdtbl[i];
+          this.outputfDCTQuant[i] = fDCTVal > 0 ? fDCTVal + 0.5 | 0 : fDCTVal - 0.5 | 0;
+        }
+        return this.outputfDCTQuant;
+      }
+      processDU(CDU, fdtbl, DC, HTDC, HTAC) {
+        const EOB = HTAC[0];
+        const M16zeroes = HTAC[240];
+        let pos;
+        const I16 = 16;
+        const I63 = 63;
+        const I64 = 64;
+        const DU_DCT = this.fDCTQuant(CDU, fdtbl);
+        for (let j = 0; j < I64; ++j) {
+          this.DU[ZIGZAG[j]] = DU_DCT[j];
+        }
+        const Diff = this.DU[0] - DC;
+        DC = this.DU[0];
+        if (Diff === 0) {
+          this.writeBits(HTDC[0]);
+        } else {
+          pos = 32767 + Diff;
+          this.writeBits(HTDC[this.category[pos]]);
+          this.writeBits(this.bitcode[pos]);
+        }
+        let end0pos = 63;
+        for (; end0pos > 0 && this.DU[end0pos] === 0; end0pos--) {
+        }
+        if (end0pos === 0) {
+          this.writeBits(EOB);
+          return DC;
+        }
+        let i = 1;
+        let lng;
+        while (i <= end0pos) {
+          const startpos = i;
+          for (; this.DU[i] === 0 && i <= end0pos; ++i) {
+          }
+          let nrzeroes = i - startpos;
+          if (nrzeroes >= I16) {
+            lng = nrzeroes >> 4;
+            for (let nrmarker = 1; nrmarker <= lng; ++nrmarker)
+              this.writeBits(M16zeroes);
+            nrzeroes = nrzeroes & 15;
+          }
+          pos = 32767 + this.DU[i];
+          this.writeBits(HTAC[(nrzeroes << 4) + this.category[pos]]);
+          this.writeBits(this.bitcode[pos]);
+          i++;
+        }
+        if (end0pos !== I63) {
+          this.writeBits(EOB);
+        }
+        return DC;
+      }
+      encode(rgba, width, height) {
+        this.byteout = [];
+        this.bytenew = 0;
+        this.bytepos = 7;
+        this.writeWord(65496);
+        this.writeWord(65504);
+        this.writeWord(16);
+        this.writeByte(74);
+        this.writeByte(70);
+        this.writeByte(73);
+        this.writeByte(70);
+        this.writeByte(0);
+        this.writeByte(1);
+        this.writeByte(1);
+        this.writeByte(0);
+        this.writeWord(1);
+        this.writeWord(1);
+        this.writeByte(0);
+        this.writeByte(0);
+        this.writeWord(65499);
+        this.writeWord(132);
+        this.writeByte(0);
+        for (let i = 0; i < 64; i++)
+          this.writeByte(this.YTable[i]);
+        this.writeByte(1);
+        for (let j = 0; j < 64; j++)
+          this.writeByte(this.UVTable[j]);
+        this.writeWord(65472);
+        this.writeWord(17);
+        this.writeByte(8);
+        this.writeWord(height);
+        this.writeWord(width);
+        this.writeByte(3);
+        this.writeByte(1);
+        this.writeByte(17);
+        this.writeByte(0);
+        this.writeByte(2);
+        this.writeByte(17);
+        this.writeByte(1);
+        this.writeByte(3);
+        this.writeByte(17);
+        this.writeByte(1);
+        this.writeWord(65476);
+        this.writeWord(418);
+        this.writeByte(0);
+        for (let i = 0; i < 16; i++)
+          this.writeByte(STD_DC_LUMINANCE_NRCODES[i + 1]);
+        for (let i = 0; i <= 11; i++)
+          this.writeByte(STD_DC_LUMINANCE_VALUES[i]);
+        this.writeByte(16);
+        for (let i = 0; i < 16; i++)
+          this.writeByte(STD_AC_LUMINANCE_NRCODES[i + 1]);
+        for (let i = 0; i <= 161; i++)
+          this.writeByte(STD_AC_LUMINANCE_VALUES[i]);
+        this.writeByte(1);
+        for (let i = 0; i < 16; i++)
+          this.writeByte(STD_DC_CHROMINANCE_NRCODES[i + 1]);
+        for (let i = 0; i <= 11; i++)
+          this.writeByte(STD_DC_CHROMINANCE_VALUES[i]);
+        this.writeByte(17);
+        for (let i = 0; i < 16; i++)
+          this.writeByte(STD_AC_CHROMINANCE_NRCODES[i + 1]);
+        for (let i = 0; i <= 161; i++)
+          this.writeByte(STD_AC_CHROMINANCE_VALUES[i]);
+        this.writeWord(65498);
+        this.writeWord(12);
+        this.writeByte(3);
+        this.writeByte(1);
+        this.writeByte(0);
+        this.writeByte(2);
+        this.writeByte(17);
+        this.writeByte(3);
+        this.writeByte(17);
+        this.writeByte(0);
+        this.writeByte(63);
+        this.writeByte(0);
+        let DCY = 0;
+        let DCU = 0;
+        let DCV = 0;
+        this.bytenew = 0;
+        this.bytepos = 7;
+        const YDU = new Float32Array(64);
+        const UDU = new Float32Array(64);
+        const VDU = new Float32Array(64);
+        const quadWidth = width * 4;
+        const fdtbl_Y = this.fdtbl_Y;
+        const fdtbl_UV = this.fdtbl_UV;
+        const RGB_YUV_TABLE = this.RGB_YUV_TABLE;
+        for (let y = 0; y < height; y += 8) {
+          for (let x = 0; x < width; x += 8) {
+            let start = quadWidth * y + x * 4;
+            for (let pos = 0; pos < 64; pos++) {
+              const row = pos >> 3;
+              const col = (pos & 7) * 4;
+              let p = start + row * quadWidth + col;
+              if (y + row >= height)
+                p -= quadWidth * (y + row - height + 1);
+              if (x + (col >> 2) >= width)
+                p -= 4 * (x + (col >> 2) - width + 1);
+              const r = rgba[p];
+              const g = rgba[p + 1];
+              const b = rgba[p + 2];
+              YDU[pos] = (RGB_YUV_TABLE[r] + RGB_YUV_TABLE[g + 256] + RGB_YUV_TABLE[b + 512] >> 16) - 128;
+              UDU[pos] = (RGB_YUV_TABLE[r + 768] + RGB_YUV_TABLE[g + 1024] + RGB_YUV_TABLE[b + 1280] >> 16) - 128;
+              VDU[pos] = (RGB_YUV_TABLE[r + 1280] + RGB_YUV_TABLE[g + 1536] + RGB_YUV_TABLE[b + 1792] >> 16) - 128;
+            }
+            DCY = this.processDU(YDU, fdtbl_Y, DCY, this.YDC_HT, this.YAC_HT);
+            DCU = this.processDU(UDU, fdtbl_UV, DCU, this.UVDC_HT, this.UVAC_HT);
+            DCV = this.processDU(VDU, fdtbl_UV, DCV, this.UVDC_HT, this.UVAC_HT);
+          }
+        }
+        if (this.bytepos >= 0) {
+          const fillbits = { length: this.bytepos + 1, code: (1 << this.bytepos + 1) - 1 };
+          this.writeBits(fillbits);
+        }
+        this.writeWord(65497);
+        return Buffer.from(this.byteout);
+      }
+    };
+  }
+});
+
 // ../core/dist/png-encoder.js
 import { deflateSync } from "zlib";
 function crc32(buf) {
@@ -1531,12 +2504,18 @@ var init_png_encoder = __esm({
 import * as fs from "fs";
 import * as os from "os";
 import * as path from "path";
-function encodePngFromRgbaResponse(response) {
+function encodeImageFromRgbaResponse(response, format, quality) {
   if (!response.data || response.width === void 0 || response.height === void 0) {
     throw new Error("Render response missing data, width, or height");
   }
   const rgbaBuffer = Buffer.from(response.data, "base64");
-  return rgbaToPng(rgbaBuffer, response.width, response.height);
+  if (format === "png") {
+    return { buffer: rgbaToPng(rgbaBuffer, response.width, response.height), mimeType: "image/png" };
+  }
+  return {
+    buffer: rgbaToJpeg(rgbaBuffer, response.width, response.height, quality),
+    mimeType: "image/jpeg"
+  };
 }
 function luaLongQuote(s) {
   let level = 0;
@@ -1751,6 +2730,9 @@ function parseBridgeResponse(response) {
   }
   return JSON.stringify(response);
 }
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
 var SERVER_LOCAL_NAME, CLIENT_LOCAL_NAME, EVAL_WRAPPER_LINE_OFFSET, RobloxStudioTools;
 var init_tools = __esm({
   "../core/dist/tools/index.js"() {
@@ -1760,6 +2742,7 @@ var init_tools = __esm({
     init_build_executor();
     init_opencloud_client();
     init_roblox_cookie_client();
+    init_jpeg_encoder();
     init_png_encoder();
     SERVER_LOCAL_NAME = "__MCP_ServerEvalLocal";
     CLIENT_LOCAL_NAME = "__MCP_ClientEvalBridge";
@@ -1796,6 +2779,111 @@ var init_tools = __esm({
         }
         return this.client.request(endpoint, data, r.targetInstanceId, r.targetRole);
       }
+      // 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
+      // running client (where the live viewport + input pipeline are) without the
+      // caller having to pass target. Throws RoutingFailure with the standard
+      // instance list if the place is ambiguous (multiple connected, no instance_id).
+      _resolveRuntime(instance_id) {
+        const r = this.bridge.resolveTarget({ instance_id, target: void 0 });
+        if (!r.ok)
+          throw new RoutingFailure(r.error);
+        const resolvedId = r.targetInstanceId;
+        const roles = this.bridge.getInstances().filter((i) => i.instanceId === resolvedId).map((i) => i.role);
+        const clientRoles = roles.filter((role) => role.startsWith("client")).sort();
+        return { instanceId: resolvedId, clientRole: clientRoles[0] };
+      }
+      _resolveInstanceIdOnly(instance_id) {
+        const instances = this.bridge.getInstances();
+        const publicList = this.bridge.getPublicInstances();
+        const errorData = { instances: publicList, count: publicList.length };
+        if (instance_id !== void 0) {
+          if (!instances.some((i) => i.instanceId === instance_id)) {
+            throw new RoutingFailure({
+              code: "unrecognized_instance_id",
+              message: `instance_id "${instance_id}" is not connected. Pass one from data.instances.`,
+              data: errorData
+            });
+          }
+          return instance_id;
+        }
+        const distinct = Array.from(new Set(instances.map((i) => i.instanceId)));
+        if (distinct.length === 0) {
+          throw new RoutingFailure({
+            code: "unrecognized_instance_id",
+            message: "No Studio plugin is connected.",
+            data: errorData
+          });
+        }
+        if (distinct.length > 1) {
+          throw new RoutingFailure({
+            code: "multiple_instances_connected",
+            message: "Multiple Studio places are connected. Pass instance_id to disambiguate.",
+            data: errorData
+          });
+        }
+        return distinct[0];
+      }
+      _resolveSingleTarget(target, instance_id) {
+        const resolved = this.bridge.resolveTarget({ instance_id, target });
+        if (!resolved.ok)
+          throw new RoutingFailure(resolved.error);
+        if (resolved.mode !== "single") {
+          throw new RoutingFailure({
+            code: "target_role_not_present_on_instance",
+            message: "Pick a specific target role for this tool.",
+            data: {
+              instances: this.bridge.getPublicInstances(),
+              count: this.bridge.getInstances().length
+            }
+          });
+        }
+        return { instanceId: resolved.targetInstanceId, role: resolved.targetRole };
+      }
+      _rolesForInstance(instanceId) {
+        return this.bridge.getInstances().filter((i) => i.instanceId === instanceId).map((i) => i.role);
+      }
+      _clientRolesForInstance(instanceId) {
+        return this._rolesForInstance(instanceId).filter((role) => /^client-\d+$/.test(role)).sort((a, b) => Number(a.slice("client-".length)) - Number(b.slice("client-".length)));
+      }
+      async _waitForRuntimeRoles(instanceId, opts, timeoutSec = 30) {
+        const deadline = Date.now() + timeoutSec * 1e3;
+        while (Date.now() < deadline) {
+          const roles = this._rolesForInstance(instanceId);
+          const hasServer = !opts.server || roles.includes("server");
+          const hasClients = opts.clientCount === void 0 || this._clientRolesForInstance(instanceId).length >= opts.clientCount;
+          const absent = opts.absentRole === void 0 || !roles.includes(opts.absentRole);
+          const runtimeAbsent = !opts.noRuntime || !roles.some((role) => role === "server" || /^client-\d+$/.test(role));
+          if (hasServer && hasClients && absent && runtimeAbsent) {
+            return { ok: true, roles, timedOut: false };
+          }
+          await sleep(250);
+        }
+        return { ok: false, roles: this._rolesForInstance(instanceId), timedOut: true };
+      }
+      async _waitForExactClientCount(instanceId, expectedClientCount, timeoutSec = 30, stableMs = 3e3) {
+        const deadline = Date.now() + timeoutSec * 1e3;
+        let exactSince;
+        while (Date.now() < deadline) {
+          const roles2 = this._rolesForInstance(instanceId);
+          const clientCount2 = this._clientRolesForInstance(instanceId).length;
+          if (clientCount2 > expectedClientCount) {
+            return { ok: false, roles: roles2, timedOut: false, extraClients: true, clientCount: clientCount2 };
+          }
+          if (roles2.includes("server") && clientCount2 === expectedClientCount) {
+            exactSince ??= Date.now();
+            if (Date.now() - exactSince >= stableMs) {
+              return { ok: true, roles: roles2, timedOut: false, extraClients: false, clientCount: clientCount2 };
+            }
+          } else {
+            exactSince = void 0;
+          }
+          await sleep(250);
+        }
+        const roles = this._rolesForInstance(instanceId);
+        const clientCount = this._clientRolesForInstance(instanceId).length;
+        return { ok: false, roles, timedOut: true, extraClients: clientCount > expectedClientCount, clientCount };
+      }
       async getFileTree(path2 = "", instance_id) {
         const response = await this._callSingle("/api/file-tree", { path: path2 }, void 0, instance_id);
         return {
@@ -2325,7 +3413,7 @@ ${code}`
         const wrapper = buildModuleScriptInvokeWrapper({
           service: "ServerScriptService",
           bridgeName: SERVER_LOCAL_NAME,
-          missingError: "ServerEvalBridge not installed. Bridges are auto-installed at start_playtest and removed at stop_playtest. Start a playtest before calling eval_server_runtime.",
+          missingError: "ServerEvalBridge not found. The bridge runs inside the play DM, so a playtest must be running. The bridge installs automatically (including for manually-started playtests); if a playtest is running and you still see this, reconnect the plugin in the edit window so the bridge reinstalls, then start the playtest again.",
           userCode: code
         });
         const response = await this._callSingle("/api/execute-luau", { code: wrapper }, "server", instance_id);
@@ -2349,7 +3437,7 @@ ${code}`
         const wrapper = buildModuleScriptInvokeWrapper({
           service: "ReplicatedStorage",
           bridgeName: CLIENT_LOCAL_NAME,
-          missingError: "ClientEvalBridge not installed. Bridges are auto-installed at start_playtest and removed at stop_playtest. Start a playtest before calling eval_client_runtime.",
+          missingError: "ClientEvalBridge not found. The bridge runs inside the play DM, so a playtest must be running. The bridge installs automatically (including for manually-started playtests); if a playtest is running and you still see this, reconnect the plugin in the edit window so the bridge reinstalls, then start the playtest again.",
           userCode: code
         });
         const response = await this._callSingle("/api/execute-luau", { code: wrapper }, clientTarget, instance_id);
@@ -2440,10 +3528,10 @@ ${code}`
         if (mode !== "play" && mode !== "run") {
           throw new Error('mode must be "play" or "run"');
         }
-        const data = { mode };
         if (numPlayers !== void 0) {
-          data.numPlayers = numPlayers;
+          throw new Error("start_playtest is single-player only. Use multiplayer_test_start for multi-client StudioTestService sessions.");
         }
+        const data = { mode };
         const response = await this._callSingle("/api/start-playtest", data, void 0, instance_id);
         return {
           content: [
@@ -2471,6 +3559,196 @@ ${code}`
           ]
         };
       }
+      async _buildMultiplayerState(instanceId) {
+        const peers = this.bridge.getPublicInstances().filter((i) => i.instanceId === instanceId).sort((a, b) => a.role.localeCompare(b.role));
+        const body = {
+          instanceId,
+          peers,
+          peerCount: peers.length
+        };
+        const edit = peers.find((p) => p.role === "edit");
+        const server = peers.find((p) => p.role === "server");
+        let editState;
+        let serverState;
+        if (edit) {
+          try {
+            editState = await this.client.request("/api/multiplayer-test-state", {}, instanceId, "edit");
+            body.edit = editState;
+          } catch (err) {
+            body.edit = { error: err instanceof Error ? err.message : String(err) };
+          }
+        }
+        if (server) {
+          try {
+            serverState = await this.client.request("/api/multiplayer-test-state", {}, instanceId, "server");
+            body.server = serverState;
+          } catch (err) {
+            body.server = { error: err instanceof Error ? err.message : String(err) };
+          }
+        }
+        const session = editState?.session;
+        const rawPhase = typeof session?.phase === "string" ? session.phase : void 0;
+        const hasRuntime = peers.some((p) => p.role === "server" || p.role.startsWith("client-"));
+        body.phase = rawPhase === "starting" && hasRuntime ? "running" : rawPhase ?? (hasRuntime ? "running" : "idle");
+        body.testId = session?.testId;
+        body.numPlayers = session?.numPlayers;
+        body.testArgs = session?.testArgs ?? serverState?.testArgs;
+        body.result = session?.result;
+        body.error = session?.error;
+        body.players = serverState?.players ?? [];
+        body.playerCount = serverState?.playerCount ?? 0;
+        body.clientRoles = this._clientRolesForInstance(instanceId);
+        return body;
+      }
+      async _waitForMultiplayerEditDone(instanceId, timeoutSec = 30) {
+        const deadline = Date.now() + timeoutSec * 1e3;
+        while (Date.now() < deadline) {
+          if (!this._rolesForInstance(instanceId).includes("edit"))
+            return false;
+          try {
+            const editState = await this.client.request("/api/multiplayer-test-state", {}, instanceId, "edit");
+            const phase = editState?.session?.phase;
+            if (phase === "completed" || phase === "failed")
+              return true;
+          } catch {
+          }
+          await sleep(250);
+        }
+        return false;
+      }
+      async _isMultiplayerTestRunning(instanceId) {
+        if (!this._rolesForInstance(instanceId).includes("edit"))
+          return false;
+        try {
+          const editState = await this.client.request("/api/multiplayer-test-state", {}, instanceId, "edit");
+          const phase = editState?.session?.phase;
+          return phase === "starting" || phase === "running";
+        } catch {
+          return false;
+        }
+      }
+      async _waitForMultiplayerStart(instanceId, clientCount, timeoutSec = 30) {
+        const deadline = Date.now() + timeoutSec * 1e3;
+        while (Date.now() < deadline) {
+          const exact = await this._waitForExactClientCount(instanceId, clientCount, 0.25, 0);
+          if (exact.ok || exact.extraClients) {
+            return { ok: exact.ok, roles: exact.roles, timedOut: false, error: exact.extraClients ? `Expected ${clientCount} client(s), but Studio registered ${exact.clientCount}.` : void 0 };
+          }
+          try {
+            const editState = await this.client.request("/api/multiplayer-test-state", {}, instanceId, "edit");
+            const session = editState?.session;
+            if (session?.phase === "failed" || session?.phase === "completed") {
+              return { ok: false, roles: this._rolesForInstance(instanceId), timedOut: false, phase: session.phase, error: session.error };
+            }
+          } catch {
+          }
+          await sleep(250);
+        }
+        return { ok: false, roles: this._rolesForInstance(instanceId), timedOut: true };
+      }
+      async multiplayerTestStart(numPlayers, testArgs, timeout, instance_id) {
+        if (!Number.isInteger(numPlayers) || numPlayers < 1 || numPlayers > 8) {
+          throw new Error("numPlayers must be an integer from 1 to 8");
+        }
+        const editTarget = this._resolveSingleTarget("edit", instance_id);
+        const response = await this.client.request("/api/multiplayer-test-start", { numPlayers, testArgs: testArgs ?? {} }, editTarget.instanceId, editTarget.role);
+        if (response?.error) {
+          return { content: [{ type: "text", text: JSON.stringify(response) }] };
+        }
+        const wait = await this._waitForMultiplayerStart(editTarget.instanceId, numPlayers, timeout ?? 30);
+        const state = await this._buildMultiplayerState(editTarget.instanceId);
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              ...response,
+              ready: wait.ok,
+              timedOut: wait.timedOut,
+              wait,
+              roles: wait.roles,
+              state
+            })
+          }]
+        };
+      }
+      async multiplayerTestState(instance_id) {
+        const instanceId = this._resolveInstanceIdOnly(instance_id);
+        const state = await this._buildMultiplayerState(instanceId);
+        return { content: [{ type: "text", text: JSON.stringify(state) }] };
+      }
+      async multiplayerTestAddPlayers(numPlayers, timeout, instance_id) {
+        if (!Number.isInteger(numPlayers) || numPlayers < 1 || numPlayers > 8) {
+          throw new Error("numPlayers must be an integer from 1 to 8");
+        }
+        const serverTarget = this._resolveSingleTarget("server", instance_id);
+        const before = this._clientRolesForInstance(serverTarget.instanceId).length;
+        const response = await this.client.request("/api/multiplayer-test-add-players", { numPlayers, timeout: timeout ?? 10 }, serverTarget.instanceId, serverTarget.role);
+        if (response?.error) {
+          return { content: [{ type: "text", text: JSON.stringify(response) }] };
+        }
+        const wait = await this._waitForExactClientCount(serverTarget.instanceId, before + numPlayers, timeout ?? 30);
+        const state = await this._buildMultiplayerState(serverTarget.instanceId);
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              ...response,
+              ready: wait.ok,
+              timedOut: wait.timedOut,
+              wait,
+              roles: wait.roles,
+              state
+            })
+          }]
+        };
+      }
+      async multiplayerTestLeaveClient(target = "client-1", timeout, instance_id) {
+        if (!/^client-\d+$/.test(target)) {
+          throw new Error(`multiplayer_test_leave_client requires target=client-N (got: ${target})`);
+        }
+        const clientTarget = this._resolveSingleTarget(target, instance_id);
+        const response = await this.client.request("/api/multiplayer-test-leave-client", {}, clientTarget.instanceId, clientTarget.role);
+        if (response?.error) {
+          return { content: [{ type: "text", text: JSON.stringify(response) }] };
+        }
+        const wait = await this._waitForRuntimeRoles(clientTarget.instanceId, { absentRole: clientTarget.role }, timeout ?? 30);
+        const state = await this._buildMultiplayerState(clientTarget.instanceId);
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              ...response,
+              left: wait.ok,
+              timedOut: wait.timedOut,
+              roles: wait.roles,
+              state
+            })
+          }]
+        };
+      }
+      async multiplayerTestEnd(value, timeout, instance_id) {
+        const serverTarget = this._resolveSingleTarget("server", instance_id);
+        const response = await this.client.request("/api/multiplayer-test-end", { value: value ?? "ended_by_mcp" }, serverTarget.instanceId, serverTarget.role);
+        if (response?.error) {
+          return { content: [{ type: "text", text: JSON.stringify(response) }] };
+        }
+        const editDone = await this._waitForMultiplayerEditDone(serverTarget.instanceId, timeout ?? 30);
+        const wait = await this._waitForRuntimeRoles(serverTarget.instanceId, { noRuntime: true }, timeout ?? 30);
+        const state = await this._buildMultiplayerState(serverTarget.instanceId);
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              ...response,
+              ended: wait.ok,
+              editDone,
+              timedOut: wait.timedOut,
+              roles: wait.roles,
+              state
+            })
+          }]
+        };
+      }
       async getConnectedInstances() {
         const instances = this.bridge.getPublicInstances();
         return {
@@ -2506,15 +3784,15 @@ ${code}`
       }
       static findProjectRoot(startDir) {
         let dir = path.resolve(startDir);
-        while (true) {
+        let previous = "";
+        while (dir !== previous) {
           if (fs.existsSync(path.join(dir, ".git")) || fs.existsSync(path.join(dir, "package.json"))) {
             return dir;
           }
-          const parent = path.dirname(dir);
-          if (parent === dir)
-            return null;
-          dir = parent;
+          previous = dir;
+          dir = path.dirname(dir);
         }
+        return null;
       }
       static isDirectory(candidate) {
         if (!candidate)
@@ -3195,13 +4473,13 @@ ${code}`
         if (!action) {
           throw new Error("action is required for simulate_mouse_input");
         }
+        const { instanceId, clientRole } = this._resolveRuntime(instance_id);
         const response = await this._callSingle("/api/simulate-mouse-input", {
           action,
           x,
           y,
-          button,
-          scrollDirection
-        }, target || "edit", instance_id);
+          button
+        }, target || clientRole || "edit", instanceId);
         return {
           content: [{
             type: "text",
@@ -3209,15 +4487,17 @@ ${code}`
           }]
         };
       }
-      async simulateKeyboardInput(keyCode, action, duration, target, instance_id) {
-        if (!keyCode) {
-          throw new Error("keyCode is required for simulate_keyboard_input");
+      async simulateKeyboardInput(keyCode, action, duration, text, target, instance_id) {
+        if (!keyCode && text === void 0) {
+          throw new Error("keyCode or text is required for simulate_keyboard_input");
         }
+        const { instanceId, clientRole } = this._resolveRuntime(instance_id);
         const response = await this._callSingle("/api/simulate-keyboard-input", {
           keyCode,
           action,
-          duration
-        }, target || "edit", instance_id);
+          duration,
+          text
+        }, target || clientRole || "edit", instanceId);
         return {
           content: [{
             type: "text",
@@ -3429,23 +4709,74 @@ ${code}`
         }, tgt, instance_id);
         return { content: [{ type: "text", text: JSON.stringify(response) }] };
       }
-      async captureScreenshot(instance_id) {
-        const response = await this._callSingle("/api/capture-screenshot", {}, void 0, instance_id);
+      async captureScreenshot(instance_id, format, quality) {
+        const { instanceId, clientRole } = this._resolveRuntime(instance_id);
+        let response;
+        if (clientRole) {
+          const begin = await this._callSingle("/api/capture-begin", {}, clientRole, instanceId);
+          if (begin.error) {
+            return { content: [{ type: "text", text: begin.error }] };
+          }
+          if (!begin.contentId) {
+            return { content: [{ type: "text", text: "Screenshot capture failed: no content id returned from client." }] };
+          }
+          response = await this._callSingle("/api/capture-read", { contentId: begin.contentId }, "edit", instanceId);
+        } else {
+          response = await this._callSingle("/api/capture-screenshot", {}, "edit", instanceId);
+        }
         if (response.error) {
+          let text = response.error;
+          if (clientRole && response.error.includes("Failed to load texture, unexpected format") && await this._isMultiplayerTestRunning(instanceId)) {
+            text = `Screenshot capture reached the multiplayer client, but Roblox returned a temporary screenshot texture that the edit peer cannot read in StudioTestService multiplayer sessions. Regular start_playtest capture works because the temporary rbxtemp:// handle is readable from the edit process; multiplayer client handles appear to be scoped to the client process. Raw error: ${response.error}`;
+          }
           return {
             content: [{
               type: "text",
-              text: response.error
+              text
             }]
           };
         }
-        const pngBuffer = encodePngFromRgbaResponse(response);
+        const w = response.width;
+        const h = response.height;
+        if (w === void 0 || h === void 0) {
+          return { content: [{ type: "text", text: "Screenshot response missing dimensions." }] };
+        }
+        const fmt = format === "png" ? "png" : "jpeg";
+        const q = quality === void 0 ? 92 : Math.max(1, Math.min(100, Math.floor(quality)));
+        const MAX_IMAGE_BYTES = 6e6;
+        const encoded = encodeImageFromRgbaResponse(response, fmt, q);
+        let { buffer } = encoded;
+        const { mimeType } = encoded;
+        let usedQ = q;
+        let note = "";
+        if (buffer.length > MAX_IMAGE_BYTES) {
+          if (fmt === "png") {
+            const mb = (buffer.length / 1048576).toFixed(1);
+            return {
+              content: [{
+                type: "text",
+                text: `PNG screenshot is ${mb}MB, over the ~${(MAX_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.`
+              }]
+            };
+          }
+          while (buffer.length > MAX_IMAGE_BYTES && usedQ > 25) {
+            usedQ = Math.max(25, usedQ - 20);
+            buffer = encodeImageFromRgbaResponse(response, "jpeg", usedQ).buffer;
+          }
+          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`;
+        }
         return {
-          content: [{
-            type: "image",
-            data: pngBuffer.toString("base64"),
-            mimeType: "image/png"
-          }]
+          content: [
+            {
+              type: "text",
+              text: `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.`
+            },
+            {
+              type: "image",
+              data: buffer.toString("base64"),
+              mimeType
+            }
+          ]
         };
       }
     };
@@ -4582,7 +5913,7 @@ var init_definitions = __esm({
       {
         name: "execute_luau",
         category: "write",
-        description: "Execute Luau code in plugin context. Use print()/warn() for output. Return value is captured.",
+        description: 'Execute Luau code in plugin context. target="server" and target="client-N" run against live runtime DataModels with PluginSecurity permissions; use eval_*_runtime instead when you need the game Script/LocalScript VM require cache. Use print()/warn() for output. Return value is captured.',
         inputSchema: {
           type: "object",
           properties: {
@@ -4605,7 +5936,7 @@ var init_definitions = __esm({
       {
         name: "eval_server_runtime",
         category: "write",
-        description: "Execute Luau on the server peer in the running game's Script VM (shares require cache with user game scripts). Use this instead of execute_luau target=server when you need to see runtime-mutated module state. Auto-installed at start_playtest, removed at stop_playtest.",
+        description: "Execute Luau on the server peer in the running game's Script VM (shares require cache with user game scripts, unlike execute_luau target=server which runs in plugin context). Requires a running playtest; the bridge is installed automatically (including for playtests started manually via the Studio Play button).",
         inputSchema: {
           type: "object",
           properties: {
@@ -4624,7 +5955,7 @@ var init_definitions = __esm({
       {
         name: "eval_client_runtime",
         category: "write",
-        description: "Execute Luau on a client peer in the running game's LocalScript VM (shares require cache with user game scripts). Use this instead of execute_luau target=client-N when you need to see runtime-mutated module state. Auto-installed at start_playtest, removed at stop_playtest.",
+        description: "Execute Luau on a client peer in the running game's LocalScript VM (shares require cache with user game scripts, unlike execute_luau target=client-N which runs in plugin context). Requires a running playtest; the bridge is installed automatically (including for playtests started manually via the Studio Play button).",
         inputSchema: {
           type: "object",
           properties: {
@@ -4701,7 +6032,7 @@ var init_definitions = __esm({
       {
         name: "start_playtest",
         category: "write",
-        description: "Start playtest. Captures print/warn/error via LogService. Poll with get_playtest_output, end with stop_playtest. Use numPlayers for multi-client testing (server + N clients).",
+        description: "Start a simple single-player Studio playtest in play or run mode. Captures print/warn/error via LogService. Poll with get_playtest_output, end with stop_playtest. For multi-client testing use multiplayer_test_start instead.",
         inputSchema: {
           type: "object",
           properties: {
@@ -4712,7 +6043,7 @@ var init_definitions = __esm({
             },
             numPlayers: {
               type: "number",
-              description: "Number of client players (1-8). Triggers server + clients mode via TestService."
+              description: "Deprecated and rejected. Use multiplayer_test_start for multi-client testing."
             },
             instance_id: {
               type: "string",
@@ -4754,6 +6085,112 @@ var init_definitions = __esm({
           }
         }
       },
+      {
+        name: "multiplayer_test_start",
+        category: "write",
+        description: "Start a StudioTestService multiplayer test and wait for the server plus requested client peers to connect. Use this for multi-client runtime testing.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            numPlayers: {
+              type: "number",
+              description: "Number of client players to start (1-8)."
+            },
+            testArgs: {
+              description: "JSON-compatible table passed to StudioTestService:GetTestArgs() on server and clients."
+            },
+            timeout: {
+              type: "number",
+              description: "Max seconds to wait for server + clients to register (default 30)."
+            },
+            instance_id: {
+              type: "string",
+              description: "Which connected Studio place to target. Required when multiple places are connected; omit when one. Use get_connected_instances to list available IDs."
+            }
+          },
+          required: ["numPlayers"]
+        }
+      },
+      {
+        name: "multiplayer_test_state",
+        category: "read",
+        description: "Get the active multiplayer StudioTestService state for a place: phase, peers, players, original testArgs, result/error, and connected client roles.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            instance_id: {
+              type: "string",
+              description: "Which connected Studio place to inspect. Required when multiple places are connected; omit when one. Use get_connected_instances to list available IDs."
+            }
+          }
+        }
+      },
+      {
+        name: "multiplayer_test_add_players",
+        category: "write",
+        description: "Add client players to a running StudioTestService multiplayer test and wait for the new clients to connect.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            numPlayers: {
+              type: "number",
+              description: "Number of additional client players to add (1-8)."
+            },
+            timeout: {
+              type: "number",
+              description: "Max seconds to wait for new clients to register (default 30)."
+            },
+            instance_id: {
+              type: "string",
+              description: "Which connected Studio place to target. Required when multiple places are connected; omit when one. Use get_connected_instances to list available IDs."
+            }
+          },
+          required: ["numPlayers"]
+        }
+      },
+      {
+        name: "multiplayer_test_leave_client",
+        category: "write",
+        description: "Disconnect a specific client from a running StudioTestService multiplayer test, then wait for that client peer to leave.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            target: {
+              type: "string",
+              description: 'Client target to leave: "client-1" (default), "client-2", etc.'
+            },
+            timeout: {
+              type: "number",
+              description: "Max seconds to wait for the client peer to disconnect (default 30)."
+            },
+            instance_id: {
+              type: "string",
+              description: "Which connected Studio place to target. Required when multiple places are connected; omit when one. Use get_connected_instances to list available IDs."
+            }
+          }
+        }
+      },
+      {
+        name: "multiplayer_test_end",
+        category: "write",
+        description: "End a running StudioTestService multiplayer test with an optional return value, then wait for all runtime peers to disconnect.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            value: {
+              description: "JSON-compatible value returned to the edit-side ExecuteMultiplayerTestAsync call."
+            },
+            timeout: {
+              type: "number",
+              description: "Max seconds to wait for runtime peers to disconnect (default 30)."
+            },
+            instance_id: {
+              type: "string",
+              description: "Which connected Studio place to target. Required when multiple places are connected; omit when one. Use get_connected_instances to list available IDs."
+            }
+          }
+        }
+      },
       {
         name: "get_runtime_logs",
         category: "read",
@@ -5298,10 +6735,19 @@ part(0,2,0,2,1,1,"b")`,
       {
         name: "capture_screenshot",
         category: "read",
-        description: 'Capture a screenshot of the Roblox Studio viewport and return it as a PNG image. Requires EditableImage API to be enabled: Game Settings > Security > "Allow Mesh / Image APIs". Only works in Edit mode with the viewport visible.',
+        description: 'Capture the Roblox Studio viewport at native resolution and return it as an image, plus a text line stating the exact pixel dimensions. Works in Edit mode and regular playtests (auto-detects a running client and captures the live play viewport). StudioTestService multiplayer client screenshots are currently blocked by Roblox temporary-texture process scoping; the tool returns a clear error in that case. The returned image is never downscaled, so its pixel grid is exactly the coordinate space simulate_mouse_input uses \u2014 read click positions straight off this image. For reading fine text/UI, use format="png" (lossless) or a higher quality; enlarging the Studio window raises resolution. Requires EditableImage API enabled (Game Settings > Security > "Allow Mesh / Image APIs") and the window to be visible.',
         inputSchema: {
           type: "object",
           properties: {
+            format: {
+              type: "string",
+              enum: ["jpeg", "png"],
+              description: 'Image format. "jpeg" (default) is compact and crisp at high quality. "png" is lossless \u2014 best for reading dense text/UI, but larger (a busy 3D scene may be big).'
+            },
+            quality: {
+              type: "number",
+              description: "JPEG quality 1-100 (default 92). Higher = sharper text, larger size. Ignored for png."
+            },
             instance_id: {
               type: "string",
               description: "Which connected Studio place to target. Required when multiple places are connected; omit when one. Use get_connected_instances to list available IDs."
@@ -5313,36 +6759,31 @@ part(0,2,0,2,1,1,"b")`,
       {
         name: "simulate_mouse_input",
         category: "write",
-        description: "Simulate mouse input in the Roblox Studio viewport via VirtualInputManager. Use during playtest to click UI buttons, interact with objects, or navigate menus. Coordinates are viewport pixels (top-left is 0,0). Use capture_screenshot to identify UI element positions before clicking.",
+        description: "Simulate a mouse click in the running game via UserInputService:CreateVirtualInput. Use during a playtest to click UI buttons, interact with objects, or aim. Fires real UserInputService input and activates GUI buttons. Coordinates are viewport pixels matching capture_screenshot (top-left is 0,0) \u2014 take a screenshot first to find positions. Auto-targets the running client; only works during a playtest. Note: only click/mouseDown/mouseUp are supported (the API has no mouse-move or scroll).",
         inputSchema: {
           type: "object",
           properties: {
             action: {
               type: "string",
-              enum: ["click", "mouseDown", "mouseUp", "move", "scroll"],
-              description: 'Mouse action to perform. "click" does mouseDown + short delay + mouseUp.'
+              enum: ["click", "mouseDown", "mouseUp"],
+              description: 'Mouse action. "click" does mouseDown + short delay + mouseUp.'
             },
             x: {
               type: "number",
-              description: "Viewport pixel X coordinate"
+              description: "Viewport pixel X coordinate (as seen in capture_screenshot)"
             },
             y: {
               type: "number",
-              description: "Viewport pixel Y coordinate"
+              description: "Viewport pixel Y coordinate (as seen in capture_screenshot)"
             },
             button: {
               type: "string",
               enum: ["Left", "Right", "Middle"],
               description: "Mouse button (default: Left)"
             },
-            scrollDirection: {
-              type: "string",
-              enum: ["up", "down"],
-              description: 'Scroll direction (only for "scroll" action)'
-            },
             target: {
               type: "string",
-              description: 'Instance target: "edit" (default), "server", "client-1", "client-2", etc.'
+              description: 'Instance target. Defaults to the running playtest client (client-1) when present, else "edit". Override with "server", "client-2", etc.'
             },
             instance_id: {
               type: "string",
@@ -5355,13 +6796,13 @@ part(0,2,0,2,1,1,"b")`,
       {
         name: "simulate_keyboard_input",
         category: "write",
-        description: 'Simulate keyboard input via VirtualInputManager. Use during playtest for character movement (W/A/S/D), jumping (Space), interactions (E), or any key-driven action. For sustained movement, use "press" to hold and "release" to let go.',
+        description: 'Simulate keyboard input in the running game via UserInputService:CreateVirtualInput. Use during a playtest for character movement (W/A/S/D walks at full WalkSpeed with player controls intact), jumping (Space), interactions (E), or any key-driven action. Drives the real input pipeline so game scripts and control modules respond. For sustained movement use action="press" to hold and "release" to let go. Pass "text" instead of keyCode to type a string into the focused TextBox. Auto-targets the running client; only works during a playtest.',
         inputSchema: {
           type: "object",
           properties: {
             keyCode: {
               type: "string",
-              description: 'Enum.KeyCode name: "W", "A", "S", "D", "Space", "E", "F", "LeftShift", "LeftControl", "Return", "Tab", "Escape", "One", "Two", etc.'
+              description: 'Enum.KeyCode name: "W", "A", "S", "D", "Space", "E", "F", "LeftShift", "LeftControl", "Return", "Tab", "Escape", "One", "Two", etc. Omit if using "text".'
             },
             action: {
               type: "string",
@@ -5372,16 +6813,19 @@ part(0,2,0,2,1,1,"b")`,
               type: "number",
               description: 'Hold duration in seconds for "tap" action (default: 0.1). Use longer values for sustained input like walking.'
             },
+            text: {
+              type: "string",
+              description: "Type this string into the currently focused TextBox (uses SendTextInput). When provided, keyCode/action are ignored."
+            },
             target: {
               type: "string",
-              description: 'Instance target: "edit" (default), "server", "client-1", "client-2", etc.'
+              description: 'Instance target. Defaults to the running playtest client (client-1) when present, else "edit". Override with "server", "client-2", etc.'
             },
             instance_id: {
               type: "string",
               description: "Which connected Studio place to target. Required when multiple places are connected; omit when one. Use get_connected_instances to list available IDs."
             }
-          },
-          required: ["keyCode"]
+          }
         }
       },
       // === Character Navigation ===
@@ -5749,7 +7193,7 @@ function handleVariantConflict({ pluginsFolder, otherAssetName, replace }) {
   }
   console.warn(`
 [install-plugin] WARNING: ${otherAssetName} is already present in ${pluginsFolder}.
-Both plugins will register with MCP at Studio launch, causing duplicate role registrations and unpredictable routing for stop_playtest and per-peer execute_luau.
+Only one MCP plugin variant should be present. If both variants are in the Studio Plugins folder, Studio loads both and runtime routing can become unpredictable.
 Re-run with --replace-variant to remove ${otherAssetName}, or delete it manually.
 `);
 }