@chrrxs/robloxstudio-mcp 2.12.0 → 2.13.0

package/dist/index.js

@@ -700,9 +700,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 +1468,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 +2488,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;
@@ -1760,6 +2723,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 +2760,20 @@ 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] };
+      }
       async getFileTree(path2 = "", instance_id) {
         const response = await this._callSingle("/api/file-tree", { path: path2 }, void 0, instance_id);
         return {
@@ -2325,7 +3303,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 +3327,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);
@@ -3195,13 +4173,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 +4187,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,8 +4409,21 @@ ${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) {
           return {
             content: [{
@@ -3439,13 +4432,45 @@ ${code}`
             }]
           };
         }
-        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;
+        let { buffer, mimeType } = encodeImageFromRgbaResponse(response, fmt, q);
+        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
+            }
+          ]
         };
       }
     };
@@ -4605,7 +5630,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). Use this instead of execute_luau target=server when you need to see runtime-mutated module state. 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 +5649,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). Use this instead of execute_luau target=client-N when you need to see runtime-mutated module state. Requires a running playtest; the bridge is installed automatically (including for playtests started manually via the Studio Play button).",
         inputSchema: {
           type: "object",
           properties: {
@@ -5298,10 +6323,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 during a playtest (auto-detects a running client and captures the live play viewport). 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 +6347,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 +6384,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 +6401,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 ===