@chrrxs/robloxstudio-mcp 2.11.4 → 2.13.0

package/dist/index.js

@@ -9,6 +9,299 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// ../core/dist/bridge-service.js
+import { v4 as uuidv4 } from "uuid";
+function toPublic(inst) {
+  return {
+    instanceId: inst.instanceId,
+    role: inst.role,
+    placeId: inst.placeId,
+    placeName: inst.placeName,
+    dataModelName: inst.dataModelName,
+    isRunning: inst.isRunning,
+    lastActivity: inst.lastActivity,
+    connectedAt: inst.connectedAt
+  };
+}
+var RoutingFailure, STALE_INSTANCE_MS, BridgeService;
+var init_bridge_service = __esm({
+  "../core/dist/bridge-service.js"() {
+    "use strict";
+    RoutingFailure = class extends Error {
+      routingError;
+      constructor(routingError) {
+        super(routingError.message);
+        this.name = "RoutingFailure";
+        this.routingError = routingError;
+      }
+    };
+    STALE_INSTANCE_MS = 3e4;
+    BridgeService = class {
+      pendingRequests = /* @__PURE__ */ new Map();
+      // Keyed by pluginSessionId (the per-plugin GUID).
+      instances = /* @__PURE__ */ new Map();
+      requestTimeout = 3e4;
+      registerInstance(input) {
+        const { pluginSessionId, instanceId, role } = input;
+        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]));
+          }
+          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) {
+          return {
+            ok: false,
+            error: {
+              code: "duplicate_instance_role",
+              message: `Another plugin is already registered as (${instanceId}, ${assignedRole}).`,
+              existing: toPublic(existing)
+            }
+          };
+        }
+        this.instances.set(pluginSessionId, {
+          pluginSessionId,
+          instanceId,
+          role: assignedRole,
+          placeId: input.placeId ?? 0,
+          placeName: input.placeName ?? "",
+          dataModelName: input.dataModelName ?? "",
+          isRunning: input.isRunning ?? false,
+          lastActivity: Date.now(),
+          connectedAt: Date.now()
+        });
+        return { ok: true, assignedRole, instanceId };
+      }
+      unregisterInstance(pluginSessionId) {
+        const removed = this.instances.get(pluginSessionId);
+        this.instances.delete(pluginSessionId);
+        if (!removed)
+          return;
+        for (const [id, req] of this.pendingRequests.entries()) {
+          const stillHasHandler = Array.from(this.instances.values()).some((i) => i.instanceId === req.targetInstanceId && i.role === req.targetRole);
+          if (!stillHasHandler) {
+            clearTimeout(req.timeoutId);
+            this.pendingRequests.delete(id);
+            req.reject(new Error(`Target (${req.targetInstanceId}, ${req.targetRole}) disconnected`));
+          }
+        }
+      }
+      getInstances() {
+        return Array.from(this.instances.values());
+      }
+      getPublicInstances() {
+        return this.getInstances().map(toPublic);
+      }
+      getInstanceBySessionId(pluginSessionId) {
+        return this.instances.get(pluginSessionId);
+      }
+      getPendingRequestCount() {
+        return this.pendingRequests.size;
+      }
+      updateInstanceActivity(pluginSessionId) {
+        const inst = this.instances.get(pluginSessionId);
+        if (inst) {
+          inst.lastActivity = Date.now();
+        }
+      }
+      updateInstanceMetadata(pluginSessionId, metadata) {
+        const inst = this.instances.get(pluginSessionId);
+        if (!inst)
+          return;
+        if (metadata.placeId !== void 0)
+          inst.placeId = metadata.placeId;
+        if (metadata.placeName !== void 0)
+          inst.placeName = metadata.placeName;
+        if (metadata.dataModelName !== void 0)
+          inst.dataModelName = metadata.dataModelName;
+        if (metadata.isRunning !== void 0)
+          inst.isRunning = metadata.isRunning;
+      }
+      cleanupStaleInstances() {
+        const now = Date.now();
+        for (const [id, inst] of this.instances.entries()) {
+          if (now - inst.lastActivity > STALE_INSTANCE_MS) {
+            this.unregisterInstance(id);
+          }
+        }
+      }
+      // Resolves (instance_id, target-role) MCP arguments to a concrete
+      // routing decision: either a single (instanceId, role) tuple or a fanout
+      // list. Returns an error result with the full instance list embedded so
+      // the caller (tool layer) can surface it without a second round-trip.
+      resolveTarget(input) {
+        const instances = this.getInstances();
+        const publicList = instances.map(toPublic);
+        const errorData = { instances: publicList, count: publicList.length };
+        const { instance_id, target } = input;
+        const isFanout = target === "all";
+        const role = target && target !== "all" ? target : void 0;
+        if (instance_id !== void 0) {
+          const matchingInstances = instances.filter((i) => i.instanceId === instance_id);
+          if (matchingInstances.length === 0) {
+            return {
+              ok: false,
+              error: {
+                code: "unrecognized_instance_id",
+                message: `instance_id "${instance_id}" is not connected. Pass one from data.instances.`,
+                data: errorData
+              }
+            };
+          }
+          if (isFanout) {
+            return {
+              ok: true,
+              mode: "fanout",
+              targets: matchingInstances.map((i) => ({
+                targetInstanceId: i.instanceId,
+                targetRole: i.role
+              }))
+            };
+          }
+          if (role) {
+            const exact = matchingInstances.find((i) => i.role === role);
+            if (!exact) {
+              return {
+                ok: false,
+                error: {
+                  code: "target_role_not_present_on_instance",
+                  message: `instance "${instance_id}" has no role "${role}". Available roles: ${matchingInstances.map((i) => i.role).join(", ")}.`,
+                  data: errorData
+                }
+              };
+            }
+            return { ok: true, mode: "single", targetInstanceId: instance_id, targetRole: role };
+          }
+          if (matchingInstances.length === 1) {
+            return {
+              ok: true,
+              mode: "single",
+              targetInstanceId: instance_id,
+              targetRole: matchingInstances[0].role
+            };
+          }
+          const edit = matchingInstances.find((i) => i.role === "edit");
+          if (edit) {
+            return { ok: true, mode: "single", targetInstanceId: instance_id, targetRole: "edit" };
+          }
+          return {
+            ok: false,
+            error: {
+              code: "target_role_required",
+              message: `instance "${instance_id}" has multiple roles connected: ${matchingInstances.map((i) => i.role).join(", ")}. Pass target=<role>.`,
+              data: errorData
+            }
+          };
+        }
+        const distinctInstanceIds = new Set(instances.map((i) => i.instanceId));
+        if (distinctInstanceIds.size === 0) {
+          return {
+            ok: false,
+            error: {
+              code: "unrecognized_instance_id",
+              message: "No Studio plugin is connected.",
+              data: errorData
+            }
+          };
+        }
+        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.";
+          return { ok: false, error: { code: errorCode, message: msg, data: errorData } };
+        }
+        const onlyInstanceId = instances[0].instanceId;
+        return this.resolveTarget({ instance_id: onlyInstanceId, target });
+      }
+      async sendRequest(endpoint, data, targetInstanceId, targetRole) {
+        const requestId = uuidv4();
+        return new Promise((resolve2, reject) => {
+          const timeoutId = setTimeout(() => {
+            if (this.pendingRequests.has(requestId)) {
+              this.pendingRequests.delete(requestId);
+              reject(new Error("Request timeout"));
+            }
+          }, this.requestTimeout);
+          const request = {
+            id: requestId,
+            endpoint,
+            data,
+            targetInstanceId,
+            targetRole,
+            timestamp: Date.now(),
+            resolve: resolve2,
+            reject,
+            timeoutId
+          };
+          this.pendingRequests.set(requestId, request);
+        });
+      }
+      getPendingRequest(callerInstanceId, callerRole) {
+        let oldestRequest = null;
+        for (const request of this.pendingRequests.values()) {
+          if (request.targetInstanceId !== callerInstanceId)
+            continue;
+          if (request.targetRole !== callerRole)
+            continue;
+          if (!oldestRequest || request.timestamp < oldestRequest.timestamp) {
+            oldestRequest = request;
+          }
+        }
+        if (oldestRequest) {
+          return {
+            requestId: oldestRequest.id,
+            request: {
+              endpoint: oldestRequest.endpoint,
+              data: oldestRequest.data
+            }
+          };
+        }
+        return null;
+      }
+      resolveRequest(requestId, response) {
+        const request = this.pendingRequests.get(requestId);
+        if (request) {
+          clearTimeout(request.timeoutId);
+          this.pendingRequests.delete(requestId);
+          request.resolve(response);
+        }
+      }
+      rejectRequest(requestId, error) {
+        const request = this.pendingRequests.get(requestId);
+        if (request) {
+          clearTimeout(request.timeoutId);
+          this.pendingRequests.delete(requestId);
+          request.reject(error);
+        }
+      }
+      cleanupOldRequests() {
+        const now = Date.now();
+        for (const [id, request] of this.pendingRequests.entries()) {
+          if (now - request.timestamp > this.requestTimeout) {
+            clearTimeout(request.timeoutId);
+            this.pendingRequests.delete(id);
+            request.reject(new Error("Request timeout"));
+          }
+        }
+      }
+      clearAllPendingRequests() {
+        for (const [, request] of this.pendingRequests.entries()) {
+          clearTimeout(request.timeoutId);
+          request.reject(new Error("Connection closed"));
+        }
+        this.pendingRequests.clear();
+      }
+    };
+  }
+});
+
 // ../core/dist/http-server.js
 import express from "express";
 import cors from "cors";
@@ -56,12 +349,7 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig) {
       version: serverConfig?.version,
       pluginConnected: instances.length > 0,
       instanceCount: instances.length,
-      instances: instances.map((i) => ({
-        instanceId: i.instanceId,
-        role: i.role,
-        lastActivity: i.lastActivity,
-        connectedAt: i.connectedAt
-      })),
+      instances: instances.map(toPublic),
       mcpServerActive: isMCPServerActive(),
       uptime: mcpServerActive ? Date.now() - mcpServerStartTime : 0,
       pendingRequests: bridge.getPendingRequestCount(),
@@ -70,22 +358,42 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig) {
     });
   });
   app.post("/ready", (req, res) => {
-    const { instanceId, role } = req.body;
-    if (instanceId && role) {
-      const assignedRole = bridge.registerInstance(instanceId, role);
-      res.json({ success: true, assignedRole });
-    } else {
-      bridge.registerInstance("legacy", "edit");
-      res.json({ success: true, assignedRole: "edit" });
+    const { pluginSessionId, instanceId, role, placeId, placeName, dataModelName, isRunning } = req.body;
+    if (!pluginSessionId || !instanceId || !role) {
+      res.status(400).json({
+        success: false,
+        error: "pluginSessionId, instanceId, and role are required"
+      });
+      return;
+    }
+    const result = bridge.registerInstance({
+      pluginSessionId,
+      instanceId,
+      role,
+      placeId: typeof placeId === "number" ? placeId : 0,
+      placeName: typeof placeName === "string" ? placeName : "",
+      dataModelName: typeof dataModelName === "string" ? dataModelName : "",
+      isRunning: !!isRunning
+    });
+    if (!result.ok) {
+      res.status(409).json({
+        success: false,
+        error: result.error.code,
+        message: result.error.message,
+        existing: result.error.existing
+      });
+      return;
     }
+    res.json({
+      success: true,
+      assignedRole: result.assignedRole,
+      instanceId: result.instanceId
+    });
   });
   app.post("/disconnect", (req, res) => {
-    const { instanceId } = req.body;
-    if (instanceId) {
-      bridge.unregisterInstance(instanceId);
-    } else {
-      bridge.unregisterInstance("legacy");
-      bridge.clearAllPendingRequests();
+    const { pluginSessionId } = req.body;
+    if (pluginSessionId) {
+      bridge.unregisterInstance(pluginSessionId);
     }
     res.json({ success: true });
   });
@@ -94,7 +402,7 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig) {
     res.json({
       pluginConnected: instances.length > 0,
       instanceCount: instances.length,
-      instances: instances.map((i) => ({ instanceId: i.instanceId, role: i.role })),
+      instances: instances.map(toPublic),
       mcpServerActive: isMCPServerActive(),
       lastMCPActivity,
       uptime: mcpServerActive ? Date.now() - mcpServerStartTime : 0
@@ -104,15 +412,17 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig) {
     res.json({ instances: bridge.getInstances() });
   });
   app.get("/poll", (req, res) => {
-    const instanceId = req.query.instanceId;
-    if (instanceId) {
-      bridge.updateInstanceActivity(instanceId);
+    const pluginSessionId = req.query.pluginSessionId;
+    if (pluginSessionId) {
+      bridge.updateInstanceActivity(pluginSessionId);
     }
-    let callerRole = "edit";
+    let callerInstanceId;
+    let callerRole;
     let knownInstance = false;
-    if (instanceId) {
-      const inst = bridge.getInstances().find((i) => i.instanceId === instanceId);
+    if (pluginSessionId) {
+      const inst = bridge.getInstanceBySessionId(pluginSessionId);
       if (inst) {
+        callerInstanceId = inst.instanceId;
         callerRole = inst.role;
         knownInstance = true;
       }
@@ -127,7 +437,7 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig) {
       });
       return;
     }
-    const pendingRequest = bridge.getPendingRequest(callerRole);
+    const pendingRequest = knownInstance && callerInstanceId && callerRole ? bridge.getPendingRequest(callerInstanceId, callerRole) : null;
     if (pendingRequest) {
       res.json({
         request: pendingRequest.request,
@@ -157,16 +467,16 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig) {
     res.json({ success: true });
   });
   app.post("/proxy", async (req, res) => {
-    const { endpoint, data, target, proxyInstanceId } = req.body;
-    if (!endpoint) {
-      res.status(400).json({ error: "endpoint is required" });
+    const { endpoint, data, targetInstanceId, targetRole, proxyInstanceId } = req.body;
+    if (!endpoint || !targetInstanceId || !targetRole) {
+      res.status(400).json({ error: "endpoint, targetInstanceId, and targetRole are required" });
       return;
     }
     if (proxyInstanceId) {
       proxyInstances.add(proxyInstanceId);
     }
     try {
-      const response = await bridge.sendRequest(endpoint, data, target || "edit");
+      const response = await bridge.sendRequest(endpoint, data, targetInstanceId, targetRole);
       res.json({ response });
     } catch (err) {
       res.status(500).json({ error: err.message || "Proxy request failed" });
@@ -197,6 +507,19 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig) {
           try {
             return await handler(tools, args || {});
           } catch (error) {
+            if (error instanceof RoutingFailure) {
+              return {
+                content: [{
+                  type: "text",
+                  text: JSON.stringify({
+                    error: error.routingError.code,
+                    message: error.routingError.message,
+                    data: error.routingError.data
+                  })
+                }],
+                isError: true
+              };
+            }
             if (error instanceof McpError)
               throw error;
             throw new McpError(ErrorCode.InternalError, `Tool execution failed: ${error instanceof Error ? error.message : String(error)}`);
@@ -248,6 +571,14 @@ function createHttpServer(tools, bridge, allowedTools, serverConfig) {
         const result = await handler(tools, req.body);
         res.json(result);
       } catch (error) {
+        if (error instanceof RoutingFailure) {
+          res.status(400).json({
+            error: error.routingError.code,
+            message: error.routingError.message,
+            data: error.routingError.data
+          });
+          return;
+        }
         res.status(500).json({ error: error instanceof Error ? error.message : "Unknown error" });
       }
     });
@@ -296,26 +627,27 @@ var TOOL_HANDLERS;
 var init_http_server = __esm({
   "../core/dist/http-server.js"() {
     "use strict";
+    init_bridge_service();
     TOOL_HANDLERS = {
-      get_file_tree: (tools, body) => tools.getFileTree(body.path),
-      search_files: (tools, body) => tools.searchFiles(body.query, body.searchType),
-      get_place_info: (tools) => tools.getPlaceInfo(),
-      get_services: (tools, body) => tools.getServices(body.serviceName),
-      search_objects: (tools, body) => tools.searchObjects(body.query, body.searchType, body.propertyName),
-      get_instance_properties: (tools, body) => tools.getInstanceProperties(body.instancePath, body.excludeSource),
-      get_instance_children: (tools, body) => tools.getInstanceChildren(body.instancePath),
-      search_by_property: (tools, body) => tools.searchByProperty(body.propertyName, body.propertyValue),
-      get_class_info: (tools, body) => tools.getClassInfo(body.className),
-      get_project_structure: (tools, body) => tools.getProjectStructure(body.path, body.maxDepth, body.scriptsOnly),
-      set_property: (tools, body) => tools.setProperty(body.instancePath, body.propertyName, body.propertyValue),
-      set_properties: (tools, body) => tools.setProperties(body.instancePath, body.properties),
-      mass_set_property: (tools, body) => tools.massSetProperty(body.paths, body.propertyName, body.propertyValue),
-      mass_get_property: (tools, body) => tools.massGetProperty(body.paths, body.propertyName),
-      create_object: (tools, body) => tools.createObject(body.className, body.parent, body.name, body.properties),
-      mass_create_objects: (tools, body) => tools.massCreateObjects(body.objects),
-      delete_object: (tools, body) => tools.deleteObject(body.instancePath),
-      smart_duplicate: (tools, body) => tools.smartDuplicate(body.instancePath, body.count, body.options),
-      mass_duplicate: (tools, body) => tools.massDuplicate(body.duplications),
+      get_file_tree: (tools, body) => tools.getFileTree(body.path, body.instance_id),
+      search_files: (tools, body) => tools.searchFiles(body.query, body.searchType, body.instance_id),
+      get_place_info: (tools, body) => tools.getPlaceInfo(body.instance_id),
+      get_services: (tools, body) => tools.getServices(body.serviceName, body.instance_id),
+      search_objects: (tools, body) => tools.searchObjects(body.query, body.searchType, body.propertyName, body.instance_id),
+      get_instance_properties: (tools, body) => tools.getInstanceProperties(body.instancePath, body.excludeSource, body.instance_id),
+      get_instance_children: (tools, body) => tools.getInstanceChildren(body.instancePath, body.instance_id),
+      search_by_property: (tools, body) => tools.searchByProperty(body.propertyName, body.propertyValue, body.instance_id),
+      get_class_info: (tools, body) => tools.getClassInfo(body.className, body.instance_id),
+      get_project_structure: (tools, body) => tools.getProjectStructure(body.path, body.maxDepth, body.scriptsOnly, body.instance_id),
+      set_property: (tools, body) => tools.setProperty(body.instancePath, body.propertyName, body.propertyValue, body.instance_id),
+      set_properties: (tools, body) => tools.setProperties(body.instancePath, body.properties, body.instance_id),
+      mass_set_property: (tools, body) => tools.massSetProperty(body.paths, body.propertyName, body.propertyValue, body.instance_id),
+      mass_get_property: (tools, body) => tools.massGetProperty(body.paths, body.propertyName, body.instance_id),
+      create_object: (tools, body) => tools.createObject(body.className, body.parent, body.name, body.properties, body.instance_id),
+      mass_create_objects: (tools, body) => tools.massCreateObjects(body.objects, body.instance_id),
+      delete_object: (tools, body) => tools.deleteObject(body.instancePath, body.instance_id),
+      smart_duplicate: (tools, body) => tools.smartDuplicate(body.instancePath, body.count, body.options, body.instance_id),
+      mass_duplicate: (tools, body) => tools.massDuplicate(body.duplications, body.instance_id),
       grep_scripts: (tools, body) => tools.grepScripts(body.pattern, {
         caseSensitive: body.caseSensitive,
         usePattern: body.usePattern,
@@ -325,56 +657,56 @@ var init_http_server = __esm({
         filesOnly: body.filesOnly,
         path: body.path,
         classFilter: body.classFilter
-      }),
-      get_script_source: (tools, body) => tools.getScriptSource(body.instancePath, body.startLine, body.endLine),
-      set_script_source: (tools, body) => tools.setScriptSource(body.instancePath, body.source),
-      edit_script_lines: (tools, body) => tools.editScriptLines(body.instancePath, body.old_string, body.new_string, body.startLine),
-      insert_script_lines: (tools, body) => tools.insertScriptLines(body.instancePath, body.afterLine, body.newContent),
-      delete_script_lines: (tools, body) => tools.deleteScriptLines(body.instancePath, body.startLine, body.endLine),
-      set_attribute: (tools, body) => tools.setAttribute(body.instancePath, body.attributeName, body.attributeValue, body.valueType),
-      get_attributes: (tools, body) => tools.getAttributes(body.instancePath),
-      delete_attribute: (tools, body) => tools.deleteAttribute(body.instancePath, body.attributeName),
-      get_tags: (tools, body) => tools.getTags(body.instancePath),
-      add_tag: (tools, body) => tools.addTag(body.instancePath, body.tagName),
-      remove_tag: (tools, body) => tools.removeTag(body.instancePath, body.tagName),
-      get_tagged: (tools, body) => tools.getTagged(body.tagName),
-      get_selection: (tools) => tools.getSelection(),
-      execute_luau: (tools, body) => tools.executeLuau(body.code, body.target),
-      eval_server_runtime: (tools, body) => tools.evalServerRuntime(body.code),
-      eval_client_runtime: (tools, body) => tools.evalClientRuntime(body.code, body.target),
-      start_playtest: (tools, body) => tools.startPlaytest(body.mode, body.numPlayers),
-      stop_playtest: (tools) => tools.stopPlaytest(),
-      get_playtest_output: (tools, body) => tools.getPlaytestOutput(body.target),
-      get_runtime_logs: (tools, body) => tools.getRuntimeLogs(body.target, body.since, body.tail, body.filter),
+      }, body.instance_id),
+      get_script_source: (tools, body) => tools.getScriptSource(body.instancePath, body.startLine, body.endLine, body.instance_id),
+      set_script_source: (tools, body) => tools.setScriptSource(body.instancePath, body.source, body.instance_id),
+      edit_script_lines: (tools, body) => tools.editScriptLines(body.instancePath, body.old_string, body.new_string, body.startLine, body.instance_id),
+      insert_script_lines: (tools, body) => tools.insertScriptLines(body.instancePath, body.afterLine, body.newContent, body.instance_id),
+      delete_script_lines: (tools, body) => tools.deleteScriptLines(body.instancePath, body.startLine, body.endLine, body.instance_id),
+      set_attribute: (tools, body) => tools.setAttribute(body.instancePath, body.attributeName, body.attributeValue, body.valueType, body.instance_id),
+      get_attributes: (tools, body) => tools.getAttributes(body.instancePath, body.instance_id),
+      delete_attribute: (tools, body) => tools.deleteAttribute(body.instancePath, body.attributeName, body.instance_id),
+      get_tags: (tools, body) => tools.getTags(body.instancePath, body.instance_id),
+      add_tag: (tools, body) => tools.addTag(body.instancePath, body.tagName, body.instance_id),
+      remove_tag: (tools, body) => tools.removeTag(body.instancePath, body.tagName, body.instance_id),
+      get_tagged: (tools, body) => tools.getTagged(body.tagName, body.instance_id),
+      get_selection: (tools, body) => tools.getSelection(body.instance_id),
+      execute_luau: (tools, body) => tools.executeLuau(body.code, body.target, body.instance_id),
+      eval_server_runtime: (tools, body) => tools.evalServerRuntime(body.code, body.instance_id),
+      eval_client_runtime: (tools, body) => tools.evalClientRuntime(body.code, body.target, body.instance_id),
+      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),
+      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),
+      export_build: (tools, body) => tools.exportBuild(body.instancePath, body.outputId, body.style, body.instance_id),
       create_build: (tools, body) => tools.createBuild(body.id, body.style, body.palette, body.parts, body.bounds),
       generate_build: (tools, body) => tools.generateBuild(body.id, body.style, body.palette, body.code, body.seed),
-      import_build: (tools, body) => tools.importBuild(body.buildData, body.targetPath, body.position),
+      import_build: (tools, body) => tools.importBuild(body.buildData, body.targetPath, body.position, body.instance_id),
       list_library: (tools, body) => tools.listLibrary(body.style),
-      search_materials: (tools, body) => tools.searchMaterials(body.query, body.maxResults),
+      search_materials: (tools, body) => tools.searchMaterials(body.query, body.maxResults, body.instance_id),
       get_build: (tools, body) => tools.getBuild(body.id),
-      import_scene: (tools, body) => tools.importScene(body.sceneData, body.targetPath),
-      undo: (tools) => tools.undo(),
-      redo: (tools) => tools.redo(),
+      import_scene: (tools, body) => tools.importScene(body.sceneData, body.targetPath, body.instance_id),
+      undo: (tools, body) => tools.undo(body.instance_id),
+      redo: (tools, body) => tools.redo(body.instance_id),
       search_assets: (tools, body) => tools.searchAssets(body.assetType, body.query, body.maxResults, body.sortBy, body.verifiedCreatorsOnly),
       get_asset_details: (tools, body) => tools.getAssetDetails(body.assetId),
       get_asset_thumbnail: (tools, body) => tools.getAssetThumbnail(body.assetId, body.size),
-      insert_asset: (tools, body) => tools.insertAsset(body.assetId, body.parentPath, body.position),
-      preview_asset: (tools, body) => tools.previewAsset(body.assetId, body.includeProperties, body.maxDepth),
+      insert_asset: (tools, body) => tools.insertAsset(body.assetId, body.parentPath, body.position, body.instance_id),
+      preview_asset: (tools, body) => tools.previewAsset(body.assetId, body.includeProperties, body.maxDepth, body.instance_id),
       upload_asset: (tools, body) => tools.uploadAsset(body.filePath, body.assetType, body.displayName, body.description, body.userId, body.groupId),
-      clone_object: (tools, body) => tools.cloneObject(body.instancePath, body.targetParentPath),
-      get_descendants: (tools, body) => tools.getDescendants(body.instancePath, body.maxDepth, body.classFilter),
-      compare_instances: (tools, body) => tools.compareInstances(body.instancePathA, body.instancePathB),
-      get_output_log: (tools, body) => tools.getOutputLog(body.maxEntries, body.messageType),
-      bulk_set_attributes: (tools, body) => tools.bulkSetAttributes(body.instancePath, body.attributes),
-      capture_screenshot: (tools) => tools.captureScreenshot(),
-      simulate_mouse_input: (tools, body) => tools.simulateMouseInput(body.action, body.x, body.y, body.button, body.scrollDirection, body.target),
-      simulate_keyboard_input: (tools, body) => tools.simulateKeyboardInput(body.keyCode, body.action, body.duration, body.target),
-      character_navigation: (tools, body) => tools.characterNavigation(body.position, body.instancePath, body.waitForCompletion, body.timeout, body.target),
-      get_memory_breakdown: (tools, body) => tools.getMemoryBreakdown(body.target, body.tags),
-      export_rbxm: (tools, body) => tools.exportRbxm(body.instance_paths, body.output_path, body.target),
-      import_rbxm: (tools, body) => tools.importRbxm(body.source, body.parent_path, body.target),
+      clone_object: (tools, body) => tools.cloneObject(body.instancePath, body.targetParentPath, body.instance_id),
+      get_descendants: (tools, body) => tools.getDescendants(body.instancePath, body.maxDepth, body.classFilter, body.instance_id),
+      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, 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.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),
+      import_rbxm: (tools, body) => tools.importRbxm(body.source, body.parent_path, body.target, body.instance_id),
       find_and_replace_in_scripts: (tools, body) => tools.findAndReplaceInScripts(body.pattern, body.replacement, {
         caseSensitive: body.caseSensitive,
         usePattern: body.usePattern,
@@ -382,7 +714,7 @@ var init_http_server = __esm({
         classFilter: body.classFilter,
         dryRun: body.dryRun,
         maxReplacements: body.maxReplacements
-      })
+      }, body.instance_id)
     };
   }
 });
@@ -397,9 +729,9 @@ var init_studio_client = __esm({
       constructor(bridge) {
         this.bridge = bridge;
       }
-      async request(endpoint, data, target = "edit") {
+      async request(endpoint, data, targetInstanceId, targetRole) {
         try {
-          const response = await this.bridge.sendRequest(endpoint, data, target);
+          const response = await this.bridge.sendRequest(endpoint, data, targetInstanceId, targetRole);
           return response;
         } catch (error) {
           if (error instanceof Error && error.message === "Request timeout") {
@@ -1136,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) {
@@ -1199,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;
@@ -1215,8 +2510,16 @@ function luaLongQuote(s) {
 ${s}
 ]${eq}]`;
 }
+function evalCountLines(s) {
+  return s.split("\n").length;
+}
 function buildModuleScriptInvokeWrapper(opts) {
+  const userLines = evalCountLines(opts.userCode);
   const wrapped = `return ((function()
+	local __mcp_traceback
+	local __mcp_remap
+	local __mcp_LINE_OFFSET = ${EVAL_WRAPPER_LINE_OFFSET}
+	local __mcp_USER_LINES = ${userLines}
 	local __mcp_output = {}
 	local __mcp_real_print = print
 	local __mcp_real_warn = warn
@@ -1237,7 +2540,65 @@ function buildModuleScriptInvokeWrapper(opts) {
 	local function __mcp_run()
 ${opts.userCode}
 	end
-	local ok, errOrValue = xpcall(__mcp_run, debug.traceback)
+	__mcp_remap = function(s)
+		-- Two chunk-name formats can reference our payload: the
+		-- ModuleScript path "Workspace.__MCPEvalPayload:N" and the
+		-- loadstring chunk "[string \\"return ((function()...\\"]:N" (if
+		-- the IIFE happens to compile via loadstring). Normalize both to
+		-- "user_code:N" with the offset stripped AND clamped to user
+		-- range, otherwise unclosed constructs report nonsense lines deep
+		-- in the wrapper. Strip the "Workspace." parent prefix too so the
+		-- final output reads "user_code:N" not "Workspace.user_code:N".
+		local function __mcp_user_line(payload_n)
+			local user_n = payload_n - __mcp_LINE_OFFSET
+			if user_n < 1 then return "1" end
+			if user_n > __mcp_USER_LINES then return tostring(__mcp_USER_LINES) .. " (at end of input)" end
+			return tostring(user_n)
+		end
+		s = string.gsub(s, "Workspace%.__MCPEvalPayload:(%d+)", function(num)
+			local n = tonumber(num)
+			if n then return "user_code:" .. __mcp_user_line(n) end
+			return "user_code:" .. num
+		end)
+		s = string.gsub(s, "__MCPEvalPayload:(%d+)", function(num)
+			local n = tonumber(num)
+			if n then return "user_code:" .. __mcp_user_line(n) end
+			return "user_code:" .. num
+		end)
+		s = string.gsub(s, '%[string "[^"]+"%]:(%d+)', function(num)
+			local n = tonumber(num)
+			if n then return "user_code:" .. __mcp_user_line(n) end
+			return "user_code:" .. num
+		end)
+		return s
+	end
+	__mcp_traceback = function(err)
+		local raw = debug.traceback(tostring(err), 2)
+		local kept = {}
+		for line in string.gmatch(raw, "[^\\n]+") do
+			local num_str = string.match(line, "__MCPEvalPayload:(%d+)")
+				or string.match(line, '%[string "[^"]+"%]:(%d+)')
+			local n = num_str and tonumber(num_str)
+			-- Strip "in function '__mcp_run'" annotation BEFORE filtering:
+			-- user-code frames all carry that suffix (their source is
+			-- hosted inside __mcp_run), so a naive "__mcp_" filter would
+			-- drop every user frame and leave only the error header.
+			line = (string.gsub(line, " in function '__mcp_run'", ""))
+			local skip = string.find(line, "MCPPlugin", 1, true)
+				or string.find(line, "__mcp_", 1, true)
+				or string.find(line, "in function 'xpcall'", 1, true)
+			-- Drop wrapper preamble/postamble frames whose line falls
+			-- outside the user-code range \u2014 those are wrapper internals.
+			if n and (n <= __mcp_LINE_OFFSET or n > __mcp_LINE_OFFSET + __mcp_USER_LINES) then
+				skip = true
+			end
+			if not skip then
+				table.insert(kept, __mcp_remap(line))
+			end
+		end
+		return table.concat(kept, "\\n")
+	end
+	local ok, errOrValue = xpcall(__mcp_run, __mcp_traceback)
 	return { ok = ok, value = errOrValue, output = __mcp_output }
 end)())`;
   return `
@@ -1249,6 +2610,46 @@ if not bf then
 		error = ${luaLongQuote(opts.missingError)},
 	})
 end
+-- Outer-scope mirror of the in-IIFE __mcp_remap. Applied to parser errors
+-- we pull out of LogService (those never pass through the IIFE) and to
+-- the canned engine error string. Same offset as the IIFE's
+-- __mcp_LINE_OFFSET; covers both chunk-name formats.
+local __mcp_USER_LINES_OUTER = ${userLines}
+local function __mcp_outer_user_line(payload_n)
+	local user_n = payload_n - ${EVAL_WRAPPER_LINE_OFFSET}
+	if user_n < 1 then return "1" end
+	if user_n > __mcp_USER_LINES_OUTER then return tostring(__mcp_USER_LINES_OUTER) .. " (at end of input)" end
+	return tostring(user_n)
+end
+local function __mcp_outer_remap(s)
+	s = string.gsub(s, "Workspace%.__MCPEvalPayload:(%d+)", function(num)
+		local n = tonumber(num)
+		if n then return "user_code:" .. __mcp_outer_user_line(n) end
+		return "user_code:" .. num
+	end)
+	s = string.gsub(s, "__MCPEvalPayload:(%d+)", function(num)
+		local n = tonumber(num)
+		if n then return "user_code:" .. __mcp_outer_user_line(n) end
+		return "user_code:" .. num
+	end)
+	s = string.gsub(s, '%[string "[^"]+"%]:(%d+)', function(num)
+		local n = tonumber(num)
+		if n then return "user_code:" .. __mcp_outer_user_line(n) end
+		return "user_code:" .. num
+	end)
+	return s
+end
+-- JSON-encode tables; otherwise tostring. Cycles or non-serializable
+-- values fall back to tostring instead of erroring. This is what makes
+-- eval_server_runtime / eval_client_runtime return structured table data
+-- (matching execute_luau) instead of "table: 0xaddr".
+local function __mcp_format(v)
+	if typeof(v) == "table" then
+		local ok, encoded = pcall(function() return HttpService:JSONEncode(v) end)
+		if ok then return encoded end
+	end
+	return tostring(v)
+end
 local USER_CODE = ${luaLongQuote(wrapped)}
 local m = Instance.new("ModuleScript")
 m.Name = "__MCPEvalPayload"
@@ -1282,7 +2683,7 @@ if not bridgeOk then
 			end
 		end
 	end
-	return HttpService:JSONEncode({ bridge = "ok", ok = false, error = errMsg })
+	return HttpService:JSONEncode({ bridge = "ok", ok = false, error = __mcp_outer_remap(errMsg) })
 end
 -- inner is the {ok, value, output} table from our IIFE. Defensive: if it's
 -- somehow not a table (caller bypassed the wrapper), fall back to old shape.
@@ -1290,13 +2691,13 @@ if typeof(inner) ~= "table" then
 	return HttpService:JSONEncode({
 		bridge = "ok",
 		ok = true,
-		result = if inner == nil then nil else tostring(inner),
+		result = if inner == nil then nil else __mcp_format(inner),
 	})
 end
 return HttpService:JSONEncode({
 	bridge = "ok",
 	ok = inner.ok == true,
-	result = if inner.ok and inner.value ~= nil then tostring(inner.value) else nil,
+	result = if inner.ok and inner.value ~= nil then __mcp_format(inner.value) else nil,
 	error = if not inner.ok then tostring(inner.value) else nil,
 	output = inner.output or {},
 })
@@ -1313,17 +2714,20 @@ function parseBridgeResponse(response) {
   }
   return JSON.stringify(response);
 }
-var SERVER_LOCAL_NAME, CLIENT_LOCAL_NAME, RobloxStudioTools;
+var SERVER_LOCAL_NAME, CLIENT_LOCAL_NAME, EVAL_WRAPPER_LINE_OFFSET, RobloxStudioTools;
 var init_tools = __esm({
   "../core/dist/tools/index.js"() {
     "use strict";
     init_studio_client();
+    init_bridge_service();
     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";
+    EVAL_WRAPPER_LINE_OFFSET = 23;
     RobloxStudioTools = class _RobloxStudioTools {
       client;
       bridge;
@@ -1335,8 +2739,43 @@ var init_tools = __esm({
         this.openCloudClient = new OpenCloudClient();
         this.cookieClient = new RobloxCookieClient();
       }
-      async getFileTree(path2 = "") {
-        const response = await this.client.request("/api/file-tree", { path: path2 });
+      // Resolve (instance_id, target-role) → concrete (instanceId, role) and
+      // dispatch a single request. Throws RoutingFailure if the resolution is
+      // ambiguous, missing, or asks for fanout on a non-fanout-capable tool —
+      // the MCP transport layer surfaces it as a structured error result so
+      // the LLM can recover via the embedded data.instances list.
+      async _callSingle(endpoint, data, target, instance_id) {
+        const r = this.bridge.resolveTarget({ instance_id, target });
+        if (!r.ok)
+          throw new RoutingFailure(r.error);
+        if (r.mode !== "single") {
+          throw new RoutingFailure({
+            code: "target_role_not_present_on_instance",
+            message: "This tool does not support target=all. Pick a specific role or omit target.",
+            data: {
+              instances: this.bridge.getPublicInstances(),
+              count: this.bridge.getInstances().length
+            }
+          });
+        }
+        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 {
           content: [
             {
@@ -1346,8 +2785,8 @@ var init_tools = __esm({
           ]
         };
       }
-      async searchFiles(query, searchType = "name") {
-        const response = await this.client.request("/api/search-files", { query, searchType });
+      async searchFiles(query, searchType = "name", instance_id) {
+        const response = await this._callSingle("/api/search-files", { query, searchType }, void 0, instance_id);
         return {
           content: [
             {
@@ -1357,8 +2796,8 @@ var init_tools = __esm({
           ]
         };
       }
-      async getPlaceInfo() {
-        const response = await this.client.request("/api/place-info", {});
+      async getPlaceInfo(instance_id) {
+        const response = await this._callSingle("/api/place-info", {}, void 0, instance_id);
         return {
           content: [
             {
@@ -1368,8 +2807,8 @@ var init_tools = __esm({
           ]
         };
       }
-      async getServices(serviceName) {
-        const response = await this.client.request("/api/services", { serviceName });
+      async getServices(serviceName, instance_id) {
+        const response = await this._callSingle("/api/services", { serviceName }, void 0, instance_id);
         return {
           content: [
             {
@@ -1379,12 +2818,12 @@ var init_tools = __esm({
           ]
         };
       }
-      async searchObjects(query, searchType = "name", propertyName) {
-        const response = await this.client.request("/api/search-objects", {
+      async searchObjects(query, searchType = "name", propertyName, instance_id) {
+        const response = await this._callSingle("/api/search-objects", {
           query,
           searchType,
           propertyName
-        });
+        }, void 0, instance_id);
         return {
           content: [
             {
@@ -1394,11 +2833,11 @@ var init_tools = __esm({
           ]
         };
       }
-      async getInstanceProperties(instancePath, excludeSource) {
+      async getInstanceProperties(instancePath, excludeSource, instance_id) {
         if (!instancePath) {
           throw new Error("Instance path is required for get_instance_properties");
         }
-        const response = await this.client.request("/api/instance-properties", { instancePath, excludeSource });
+        const response = await this._callSingle("/api/instance-properties", { instancePath, excludeSource }, void 0, instance_id);
         return {
           content: [
             {
@@ -1408,11 +2847,11 @@ var init_tools = __esm({
           ]
         };
       }
-      async getInstanceChildren(instancePath) {
+      async getInstanceChildren(instancePath, instance_id) {
         if (!instancePath) {
           throw new Error("Instance path is required for get_instance_children");
         }
-        const response = await this.client.request("/api/instance-children", { instancePath });
+        const response = await this._callSingle("/api/instance-children", { instancePath }, void 0, instance_id);
         return {
           content: [
             {
@@ -1422,14 +2861,14 @@ var init_tools = __esm({
           ]
         };
       }
-      async searchByProperty(propertyName, propertyValue) {
+      async searchByProperty(propertyName, propertyValue, instance_id) {
         if (!propertyName || !propertyValue) {
           throw new Error("Property name and value are required for search_by_property");
         }
-        const response = await this.client.request("/api/search-by-property", {
+        const response = await this._callSingle("/api/search-by-property", {
           propertyName,
           propertyValue
-        });
+        }, void 0, instance_id);
         return {
           content: [
             {
@@ -1439,11 +2878,11 @@ var init_tools = __esm({
           ]
         };
       }
-      async getClassInfo(className) {
+      async getClassInfo(className, instance_id) {
         if (!className) {
           throw new Error("Class name is required for get_class_info");
         }
-        const response = await this.client.request("/api/class-info", { className });
+        const response = await this._callSingle("/api/class-info", { className }, void 0, instance_id);
         return {
           content: [
             {
@@ -1453,12 +2892,12 @@ var init_tools = __esm({
           ]
         };
       }
-      async getProjectStructure(path2, maxDepth, scriptsOnly) {
-        const response = await this.client.request("/api/project-structure", {
+      async getProjectStructure(path2, maxDepth, scriptsOnly, instance_id) {
+        const response = await this._callSingle("/api/project-structure", {
           path: path2,
           maxDepth,
           scriptsOnly
-        });
+        }, void 0, instance_id);
         return {
           content: [
             {
@@ -1468,15 +2907,15 @@ var init_tools = __esm({
           ]
         };
       }
-      async setProperty(instancePath, propertyName, propertyValue) {
+      async setProperty(instancePath, propertyName, propertyValue, instance_id) {
         if (!instancePath || !propertyName) {
           throw new Error("Instance path and property name are required for set_property");
         }
-        const response = await this.client.request("/api/set-property", {
+        const response = await this._callSingle("/api/set-property", {
           instancePath,
           propertyName,
           propertyValue
-        });
+        }, void 0, instance_id);
         return {
           content: [
             {
@@ -1486,22 +2925,22 @@ var init_tools = __esm({
           ]
         };
       }
-      async setProperties(instancePath, properties) {
+      async setProperties(instancePath, properties, instance_id) {
         if (!instancePath || !properties) {
           throw new Error("instancePath and properties are required for set_properties");
         }
-        const response = await this.client.request("/api/set-properties", { instancePath, properties });
+        const response = await this._callSingle("/api/set-properties", { instancePath, properties }, void 0, instance_id);
         return { content: [{ type: "text", text: JSON.stringify(response) }] };
       }
-      async massSetProperty(paths, propertyName, propertyValue) {
+      async massSetProperty(paths, propertyName, propertyValue, instance_id) {
         if (!paths || paths.length === 0 || !propertyName) {
           throw new Error("Paths array and property name are required for mass_set_property");
         }
-        const response = await this.client.request("/api/mass-set-property", {
+        const response = await this._callSingle("/api/mass-set-property", {
           paths,
           propertyName,
           propertyValue
-        });
+        }, void 0, instance_id);
         return {
           content: [
             {
@@ -1511,14 +2950,14 @@ var init_tools = __esm({
           ]
         };
       }
-      async massGetProperty(paths, propertyName) {
+      async massGetProperty(paths, propertyName, instance_id) {
         if (!paths || paths.length === 0 || !propertyName) {
           throw new Error("Paths array and property name are required for mass_get_property");
         }
-        const response = await this.client.request("/api/mass-get-property", {
+        const response = await this._callSingle("/api/mass-get-property", {
           paths,
           propertyName
-        });
+        }, void 0, instance_id);
         return {
           content: [
             {
@@ -1528,16 +2967,16 @@ var init_tools = __esm({
           ]
         };
       }
-      async createObject(className, parent, name, properties) {
+      async createObject(className, parent, name, properties, instance_id) {
         if (!className || !parent) {
           throw new Error("Class name and parent are required for create_object");
         }
-        const response = await this.client.request("/api/create-object", {
+        const response = await this._callSingle("/api/create-object", {
           className,
           parent,
           name,
           properties
-        });
+        }, void 0, instance_id);
         return {
           content: [
             {
@@ -1547,11 +2986,11 @@ var init_tools = __esm({
           ]
         };
       }
-      async massCreateObjects(objects) {
+      async massCreateObjects(objects, instance_id) {
         if (!objects || objects.length === 0) {
           throw new Error("Objects array is required for mass_create_objects");
         }
-        const response = await this.client.request("/api/mass-create-objects", { objects });
+        const response = await this._callSingle("/api/mass-create-objects", { objects }, void 0, instance_id);
         return {
           content: [
             {
@@ -1561,11 +3000,11 @@ var init_tools = __esm({
           ]
         };
       }
-      async deleteObject(instancePath) {
+      async deleteObject(instancePath, instance_id) {
         if (!instancePath) {
           throw new Error("Instance path is required for delete_object");
         }
-        const response = await this.client.request("/api/delete-object", { instancePath });
+        const response = await this._callSingle("/api/delete-object", { instancePath }, void 0, instance_id);
         return {
           content: [
             {
@@ -1575,15 +3014,15 @@ var init_tools = __esm({
           ]
         };
       }
-      async smartDuplicate(instancePath, count, options) {
+      async smartDuplicate(instancePath, count, options, instance_id) {
         if (!instancePath || count < 1) {
           throw new Error("Instance path and count > 0 are required for smart_duplicate");
         }
-        const response = await this.client.request("/api/smart-duplicate", {
+        const response = await this._callSingle("/api/smart-duplicate", {
           instancePath,
           count,
           options
-        });
+        }, void 0, instance_id);
         return {
           content: [
             {
@@ -1593,11 +3032,11 @@ var init_tools = __esm({
           ]
         };
       }
-      async massDuplicate(duplications) {
+      async massDuplicate(duplications, instance_id) {
         if (!duplications || duplications.length === 0) {
           throw new Error("Duplications array is required for mass_duplicate");
         }
-        const response = await this.client.request("/api/mass-duplicate", { duplications });
+        const response = await this._callSingle("/api/mass-duplicate", { duplications }, void 0, instance_id);
         return {
           content: [
             {
@@ -1607,11 +3046,11 @@ var init_tools = __esm({
           ]
         };
       }
-      async getScriptSource(instancePath, startLine, endLine) {
+      async getScriptSource(instancePath, startLine, endLine, instance_id) {
         if (!instancePath) {
           throw new Error("Instance path is required for get_script_source");
         }
-        const response = await this.client.request("/api/get-script-source", { instancePath, startLine, endLine });
+        const response = await this._callSingle("/api/get-script-source", { instancePath, startLine, endLine }, void 0, instance_id);
         if (response.error) {
           return { content: [{ type: "text", text: `Error: ${response.error}` }] };
         }
@@ -1658,11 +3097,11 @@ ${code}`
           }]
         };
       }
-      async setScriptSource(instancePath, source) {
+      async setScriptSource(instancePath, source, instance_id) {
         if (!instancePath || typeof source !== "string") {
           throw new Error("Instance path and source code string are required for set_script_source");
         }
-        const response = await this.client.request("/api/set-script-source", { instancePath, source });
+        const response = await this._callSingle("/api/set-script-source", { instancePath, source }, void 0, instance_id);
         return {
           content: [
             {
@@ -1672,14 +3111,14 @@ ${code}`
           ]
         };
       }
-      async editScriptLines(instancePath, oldString, newString, startLine) {
+      async editScriptLines(instancePath, oldString, newString, startLine, instance_id) {
         if (!instancePath || typeof oldString !== "string" || typeof newString !== "string") {
           throw new Error("Instance path, old_string, and new_string are required for edit_script_lines");
         }
         const payload = { instancePath, old_string: oldString, new_string: newString };
         if (startLine !== void 0)
           payload.startLine = startLine;
-        const response = await this.client.request("/api/edit-script-lines", payload);
+        const response = await this._callSingle("/api/edit-script-lines", payload, void 0, instance_id);
         return {
           content: [
             {
@@ -1689,11 +3128,11 @@ ${code}`
           ]
         };
       }
-      async insertScriptLines(instancePath, afterLine, newContent) {
+      async insertScriptLines(instancePath, afterLine, newContent, instance_id) {
         if (!instancePath || typeof newContent !== "string") {
           throw new Error("Instance path and newContent are required for insert_script_lines");
         }
-        const response = await this.client.request("/api/insert-script-lines", { instancePath, afterLine: afterLine || 0, newContent });
+        const response = await this._callSingle("/api/insert-script-lines", { instancePath, afterLine: afterLine || 0, newContent }, void 0, instance_id);
         return {
           content: [
             {
@@ -1703,11 +3142,11 @@ ${code}`
           ]
         };
       }
-      async deleteScriptLines(instancePath, startLine, endLine) {
+      async deleteScriptLines(instancePath, startLine, endLine, instance_id) {
         if (!instancePath || !startLine || !endLine) {
           throw new Error("Instance path, startLine, and endLine are required for delete_script_lines");
         }
-        const response = await this.client.request("/api/delete-script-lines", { instancePath, startLine, endLine });
+        const response = await this._callSingle("/api/delete-script-lines", { instancePath, startLine, endLine }, void 0, instance_id);
         return {
           content: [
             {
@@ -1717,14 +3156,14 @@ ${code}`
           ]
         };
       }
-      async grepScripts(pattern, options) {
+      async grepScripts(pattern, options, instance_id) {
         if (!pattern) {
           throw new Error("Pattern is required for grep_scripts");
         }
-        const response = await this.client.request("/api/grep-scripts", {
+        const response = await this._callSingle("/api/grep-scripts", {
           pattern,
           ...options
-        });
+        }, void 0, instance_id);
         return {
           content: [
             {
@@ -1734,11 +3173,11 @@ ${code}`
           ]
         };
       }
-      async setAttribute(instancePath, attributeName, attributeValue, valueType) {
+      async setAttribute(instancePath, attributeName, attributeValue, valueType, instance_id) {
         if (!instancePath || !attributeName) {
           throw new Error("Instance path and attribute name are required for set_attribute");
         }
-        const response = await this.client.request("/api/set-attribute", { instancePath, attributeName, attributeValue, valueType });
+        const response = await this._callSingle("/api/set-attribute", { instancePath, attributeName, attributeValue, valueType }, void 0, instance_id);
         return {
           content: [
             {
@@ -1748,11 +3187,11 @@ ${code}`
           ]
         };
       }
-      async getAttributes(instancePath) {
+      async getAttributes(instancePath, instance_id) {
         if (!instancePath) {
           throw new Error("Instance path is required for get_attributes");
         }
-        const response = await this.client.request("/api/get-attributes", { instancePath });
+        const response = await this._callSingle("/api/get-attributes", { instancePath }, void 0, instance_id);
         return {
           content: [
             {
@@ -1762,11 +3201,11 @@ ${code}`
           ]
         };
       }
-      async deleteAttribute(instancePath, attributeName) {
+      async deleteAttribute(instancePath, attributeName, instance_id) {
         if (!instancePath || !attributeName) {
           throw new Error("Instance path and attribute name are required for delete_attribute");
         }
-        const response = await this.client.request("/api/delete-attribute", { instancePath, attributeName });
+        const response = await this._callSingle("/api/delete-attribute", { instancePath, attributeName }, void 0, instance_id);
         return {
           content: [
             {
@@ -1776,11 +3215,11 @@ ${code}`
           ]
         };
       }
-      async getTags(instancePath) {
+      async getTags(instancePath, instance_id) {
         if (!instancePath) {
           throw new Error("Instance path is required for get_tags");
         }
-        const response = await this.client.request("/api/get-tags", { instancePath });
+        const response = await this._callSingle("/api/get-tags", { instancePath }, void 0, instance_id);
         return {
           content: [
             {
@@ -1790,11 +3229,11 @@ ${code}`
           ]
         };
       }
-      async addTag(instancePath, tagName) {
+      async addTag(instancePath, tagName, instance_id) {
         if (!instancePath || !tagName) {
           throw new Error("Instance path and tag name are required for add_tag");
         }
-        const response = await this.client.request("/api/add-tag", { instancePath, tagName });
+        const response = await this._callSingle("/api/add-tag", { instancePath, tagName }, void 0, instance_id);
         return {
           content: [
             {
@@ -1804,11 +3243,11 @@ ${code}`
           ]
         };
       }
-      async removeTag(instancePath, tagName) {
+      async removeTag(instancePath, tagName, instance_id) {
         if (!instancePath || !tagName) {
           throw new Error("Instance path and tag name are required for remove_tag");
         }
-        const response = await this.client.request("/api/remove-tag", { instancePath, tagName });
+        const response = await this._callSingle("/api/remove-tag", { instancePath, tagName }, void 0, instance_id);
         return {
           content: [
             {
@@ -1818,11 +3257,11 @@ ${code}`
           ]
         };
       }
-      async getTagged(tagName) {
+      async getTagged(tagName, instance_id) {
         if (!tagName) {
           throw new Error("Tag name is required for get_tagged");
         }
-        const response = await this.client.request("/api/get-tagged", { tagName });
+        const response = await this._callSingle("/api/get-tagged", { tagName }, void 0, instance_id);
         return {
           content: [
             {
@@ -1832,8 +3271,8 @@ ${code}`
           ]
         };
       }
-      async getSelection() {
-        const response = await this.client.request("/api/get-selection", {});
+      async getSelection(instance_id) {
+        const response = await this._callSingle("/api/get-selection", {}, void 0, instance_id);
         return {
           content: [
             {
@@ -1843,11 +3282,11 @@ ${code}`
           ]
         };
       }
-      async executeLuau(code, target) {
+      async executeLuau(code, target, instance_id) {
         if (!code) {
           throw new Error("Code is required for execute_luau");
         }
-        const response = await this.client.request("/api/execute-luau", { code }, target || "edit");
+        const response = await this._callSingle("/api/execute-luau", { code }, target || "edit", instance_id);
         return {
           content: [
             {
@@ -1857,17 +3296,17 @@ ${code}`
           ]
         };
       }
-      async evalServerRuntime(code) {
+      async evalServerRuntime(code, instance_id) {
         if (!code) {
           throw new Error("Code is required for eval_server_runtime");
         }
         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.client.request("/api/execute-luau", { code: wrapper }, "server");
+        const response = await this._callSingle("/api/execute-luau", { code: wrapper }, "server", instance_id);
         return {
           content: [
             {
@@ -1877,7 +3316,7 @@ ${code}`
           ]
         };
       }
-      async evalClientRuntime(code, target) {
+      async evalClientRuntime(code, target, instance_id) {
         if (!code) {
           throw new Error("Code is required for eval_client_runtime");
         }
@@ -1888,10 +3327,10 @@ ${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.client.request("/api/execute-luau", { code: wrapper }, clientTarget);
+        const response = await this._callSingle("/api/execute-luau", { code: wrapper }, clientTarget, instance_id);
         return {
           content: [
             {
@@ -1901,7 +3340,7 @@ ${code}`
           ]
         };
       }
-      async getRuntimeLogs(target, since, tail, filter) {
+      async getRuntimeLogs(target, since, tail, filter, instance_id) {
         const tgt = target ?? "all";
         const data = {};
         if (since !== void 0)
@@ -1910,16 +3349,26 @@ ${code}`
           data.tail = tail;
         if (filter !== void 0)
           data.filter = filter;
-        if (tgt !== "all") {
-          const response = await this.client.request("/api/get-runtime-logs", data, tgt);
+        const resolved = this.bridge.resolveTarget({ instance_id, target: tgt });
+        if (!resolved.ok)
+          throw new RoutingFailure(resolved.error);
+        if (resolved.mode === "single") {
+          const response = await this.client.request("/api/get-runtime-logs", data, resolved.targetInstanceId, resolved.targetRole);
+          response.peer = resolved.targetRole;
+          if (Array.isArray(response.entries)) {
+            for (const e of response.entries) {
+              if (e.peer !== void 0)
+                e.peer = resolved.targetRole;
+            }
+          }
           return {
             content: [{ type: "text", text: JSON.stringify(response) }]
           };
         }
-        const targets = this.bridge.getInstances().filter((i) => i.role !== "edit-proxy").map((i) => i.role);
+        const targets = resolved.targets.filter((t) => t.targetRole !== "edit-proxy");
         const responses = await Promise.allSettled(targets.map(async (t) => {
-          const r = await this.client.request("/api/get-runtime-logs", data, t);
-          return { ...r, peer: t };
+          const r = await this.client.request("/api/get-runtime-logs", data, t.targetInstanceId, t.targetRole);
+          return { ...r, peer: t.targetRole };
         }));
         const merged = [];
         const perPeerNextSince = {};
@@ -1965,7 +3414,7 @@ ${code}`
           content: [{ type: "text", text: JSON.stringify(body) }]
         };
       }
-      async startPlaytest(mode, numPlayers) {
+      async startPlaytest(mode, numPlayers, instance_id) {
         if (mode !== "play" && mode !== "run") {
           throw new Error('mode must be "play" or "run"');
         }
@@ -1973,7 +3422,7 @@ ${code}`
         if (numPlayers !== void 0) {
           data.numPlayers = numPlayers;
         }
-        const response = await this.client.request("/api/start-playtest", data);
+        const response = await this._callSingle("/api/start-playtest", data, void 0, instance_id);
         return {
           content: [
             {
@@ -1983,14 +3432,14 @@ ${code}`
           ]
         };
       }
-      async stopPlaytest() {
-        const response = await this.client.request("/api/stop-playtest", {}, "edit");
+      async stopPlaytest(instance_id) {
+        const response = await this._callSingle("/api/stop-playtest", {}, "edit", instance_id);
         return {
           content: [{ type: "text", text: JSON.stringify(response) }]
         };
       }
-      async getPlaytestOutput(target) {
-        const response = await this.client.request("/api/get-playtest-output", {}, target || "edit");
+      async getPlaytestOutput(target, instance_id) {
+        const response = await this._callSingle("/api/get-playtest-output", {}, target || "edit", instance_id);
         return {
           content: [
             {
@@ -2001,7 +3450,7 @@ ${code}`
         };
       }
       async getConnectedInstances() {
-        const instances = this.bridge.getInstances();
+        const instances = this.bridge.getPublicInstances();
         return {
           content: [
             {
@@ -2011,8 +3460,8 @@ ${code}`
           ]
         };
       }
-      async undo() {
-        const response = await this.client.request("/api/undo", {});
+      async undo(instance_id) {
+        const response = await this._callSingle("/api/undo", {}, void 0, instance_id);
         return {
           content: [
             {
@@ -2022,8 +3471,8 @@ ${code}`
           ]
         };
       }
-      async redo() {
-        const response = await this.client.request("/api/redo", {});
+      async redo(instance_id) {
+        const response = await this._callSingle("/api/redo", {}, void 0, instance_id);
         return {
           content: [
             {
@@ -2109,15 +3558,15 @@ ${code}`
         _RobloxStudioTools._cachedLibraryPath = result;
         return result;
       }
-      async exportBuild(instancePath, outputId, style = "misc") {
+      async exportBuild(instancePath, outputId, style = "misc", instance_id) {
         if (!instancePath) {
           throw new Error("Instance path is required for export_build");
         }
-        const response = await this.client.request("/api/export-build", {
+        const response = await this._callSingle("/api/export-build", {
           instancePath,
           outputId,
           style
-        });
+        }, void 0, instance_id);
         if (response && response.success && response.buildData) {
           const buildData = response.buildData;
           const buildId = buildData.id || `${style}/exported`;
@@ -2305,7 +3754,7 @@ ${code}`
           ]
         };
       }
-      async importBuild(buildData, targetPath, position) {
+      async importBuild(buildData, targetPath, position, instance_id) {
         if (!buildData || !targetPath) {
           throw new Error("buildData (or library ID string) and targetPath are required for import_build");
         }
@@ -2325,11 +3774,11 @@ ${code}`
         } else {
           resolved = buildData;
         }
-        const response = await this.client.request("/api/import-build", {
+        const response = await this._callSingle("/api/import-build", {
           buildData: resolved,
           targetPath,
           position
-        });
+        }, void 0, instance_id);
         return {
           content: [
             {
@@ -2371,11 +3820,11 @@ ${code}`
           ]
         };
       }
-      async searchMaterials(query, maxResults) {
-        const response = await this.client.request("/api/search-materials", {
+      async searchMaterials(query, maxResults, instance_id) {
+        const response = await this._callSingle("/api/search-materials", {
           query: query ?? "",
           maxResults: maxResults ?? 50
-        });
+        }, void 0, instance_id);
         return {
           content: [
             {
@@ -2415,7 +3864,7 @@ ${code}`
           ]
         };
       }
-      async importScene(sceneData, targetPath = "game.Workspace") {
+      async importScene(sceneData, targetPath = "game.Workspace", instance_id) {
         if (!sceneData) {
           throw new Error("sceneData is required for import_scene");
         }
@@ -2505,10 +3954,10 @@ ${code}`
         if (expandedBuilds.length === 0) {
           throw new Error("No builds to import - check model references and library");
         }
-        const response = await this.client.request("/api/import-scene", {
+        const response = await this._callSingle("/api/import-scene", {
           expandedBuilds,
           targetPath
-        });
+        }, void 0, instance_id);
         return {
           content: [
             {
@@ -2599,15 +4048,15 @@ ${code}`
           }]
         };
       }
-      async insertAsset(assetId, parentPath, position) {
+      async insertAsset(assetId, parentPath, position, instance_id) {
         if (!assetId) {
           throw new Error("Asset ID is required for insert_asset");
         }
-        const response = await this.client.request("/api/insert-asset", {
+        const response = await this._callSingle("/api/insert-asset", {
           assetId,
           parentPath: parentPath || "game.Workspace",
           position
-        });
+        }, void 0, instance_id);
         return {
           content: [{
             type: "text",
@@ -2615,15 +4064,15 @@ ${code}`
           }]
         };
       }
-      async previewAsset(assetId, includeProperties, maxDepth) {
+      async previewAsset(assetId, includeProperties, maxDepth, instance_id) {
         if (!assetId) {
           throw new Error("Asset ID is required for preview_asset");
         }
-        const response = await this.client.request("/api/preview-asset", {
+        const response = await this._callSingle("/api/preview-asset", {
           assetId,
           includeProperties: includeProperties ?? true,
           maxDepth: maxDepth ?? 10
-        });
+        }, void 0, instance_id);
         return {
           content: [{
             type: "text",
@@ -2645,7 +4094,7 @@ ${code}`
       return id
     `;
         try {
-          const response = await this.client.request("/api/execute-luau", { code }, "edit");
+          const response = await this._callSingle("/api/execute-luau", { code }, "edit", void 0);
           const returnValue = response?.returnValue;
           if (returnValue !== void 0 && returnValue !== null && /^\d+$/.test(String(returnValue))) {
             return String(returnValue);
@@ -2720,17 +4169,17 @@ ${code}`
           }]
         };
       }
-      async simulateMouseInput(action, x, y, button, scrollDirection, target) {
+      async simulateMouseInput(action, x, y, button, scrollDirection, target, instance_id) {
         if (!action) {
           throw new Error("action is required for simulate_mouse_input");
         }
-        const response = await this.client.request("/api/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");
+          button
+        }, target || clientRole || "edit", instanceId);
         return {
           content: [{
             type: "text",
@@ -2738,15 +4187,17 @@ ${code}`
           }]
         };
       }
-      async simulateKeyboardInput(keyCode, action, duration, target) {
-        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 response = await this.client.request("/api/simulate-keyboard-input", {
+        const { instanceId, clientRole } = this._resolveRuntime(instance_id);
+        const response = await this._callSingle("/api/simulate-keyboard-input", {
           keyCode,
           action,
-          duration
-        }, target || "edit");
+          duration,
+          text
+        }, target || clientRole || "edit", instanceId);
         return {
           content: [{
             type: "text",
@@ -2754,16 +4205,16 @@ ${code}`
           }]
         };
       }
-      async characterNavigation(position, instancePath, waitForCompletion, timeout, target) {
+      async characterNavigation(position, instancePath, waitForCompletion, timeout, target, instance_id) {
         if (!position && !instancePath) {
           throw new Error("Either position or instancePath is required for character_navigation");
         }
-        const response = await this.client.request("/api/character-navigation", {
+        const response = await this._callSingle("/api/character-navigation", {
           position,
           instancePath,
           waitForCompletion,
           timeout
-        }, target || "edit");
+        }, target || "edit", instance_id);
         return {
           content: [{
             type: "text",
@@ -2771,50 +4222,50 @@ ${code}`
           }]
         };
       }
-      async cloneObject(instancePath, targetParentPath) {
+      async cloneObject(instancePath, targetParentPath, instance_id) {
         if (!instancePath || !targetParentPath) {
           throw new Error("instancePath and targetParentPath are required for clone_object");
         }
-        const response = await this.client.request("/api/clone-object", { instancePath, targetParentPath });
+        const response = await this._callSingle("/api/clone-object", { instancePath, targetParentPath }, void 0, instance_id);
         return { content: [{ type: "text", text: JSON.stringify(response) }] };
       }
-      async getDescendants(instancePath, maxDepth, classFilter) {
+      async getDescendants(instancePath, maxDepth, classFilter, instance_id) {
         if (!instancePath) {
           throw new Error("instancePath is required for get_descendants");
         }
-        const response = await this.client.request("/api/get-descendants", { instancePath, maxDepth, classFilter });
+        const response = await this._callSingle("/api/get-descendants", { instancePath, maxDepth, classFilter }, void 0, instance_id);
         return { content: [{ type: "text", text: JSON.stringify(response) }] };
       }
-      async compareInstances(instancePathA, instancePathB) {
+      async compareInstances(instancePathA, instancePathB, instance_id) {
         if (!instancePathA || !instancePathB) {
           throw new Error("instancePathA and instancePathB are required for compare_instances");
         }
-        const response = await this.client.request("/api/compare-instances", { instancePathA, instancePathB });
+        const response = await this._callSingle("/api/compare-instances", { instancePathA, instancePathB }, void 0, instance_id);
         return { content: [{ type: "text", text: JSON.stringify(response) }] };
       }
-      async getOutputLog(maxEntries, messageType) {
-        const response = await this.client.request("/api/get-output-log", { maxEntries, messageType });
+      async getOutputLog(maxEntries, messageType, instance_id) {
+        const response = await this._callSingle("/api/get-output-log", { maxEntries, messageType }, void 0, instance_id);
         return { content: [{ type: "text", text: JSON.stringify(response) }] };
       }
-      async bulkSetAttributes(instancePath, attributes) {
+      async bulkSetAttributes(instancePath, attributes, instance_id) {
         if (!instancePath || !attributes) {
           throw new Error("instancePath and attributes are required for bulk_set_attributes");
         }
-        const response = await this.client.request("/api/bulk-set-attributes", { instancePath, attributes });
+        const response = await this._callSingle("/api/bulk-set-attributes", { instancePath, attributes }, void 0, instance_id);
         return { content: [{ type: "text", text: JSON.stringify(response) }] };
       }
-      async findAndReplaceInScripts(pattern, replacement, options) {
+      async findAndReplaceInScripts(pattern, replacement, options, instance_id) {
         if (!pattern) {
           throw new Error("pattern is required for find_and_replace_in_scripts");
         }
         if (replacement === void 0 || replacement === null) {
           throw new Error("replacement is required for find_and_replace_in_scripts");
         }
-        const response = await this.client.request("/api/find-and-replace-in-scripts", {
+        const response = await this._callSingle("/api/find-and-replace-in-scripts", {
           pattern,
           replacement,
           ...options
-        });
+        }, void 0, instance_id);
         return {
           content: [{
             type: "text",
@@ -2822,24 +4273,27 @@ ${code}`
           }]
         };
       }
-      async getMemoryBreakdown(target, tags) {
+      async getMemoryBreakdown(target, tags, instance_id) {
         const tgt = target ?? "all";
         const data = {};
         if (tags !== void 0)
           data.tags = tags;
-        if (tgt !== "all") {
-          const response = await this.client.request("/api/get-memory-breakdown", data, tgt);
+        const resolved = this.bridge.resolveTarget({ instance_id, target: tgt });
+        if (!resolved.ok)
+          throw new RoutingFailure(resolved.error);
+        if (resolved.mode === "single") {
+          const response = await this.client.request("/api/get-memory-breakdown", data, resolved.targetInstanceId, resolved.targetRole);
           return { content: [{ type: "text", text: JSON.stringify(response) }] };
         }
-        const targets = this.bridge.getInstances().filter((i) => i.role !== "edit-proxy").map((i) => i.role);
+        const targets = resolved.targets.filter((t) => t.targetRole !== "edit-proxy");
         const responses = await Promise.allSettled(targets.map(async (t) => ({
-          peer: t,
-          result: await this.client.request("/api/get-memory-breakdown", data, t)
+          peer: t.targetRole,
+          result: await this.client.request("/api/get-memory-breakdown", data, t.targetInstanceId, t.targetRole)
         })));
         const body = {};
         for (let i = 0; i < responses.length; i++) {
           const r = responses[i];
-          const peer = targets[i];
+          const peer = targets[i].targetRole;
           if (r.status === "fulfilled") {
             body[peer] = r.value.result;
           } else {
@@ -2848,7 +4302,7 @@ ${code}`
         }
         return { content: [{ type: "text", text: JSON.stringify(body) }] };
       }
-      async exportRbxm(instancePaths, outputPath, target) {
+      async exportRbxm(instancePaths, outputPath, target, instance_id) {
         if (!Array.isArray(instancePaths) || instancePaths.length === 0) {
           throw new Error("instance_paths must be a non-empty array for export_rbxm");
         }
@@ -2859,7 +4313,7 @@ ${code}`
         if (tgt !== "edit" && tgt !== "server") {
           throw new Error(`export_rbxm target must be "edit" or "server" (got: ${tgt})`);
         }
-        const response = await this.client.request("/api/export-rbxm", { instance_paths: instancePaths }, tgt);
+        const response = await this._callSingle("/api/export-rbxm", { instance_paths: instancePaths }, tgt, instance_id);
         if (response.error) {
           return { content: [{ type: "text", text: JSON.stringify({ error: response.error }) }] };
         }
@@ -2885,7 +4339,7 @@ ${code}`
           }]
         };
       }
-      async importRbxm(source, parentPath, target) {
+      async importRbxm(source, parentPath, target, instance_id) {
         if (!source || typeof source !== "object") {
           throw new Error("source is required for import_rbxm");
         }
@@ -2948,15 +4402,28 @@ ${code}`
           }
           sourceLabel = `base64(${bytes.length}B)`;
         }
-        const response = await this.client.request("/api/import-rbxm", {
+        const response = await this._callSingle("/api/import-rbxm", {
           base64: bytes.toString("base64"),
           parent_path: parentPath,
           source_label: sourceLabel
-        }, tgt);
+        }, tgt, instance_id);
         return { content: [{ type: "text", text: JSON.stringify(response) }] };
       }
-      async captureScreenshot() {
-        const response = await this.client.request("/api/capture-screenshot", {});
+      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: [{
@@ -2965,158 +4432,46 @@ ${code}`
             }]
           };
         }
-        const pngBuffer = encodePngFromRgbaResponse(response);
-        return {
-          content: [{
-            type: "image",
-            data: pngBuffer.toString("base64"),
-            mimeType: "image/png"
-          }]
-        };
-      }
-    };
-  }
-});
-
-// ../core/dist/bridge-service.js
-import { v4 as uuidv4 } from "uuid";
-var STALE_INSTANCE_MS, BridgeService;
-var init_bridge_service = __esm({
-  "../core/dist/bridge-service.js"() {
-    "use strict";
-    STALE_INSTANCE_MS = 3e4;
-    BridgeService = class {
-      pendingRequests = /* @__PURE__ */ new Map();
-      instances = /* @__PURE__ */ new Map();
-      requestTimeout = 3e4;
-      registerInstance(instanceId, role) {
-        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]));
+        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.`
+              }]
+            };
           }
-          let idx = 1;
-          while (used.has(idx))
-            idx++;
-          assignedRole = `client-${idx}`;
-        }
-        this.instances.set(instanceId, {
-          instanceId,
-          role: assignedRole,
-          lastActivity: Date.now(),
-          connectedAt: Date.now()
-        });
-        return assignedRole;
-      }
-      unregisterInstance(instanceId) {
-        this.instances.delete(instanceId);
-        for (const [id, req] of this.pendingRequests.entries()) {
-          const targetRole = req.target;
-          const hasHandler = Array.from(this.instances.values()).some((i) => i.role === targetRole);
-          if (!hasHandler) {
-            clearTimeout(req.timeoutId);
-            this.pendingRequests.delete(id);
-            req.reject(new Error(`Target instance "${targetRole}" disconnected`));
+          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`;
         }
-      }
-      getInstances() {
-        return Array.from(this.instances.values());
-      }
-      getPendingRequestCount() {
-        return this.pendingRequests.size;
-      }
-      updateInstanceActivity(instanceId) {
-        const inst = this.instances.get(instanceId);
-        if (inst) {
-          inst.lastActivity = Date.now();
-        }
-      }
-      cleanupStaleInstances() {
-        const now = Date.now();
-        for (const [id, inst] of this.instances.entries()) {
-          if (now - inst.lastActivity > STALE_INSTANCE_MS) {
-            this.unregisterInstance(id);
-          }
-        }
-      }
-      async sendRequest(endpoint, data, target = "edit") {
-        const requestId = uuidv4();
-        return new Promise((resolve2, reject) => {
-          const timeoutId = setTimeout(() => {
-            if (this.pendingRequests.has(requestId)) {
-              this.pendingRequests.delete(requestId);
-              reject(new Error("Request timeout"));
-            }
-          }, this.requestTimeout);
-          const request = {
-            id: requestId,
-            endpoint,
-            data,
-            target,
-            timestamp: Date.now(),
-            resolve: resolve2,
-            reject,
-            timeoutId
-          };
-          this.pendingRequests.set(requestId, request);
-        });
-      }
-      getPendingRequest(callerRole = "edit") {
-        let oldestRequest = null;
-        for (const request of this.pendingRequests.values()) {
-          if (request.target !== callerRole)
-            continue;
-          if (!oldestRequest || request.timestamp < oldestRequest.timestamp) {
-            oldestRequest = request;
-          }
-        }
-        if (oldestRequest) {
-          return {
-            requestId: oldestRequest.id,
-            request: {
-              endpoint: oldestRequest.endpoint,
-              data: oldestRequest.data
+        return {
+          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
             }
-          };
-        }
-        return null;
-      }
-      resolveRequest(requestId, response) {
-        const request = this.pendingRequests.get(requestId);
-        if (request) {
-          clearTimeout(request.timeoutId);
-          this.pendingRequests.delete(requestId);
-          request.resolve(response);
-        }
-      }
-      rejectRequest(requestId, error) {
-        const request = this.pendingRequests.get(requestId);
-        if (request) {
-          clearTimeout(request.timeoutId);
-          this.pendingRequests.delete(requestId);
-          request.reject(error);
-        }
-      }
-      cleanupOldRequests() {
-        const now = Date.now();
-        for (const [id, request] of this.pendingRequests.entries()) {
-          if (now - request.timestamp > this.requestTimeout) {
-            clearTimeout(request.timeoutId);
-            this.pendingRequests.delete(id);
-            request.reject(new Error("Request timeout"));
-          }
-        }
-      }
-      clearAllPendingRequests() {
-        for (const [, request] of this.pendingRequests.entries()) {
-          clearTimeout(request.timeoutId);
-          request.reject(new Error("Connection closed"));
-        }
-        this.pendingRequests.clear();
+          ]
+        };
       }
     };
   }
@@ -3166,14 +4521,20 @@ var init_proxy_bridge_service = __esm({
           this.refreshTimer = void 0;
         }
       }
-      async sendRequest(endpoint, data, target = "edit") {
+      async sendRequest(endpoint, data, targetInstanceId, targetRole) {
         const controller = new AbortController();
         const timeoutId = setTimeout(() => controller.abort(), this.proxyRequestTimeout);
         try {
           const response = await fetch(`${this.primaryBaseUrl}/proxy`, {
             method: "POST",
             headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({ endpoint, data, target, proxyInstanceId: this.proxyInstanceId }),
+            body: JSON.stringify({
+              endpoint,
+              data,
+              targetInstanceId,
+              targetRole,
+              proxyInstanceId: this.proxyInstanceId
+            }),
             signal: controller.signal
           });
           clearTimeout(timeoutId);
@@ -3257,6 +4618,19 @@ var init_server = __esm({
           try {
             return await handler(this.tools, args ?? {});
           } catch (error) {
+            if (error instanceof RoutingFailure) {
+              return {
+                content: [{
+                  type: "text",
+                  text: JSON.stringify({
+                    error: error.routingError.code,
+                    message: error.routingError.message,
+                    data: error.routingError.data
+                  })
+                }],
+                isError: true
+              };
+            }
             if (error instanceof McpError2)
               throw error;
             throw new McpError2(ErrorCode2.InternalError, `Tool execution failed: ${error instanceof Error ? error.message : String(error)}`);
@@ -3398,6 +4772,10 @@ var init_definitions = __esm({
             path: {
               type: "string",
               description: "Root path (default: game root)"
+            },
+            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."
             }
           }
         }
@@ -3417,6 +4795,10 @@ var init_definitions = __esm({
               type: "string",
               enum: ["name", "type", "content"],
               description: "Search mode (default: name)"
+            },
+            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: ["query"]
@@ -3429,7 +4811,12 @@ var init_definitions = __esm({
         description: "Get place ID, name, and game settings",
         inputSchema: {
           type: "object",
-          properties: {}
+          properties: {
+            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."
+            }
+          }
         }
       },
       {
@@ -3442,6 +4829,10 @@ var init_definitions = __esm({
             serviceName: {
               type: "string",
               description: "Specific service name"
+            },
+            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."
             }
           }
         }
@@ -3465,6 +4856,10 @@ var init_definitions = __esm({
             propertyName: {
               type: "string",
               description: 'Property name when searchType is "property"'
+            },
+            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: ["query"]
@@ -3485,6 +4880,10 @@ var init_definitions = __esm({
             excludeSource: {
               type: "boolean",
               description: "For scripts, return SourceLength/LineCount instead of full source (default: false)"
+            },
+            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: ["instancePath"]
@@ -3500,6 +4899,10 @@ var init_definitions = __esm({
             instancePath: {
               type: "string",
               description: "Instance path (dot notation)"
+            },
+            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: ["instancePath"]
@@ -3519,6 +4922,10 @@ var init_definitions = __esm({
             propertyValue: {
               type: "string",
               description: "Value to match"
+            },
+            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: ["propertyName", "propertyValue"]
@@ -3534,6 +4941,10 @@ var init_definitions = __esm({
             className: {
               type: "string",
               description: "Roblox class name"
+            },
+            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: ["className"]
@@ -3558,6 +4969,10 @@ var init_definitions = __esm({
             scriptsOnly: {
               type: "boolean",
               description: "Show only scripts (default: false)"
+            },
+            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."
             }
           }
         }
@@ -3580,6 +4995,10 @@ var init_definitions = __esm({
             },
             propertyValue: {
               description: "Value to set (string, number, boolean, or object for Vector3/Color3/UDim2)"
+            },
+            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: ["instancePath", "propertyName", "propertyValue"]
@@ -3603,6 +5022,10 @@ var init_definitions = __esm({
             },
             propertyValue: {
               description: "Value to set (string, number, boolean, or object for Vector3/Color3/UDim2)"
+            },
+            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: ["paths", "propertyName", "propertyValue"]
@@ -3623,6 +5046,10 @@ var init_definitions = __esm({
             propertyName: {
               type: "string",
               description: "Property name"
+            },
+            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: ["paths", "propertyName"]
@@ -3642,6 +5069,10 @@ var init_definitions = __esm({
             properties: {
               type: "object",
               description: "Map of property name to value"
+            },
+            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: ["instancePath", "properties"]
@@ -3670,6 +5101,10 @@ var init_definitions = __esm({
             properties: {
               type: "object",
               description: "Properties to set on creation"
+            },
+            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: ["className", "parent"]
@@ -3707,6 +5142,10 @@ var init_definitions = __esm({
                 required: ["className", "parent"]
               },
               description: "Objects to create"
+            },
+            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: ["objects"]
@@ -3722,6 +5161,10 @@ var init_definitions = __esm({
             instancePath: {
               type: "string",
               description: "Instance path (dot notation)"
+            },
+            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: ["instancePath"]
@@ -3775,6 +5218,10 @@ var init_definitions = __esm({
                   description: "Different parent per duplicate"
                 }
               }
+            },
+            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: ["instancePath", "count"]
@@ -3837,6 +5284,10 @@ var init_definitions = __esm({
                 required: ["instancePath", "count"]
               },
               description: "Duplication operations"
+            },
+            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: ["duplications"]
@@ -3862,6 +5313,10 @@ var init_definitions = __esm({
             endLine: {
               type: "number",
               description: "End line (inclusive)"
+            },
+            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: ["instancePath"]
@@ -3881,6 +5336,10 @@ var init_definitions = __esm({
             source: {
               type: "string",
               description: "New source code"
+            },
+            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: ["instancePath", "source"]
@@ -3908,6 +5367,10 @@ var init_definitions = __esm({
             startLine: {
               type: "number",
               description: "Optional 1-indexed line where old_string begins. When provided, skips uniqueness check and requires old_string to match starting at that exact line."
+            },
+            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: ["instancePath", "old_string", "new_string"]
@@ -3931,6 +5394,10 @@ var init_definitions = __esm({
             newContent: {
               type: "string",
               description: "Content to insert"
+            },
+            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: ["instancePath", "newContent"]
@@ -3954,6 +5421,10 @@ var init_definitions = __esm({
             endLine: {
               type: "number",
               description: "End line (inclusive)"
+            },
+            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: ["instancePath", "startLine", "endLine"]
@@ -3981,6 +5452,10 @@ var init_definitions = __esm({
             valueType: {
               type: "string",
               description: "Type hint if needed"
+            },
+            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: ["instancePath", "attributeName", "attributeValue"]
@@ -3996,6 +5471,10 @@ var init_definitions = __esm({
             instancePath: {
               type: "string",
               description: "Instance path (dot notation)"
+            },
+            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: ["instancePath"]
@@ -4015,6 +5494,10 @@ var init_definitions = __esm({
             attributeName: {
               type: "string",
               description: "Attribute name"
+            },
+            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: ["instancePath", "attributeName"]
@@ -4031,6 +5514,10 @@ var init_definitions = __esm({
             instancePath: {
               type: "string",
               description: "Instance path (dot notation)"
+            },
+            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: ["instancePath"]
@@ -4050,6 +5537,10 @@ var init_definitions = __esm({
             tagName: {
               type: "string",
               description: "Tag name"
+            },
+            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: ["instancePath", "tagName"]
@@ -4069,6 +5560,10 @@ var init_definitions = __esm({
             tagName: {
               type: "string",
               description: "Tag name"
+            },
+            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: ["instancePath", "tagName"]
@@ -4084,6 +5579,10 @@ var init_definitions = __esm({
             tagName: {
               type: "string",
               description: "Tag name"
+            },
+            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: ["tagName"]
@@ -4096,7 +5595,12 @@ var init_definitions = __esm({
         description: "Get all currently selected objects",
         inputSchema: {
           type: "object",
-          properties: {}
+          properties: {
+            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."
+            }
+          }
         }
       },
       // === Luau Execution ===
@@ -4114,6 +5618,10 @@ var init_definitions = __esm({
             target: {
               type: "string",
               description: 'Instance target: "edit" (default), "server", "client-1", "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: ["code"]
@@ -4122,13 +5630,17 @@ 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: {
             code: {
               type: "string",
               description: "Luau code to execute. Use return ... to get a value back."
+            },
+            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: ["code"]
@@ -4137,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: {
@@ -4148,6 +5660,10 @@ var init_definitions = __esm({
             target: {
               type: "string",
               description: 'Client target: "client-1" (default), "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: ["code"]
@@ -4197,6 +5713,10 @@ var init_definitions = __esm({
               type: "string",
               enum: ["Script", "LocalScript", "ModuleScript"],
               description: "Only search scripts of this class type"
+            },
+            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: ["pattern"]
@@ -4218,6 +5738,10 @@ var init_definitions = __esm({
             numPlayers: {
               type: "number",
               description: "Number of client players (1-8). Triggers server + clients mode via TestService."
+            },
+            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: ["mode"]
@@ -4229,7 +5753,12 @@ var init_definitions = __esm({
         description: "Stop playtest and return all captured output.",
         inputSchema: {
           type: "object",
-          properties: {}
+          properties: {
+            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."
+            }
+          }
         }
       },
       {
@@ -4242,6 +5771,10 @@ var init_definitions = __esm({
             target: {
               type: "string",
               description: 'Instance target: "edit" (default), "server", "client-1", "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."
             }
           }
         }
@@ -4268,6 +5801,10 @@ var init_definitions = __esm({
             filter: {
               type: "string",
               description: "Plain substring matched against each entry's message (no pattern semantics; literal text). Applied after since, before tail."
+            },
+            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."
             }
           }
         }
@@ -4289,7 +5826,12 @@ var init_definitions = __esm({
         description: "Undo the last change in Roblox Studio. Uses ChangeHistoryService to reverse the most recent operation.",
         inputSchema: {
           type: "object",
-          properties: {}
+          properties: {
+            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."
+            }
+          }
         }
       },
       {
@@ -4298,7 +5840,12 @@ var init_definitions = __esm({
         description: "Redo the last undone change in Roblox Studio. Uses ChangeHistoryService to reapply the most recently undone operation.",
         inputSchema: {
           type: "object",
-          properties: {}
+          properties: {
+            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."
+            }
+          }
         }
       },
       // === Build Library ===
@@ -4321,6 +5868,10 @@ var init_definitions = __esm({
               type: "string",
               enum: ["medieval", "modern", "nature", "scifi", "misc"],
               description: "Style category for the build (default: misc)"
+            },
+            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: ["instancePath"]
@@ -4470,6 +6021,10 @@ part(0,2,0,2,1,1,"b")`,
               type: "array",
               items: { type: "number" },
               description: "World position offset [X, Y, Z]"
+            },
+            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: ["buildData", "targetPath"]
@@ -4504,6 +6059,10 @@ part(0,2,0,2,1,1,"b")`,
             maxResults: {
               type: "number",
               description: "Max results to return (default: 50)"
+            },
+            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."
             }
           }
         }
@@ -4588,6 +6147,10 @@ part(0,2,0,2,1,1,"b")`,
             targetPath: {
               type: "string",
               description: "Parent instance path for the scene (default: game.Workspace)"
+            },
+            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: ["sceneData"]
@@ -4685,6 +6248,10 @@ part(0,2,0,2,1,1,"b")`,
                 z: { type: "number" }
               },
               description: "Optional world position to place the asset"
+            },
+            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: ["assetId"]
@@ -4708,6 +6275,10 @@ part(0,2,0,2,1,1,"b")`,
             maxDepth: {
               type: "number",
               description: "Max hierarchy traversal depth (default: 10)"
+            },
+            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: ["assetId"]
@@ -4752,46 +6323,59 @@ 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: {}
+          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."
+            }
+          }
         }
       },
       // === Input Simulation ===
       {
         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: {
+            target: {
               type: "string",
-              enum: ["up", "down"],
-              description: 'Scroll direction (only for "scroll" action)'
+              description: 'Instance target. Defaults to the running playtest client (client-1) when present, else "edit". Override with "server", "client-2", etc.'
             },
-            target: {
+            instance_id: {
               type: "string",
-              description: 'Instance target: "edit" (default), "server", "client-1", "client-2", etc.'
+              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: ["action", "x", "y"]
@@ -4800,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",
@@ -4817,12 +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 ===
@@ -4853,6 +6444,10 @@ part(0,2,0,2,1,1,"b")`,
             target: {
               type: "string",
               description: 'Instance target: "edit" (default), "server", "client-1", "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."
             }
           }
         }
@@ -4872,6 +6467,10 @@ part(0,2,0,2,1,1,"b")`,
             targetParentPath: {
               type: "string",
               description: "Path of the parent to place the clone under"
+            },
+            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: ["instancePath", "targetParentPath"]
@@ -4896,6 +6495,10 @@ part(0,2,0,2,1,1,"b")`,
             classFilter: {
               type: "string",
               description: 'Only include instances of this class (uses IsA, so "BasePart" matches Part, MeshPart, 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: ["instancePath"]
@@ -4915,6 +6518,10 @@ part(0,2,0,2,1,1,"b")`,
             instancePathB: {
               type: "string",
               description: "Second instance path"
+            },
+            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: ["instancePathA", "instancePathB"]
@@ -4935,6 +6542,10 @@ part(0,2,0,2,1,1,"b")`,
             messageType: {
               type: "string",
               description: 'Filter by message type (e.g. "Enum.MessageType.MessageOutput", "Enum.MessageType.MessageWarning", "Enum.MessageType.MessageError")'
+            },
+            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."
             }
           }
         }
@@ -4954,6 +6565,10 @@ part(0,2,0,2,1,1,"b")`,
             attributes: {
               type: "object",
               description: "Map of attribute names to values. Supports Vector3, Color3, UDim2 via _type convention."
+            },
+            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: ["instancePath", "attributes"]
@@ -4975,6 +6590,10 @@ part(0,2,0,2,1,1,"b")`,
               type: "array",
               items: { type: "string" },
               description: "Optional DeveloperMemoryTag whitelist. Unknown tag names return 0 + unknown_tags list."
+            },
+            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."
             }
           }
         }
@@ -5000,6 +6619,10 @@ part(0,2,0,2,1,1,"b")`,
               type: "string",
               enum: ["edit", "server"],
               description: 'Which DataModel to read from (default: "edit"). "server" serializes live runtime state during a playtest.'
+            },
+            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: ["instance_paths", "output_path"]
@@ -5034,6 +6657,10 @@ part(0,2,0,2,1,1,"b")`,
               type: "string",
               enum: ["edit", "server"],
               description: 'Which DataModel to import into (default: "edit"). "server" parents into the live play-server DM.'
+            },
+            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: ["source", "parent_path"]
@@ -5079,6 +6706,10 @@ part(0,2,0,2,1,1,"b")`,
             maxReplacements: {
               type: "number",
               description: "Safety limit on total replacements (default: 1000)"
+            },
+            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: ["pattern", "replacement"]