@chrrxs/robloxstudio-mcp 2.15.1 → 2.16.0

package/dist/index.js

@@ -737,6 +737,12 @@ var init_http_server = __esm({
       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),
+      set_network_profile: (tools, body) => tools.setNetworkProfile(body.profile, body.target, body.overrides, body.instance_id),
+      get_simulation_state: (tools, body) => tools.getSimulationState(body.include, body.target, body.instance_id),
+      reset_simulation_state: (tools, body) => tools.resetSimulationState(body.target, body.network, body.deviceSimulator, body.instance_id),
+      get_device_simulator_state: (tools, body) => tools.getDeviceSimulatorState(body.target, body.deviceId, body.includeDeviceList, body.instance_id),
+      set_device_simulator: (tools, body) => tools.setDeviceSimulator(body.target, body.deviceId, body.orientation, body.resolution, body.pixelDensity, body.scalingMode, body.stopSimulation, body.instance_id),
+      capture_device_matrix: (tools, body) => tools.captureDeviceMatrix(body.entries, body.target, body.format, body.quality, body.settleSeconds, body.restoreAfter, 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),
@@ -1261,21 +1267,21 @@ var init_opencloud_client = __esm({
           clearTimeout(timeoutId);
           if (!response.ok) {
             const errorBody = await response.text();
-            let errorMessage;
+            let errorMessage2;
             try {
               const errorJson = JSON.parse(errorBody);
-              errorMessage = errorJson.detail || errorJson.message || errorBody;
+              errorMessage2 = errorJson.detail || errorJson.message || errorBody;
             } catch {
-              errorMessage = errorBody;
+              errorMessage2 = errorBody;
             }
             if (response.status === 401) {
               throw new Error("Invalid or expired API key");
             } else if (response.status === 403) {
-              throw new Error(`API key lacks required permissions: ${errorMessage}`);
+              throw new Error(`API key lacks required permissions: ${errorMessage2}`);
             } else if (response.status === 429) {
               throw new Error("Rate limit exceeded. Please try again later.");
             } else {
-              throw new Error(`Open Cloud API error (${response.status}): ${errorMessage}`);
+              throw new Error(`Open Cloud API error (${response.status}): ${errorMessage2}`);
             }
           }
           return await response.json();
@@ -1410,21 +1416,21 @@ var init_opencloud_client = __esm({
           clearTimeout(timeoutId);
           if (!response.ok) {
             const errorBody = await response.text();
-            let errorMessage;
+            let errorMessage2;
             try {
               const errorJson = JSON.parse(errorBody);
-              errorMessage = errorJson.detail || errorJson.message || errorBody;
+              errorMessage2 = errorJson.detail || errorJson.message || errorBody;
             } catch {
-              errorMessage = errorBody;
+              errorMessage2 = errorBody;
             }
             if (response.status === 401) {
               throw new Error("Invalid or expired API key");
             } else if (response.status === 403) {
-              throw new Error(`API key lacks required permissions: ${errorMessage}`);
+              throw new Error(`API key lacks required permissions: ${errorMessage2}`);
             } else if (response.status === 429) {
               throw new Error("Rate limit exceeded. Please try again later.");
             } else {
-              throw new Error(`Open Cloud API error (${response.status}): ${errorMessage}`);
+              throw new Error(`Open Cloud API error (${response.status}): ${errorMessage2}`);
             }
           }
           return await response.json();
@@ -2570,223 +2576,340 @@ function encodeImageFromRgbaResponse(response, format, quality) {
     mimeType: "image/jpeg"
   };
 }
-function luaLongQuote(s) {
-  let level = 0;
-  while (s.includes(`]${"=".repeat(level)}]`))
-    level++;
-  const eq = "=".repeat(level);
-  return `[${eq}[
-${s}
-]${eq}]`;
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
 }
-function evalCountLines(s) {
-  return s.split("\n").length;
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function normalizeNetworkProfile(profile, overrides) {
+  if (!["great", "good", "poor", "custom"].includes(profile)) {
+    throw new Error('profile must be "great", "good", "poor", or "custom"');
+  }
+  const values = profile === "custom" ? {} : { ...NETWORK_PROFILES[profile] };
+  if (overrides !== void 0) {
+    if (typeof overrides !== "object" || overrides === null || Array.isArray(overrides)) {
+      throw new Error("overrides must be an object when provided");
+    }
+    const allowed = new Set(NETWORK_PROFILE_KEYS);
+    for (const [key, value] of Object.entries(overrides)) {
+      if (!allowed.has(key)) {
+        throw new Error(`Unsupported network override "${key}". Allowed: ${NETWORK_PROFILE_KEYS.join(", ")}`);
+      }
+      if (typeof value !== "number" || !Number.isFinite(value)) {
+        throw new Error(`Network override "${key}" must be a finite number`);
+      }
+      if (value < 0) {
+        throw new Error(`Network override "${key}" must be greater than or equal to 0`);
+      }
+      if ((key === "InboundNetworkLossPercent" || key === "OutboundNetworkLossPercent") && value > MAX_NETWORK_PACKET_LOSS_PERCENT) {
+        throw new Error(`Network override "${key}" cannot exceed ${MAX_NETWORK_PACKET_LOSS_PERCENT}; Roblox engine limits packet loss simulation to 0.5%.`);
+      }
+      values[key] = value;
+    }
+  }
+  if (Object.keys(values).length === 0) {
+    throw new Error("custom profile requires at least one override");
+  }
+  return values;
 }
-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
-	local print = function(...)
-		__mcp_real_print(...)
-		local args = {...}
-		local parts = table.create(#args)
-		for i, a in ipairs(args) do parts[i] = tostring(a) end
-		table.insert(__mcp_output, table.concat(parts, "\\t"))
+function buildNetworkProfileLuau(profile, values) {
+  const valuesJson = JSON.stringify(values);
+  const keysJson = JSON.stringify(NETWORK_PROFILE_KEYS);
+  return `
+local HttpService = game:GetService("HttpService")
+local ns = settings():GetService("NetworkSettings")
+local keys = HttpService:JSONDecode(${JSON.stringify(keysJson)})
+local desired = HttpService:JSONDecode(${JSON.stringify(valuesJson)})
+local before = {}
+for _, key in ipairs(keys) do
+	before[key] = ns[key]
+end
+for key, value in pairs(desired) do
+	ns[key] = value
+end
+local after = {}
+for _, key in ipairs(keys) do
+	after[key] = ns[key]
+end
+return HttpService:JSONEncode({
+	profile = ${JSON.stringify(profile)},
+	applied = desired,
+	before = before,
+	after = after,
+})
+`.trim();
+}
+function buildNetworkStateLuau(operation) {
+  const keysJson = JSON.stringify(NETWORK_PROFILE_KEYS);
+  const resetJson = JSON.stringify(ZERO_NETWORK_PROFILE);
+  return `
+local HttpService = game:GetService("HttpService")
+local ns = settings():GetService("NetworkSettings")
+local operation = ${JSON.stringify(operation)}
+local keys = HttpService:JSONDecode(${JSON.stringify(keysJson)})
+local resetValues = HttpService:JSONDecode(${JSON.stringify(resetJson)})
+
+local function readState()
+	local state = {}
+	for _, key in ipairs(keys) do
+		state[key] = ns[key]
 	end
-	local warn = function(...)
-		__mcp_real_warn(...)
-		local args = {...}
-		local parts = table.create(#args)
-		for i, a in ipairs(args) do parts[i] = tostring(a) end
-		table.insert(__mcp_output, "[warn] " .. table.concat(parts, "\\t"))
+	return state
+end
+
+if operation == "get" then
+	return HttpService:JSONEncode({
+		success = true,
+		state = readState(),
+	})
+end
+
+if operation == "reset" then
+	local before = readState()
+	for key, value in pairs(resetValues) do
+		ns[key] = value
 	end
-	local function __mcp_run()
-${opts.userCode}
+	return HttpService:JSONEncode({
+		success = true,
+		applied = resetValues,
+		before = before,
+		after = readState(),
+	})
+end
+
+error("Unsupported network simulation operation: " .. tostring(operation), 0)
+`.trim();
+}
+function normalizeDeviceSimulatorResolution(value) {
+  if (value === void 0)
+    return void 0;
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new Error("resolution must be an object with positive integer width and height");
+  }
+  const resolution = value;
+  const width = resolution.width;
+  const height = resolution.height;
+  if (!Number.isInteger(width) || !Number.isInteger(height) || width <= 0 || height <= 0) {
+    throw new Error("resolution.width and resolution.height must be positive integers");
+  }
+  return { width, height };
+}
+function normalizeDeviceSimulatorSettings(input) {
+  const settings = {};
+  if (input.deviceId !== void 0) {
+    if (typeof input.deviceId !== "string" || input.deviceId.trim() === "") {
+      throw new Error("deviceId must be a non-empty string");
+    }
+    settings.deviceId = input.deviceId;
+  }
+  if (input.orientation !== void 0) {
+    if (typeof input.orientation !== "string" || input.orientation.trim() === "") {
+      throw new Error("orientation must be a non-empty string");
+    }
+    settings.orientation = input.orientation;
+  }
+  const resolution = normalizeDeviceSimulatorResolution(input.resolution);
+  if (resolution !== void 0)
+    settings.resolution = resolution;
+  if (input.pixelDensity !== void 0) {
+    if (typeof input.pixelDensity !== "number" || !Number.isFinite(input.pixelDensity) || input.pixelDensity <= 0) {
+      throw new Error("pixelDensity must be a positive finite number");
+    }
+    settings.pixelDensity = input.pixelDensity;
+  }
+  if (input.scalingMode !== void 0) {
+    if (typeof input.scalingMode !== "string" || input.scalingMode.trim() === "") {
+      throw new Error("scalingMode must be a non-empty string");
+    }
+    settings.scalingMode = input.scalingMode;
+  }
+  return settings;
+}
+function hasDeviceSimulatorSettings(settings) {
+  return settings.deviceId !== void 0 || settings.orientation !== void 0 || settings.resolution !== void 0 || settings.pixelDensity !== void 0 || settings.scalingMode !== void 0;
+}
+function buildDeviceSimulatorLuau(operation, options) {
+  const payload = JSON.stringify({ operation, ...options });
+  return `
+local HttpService = game:GetService("HttpService")
+local simulator = game:GetService("StudioDeviceSimulatorService")
+local opts = HttpService:JSONDecode(${JSON.stringify(payload)})
+
+local function plain(value)
+	local valueType = typeof(value)
+	if valueType == "Vector2" then
+		return { x = value.X, y = value.Y, width = value.X, height = value.Y }
 	end
-	__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)
+	if valueType == "EnumItem" then
+		return value.Name
+	end
+	if type(value) == "table" then
+		local out = {}
+		for k, v in pairs(value) do
+			out[tostring(k)] = plain(v)
 		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
+		return out
 	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
+	return value
+end
+
+local function getDeviceInfo(deviceId)
+	local ok, info = pcall(function()
+		return simulator:GetDeviceInfoAsync(deviceId)
+	end)
+	if ok then
+		return plain(info), nil
+	end
+	return nil, tostring(info)
+end
+
+local function normalizeDeviceList(rawList)
+	local devices = {}
+	local ids = {}
+	for _, entry in ipairs(rawList) do
+		local item
+		local id
+		if type(entry) == "table" then
+			item = plain(entry)
+			id = item.DeviceId or item.deviceId or item.Id or item.id or item[1]
+		else
+			id = tostring(entry)
+			item = { DeviceId = id }
+		end
+		if id ~= nil then
+			id = tostring(id)
+			local info = getDeviceInfo(id)
+			if type(info) == "table" then
+				item = info
+				if item.DeviceId == nil then item.DeviceId = id end
 			end
-			if not skip then
-				table.insert(kept, __mcp_remap(line))
+			if item.IsCustom ~= true then
+				ids[id] = true
+				table.insert(devices, item)
 			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 `
-local HttpService = game:GetService("HttpService")
-local bf = game:GetService("${opts.service}"):FindFirstChild("${opts.bridgeName}")
-if not bf then
-	return HttpService:JSONEncode({
-		bridge = "missing",
-		error = ${luaLongQuote(opts.missingError)},
-	})
+	return devices, ids
 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)
+
+local function getDeviceList()
+	local rawList = simulator:GetDeviceListAsync()
+	return normalizeDeviceList(rawList)
 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
+
+local function assertBuiltInDeviceExists(deviceId)
+	local _, ids = getDeviceList()
+	if ids[deviceId] then return end
+	local available = {}
+	for id in pairs(ids) do table.insert(available, id) end
+	table.sort(available)
+	error('deviceId "' .. tostring(deviceId) .. '" is not an available built-in device. Use get_device_simulator_state to list supported device IDs. Available: ' .. table.concat(available, ", "), 0)
 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
+
+local function enumByName(enumType, raw, label)
+	local name = tostring(raw)
+	name = string.match(name, "([^%.]+)$") or name
+	local available = {}
+	for _, item in ipairs(enumType:GetEnumItems()) do
+		table.insert(available, item.Name)
+		if item.Name == name then
+			return item, item.Name
+		end
 	end
-	return tostring(v)
+	error(label .. ' "' .. tostring(raw) .. '" is not valid. Available: ' .. table.concat(available, ", "), 0)
 end
-local USER_CODE = ${luaLongQuote(wrapped)}
-local m = Instance.new("ModuleScript")
-m.Name = "__MCPEvalPayload"
-local okSet, setErr = pcall(function() m.Source = USER_CODE end)
-if not okSet then
-	m:Destroy()
-	return HttpService:JSONEncode({ bridge = "ok", ok = false, error = "ModuleScript Source set failed: " .. tostring(setErr) })
+
+local function tryActiveGetter(state, key, fn)
+	local ok, value = pcall(fn)
+	if ok then
+		state[key] = plain(value)
+	else
+		state.unavailable = state.unavailable or {}
+		state.unavailable[key] = tostring(value)
+	end
 end
-m.Parent = workspace
-local bridgeOk, inner = bf:Invoke(m)
-m:Destroy()
-if not bridgeOk then
-	local errMsg = tostring(inner)
-	-- pcall(require, payload) collapses parse/compile failures into the
-	-- canned engine string below. The real parser diagnostic was emitted
-	-- to LogService just before. Walk GetLogHistory backward for the most
-	-- recent ERR entry tagged at our payload path and substitute.
-	if errMsg == "Requested module experienced an error while loading" then
-		-- The parser diagnostic is emitted to LogService on the next
-		-- engine frame, not synchronously with pcall(require). task.wait(0)
-		-- yields too early; 50ms is enough to let the frame complete and
-		-- the message land in GetLogHistory.
-		task.wait(0.05)
-		local LogService = game:GetService("LogService")
-		local hist = LogService:GetLogHistory()
-		for i = #hist, 1, -1 do
-			local e = hist[i]
-			if e.messageType == Enum.MessageType.MessageError and string.sub(e.message, 1, 27) == "Workspace.__MCPEvalPayload:" then
-				errMsg = e.message
-				break
-			end
-		end
+
+local function readState(includeDeviceList, requestedDeviceId)
+	local activeDeviceId = tostring(simulator:GetDeviceAsync())
+	local state = {
+		activeDeviceId = activeDeviceId,
+		isSimulating = activeDeviceId ~= "default",
+	}
+
+	if includeDeviceList then
+		local devices = getDeviceList()
+		state.devices = devices
+	end
+
+	if requestedDeviceId ~= nil then
+		assertBuiltInDeviceExists(requestedDeviceId)
+		state.deviceInfo = plain(simulator:GetDeviceInfoAsync(requestedDeviceId))
+	end
+
+	if state.isSimulating then
+		tryActiveGetter(state, "resolution", function() return simulator:GetResolutionAsync() end)
+		tryActiveGetter(state, "pixelDensity", function() return simulator:GetPixelDensityAsync() end)
+		tryActiveGetter(state, "orientation", function() return simulator:GetOrientationAsync() end)
+		tryActiveGetter(state, "scalingMode", function() return simulator:GetScalingModeAsync() end)
 	end
-	return HttpService:JSONEncode({ bridge = "ok", ok = false, error = __mcp_outer_remap(errMsg) })
+
+	return state
 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.
-if typeof(inner) ~= "table" then
-	return HttpService:JSONEncode({
-		bridge = "ok",
-		ok = true,
-		result = if inner == nil then nil else __mcp_format(inner),
-	})
+
+local function applySettings(settings)
+	local applied = {}
+	if settings.deviceId ~= nil then
+		assertBuiltInDeviceExists(settings.deviceId)
+		simulator:SetDeviceAsync(settings.deviceId)
+		applied.deviceId = settings.deviceId
+	end
+	if settings.orientation ~= nil then
+		local item, name = enumByName(Enum.ScreenOrientation, settings.orientation, "orientation")
+		simulator:SetOrientationAsync(item)
+		applied.orientation = name
+	end
+	if settings.resolution ~= nil then
+		simulator:SetResolutionAsync(settings.resolution.width, settings.resolution.height)
+		applied.resolution = { width = settings.resolution.width, height = settings.resolution.height }
+	end
+	if settings.pixelDensity ~= nil then
+		simulator:SetPixelDensityAsync(settings.pixelDensity)
+		applied.pixelDensity = settings.pixelDensity
+	end
+	if settings.scalingMode ~= nil then
+		local item, name = enumByName(Enum.DeviceSimulatorScalingMode, settings.scalingMode, "scalingMode")
+		simulator:SetScalingModeAsync(item)
+		applied.scalingMode = name
+	end
+	return applied
 end
-return HttpService:JSONEncode({
-	bridge = "ok",
-	ok = inner.ok == true,
-	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 {},
-})
-`;
-}
-function parseBridgeResponse(response) {
-  const r = response;
-  if (r && typeof r.returnValue === "string") {
-    try {
-      const parsed = JSON.parse(r.returnValue);
-      return JSON.stringify(parsed);
-    } catch {
-    }
-  }
-  return JSON.stringify(response);
-}
-function sleep(ms) {
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
+
+if opts.operation == "get" then
+	return readState(opts.includeDeviceList ~= false, opts.deviceId)
+end
+
+if opts.operation == "set" then
+	local before = readState(false, nil)
+	local applied
+	if opts.stopSimulation == true then
+		simulator:StopSimulationAsync()
+		applied = { stopSimulation = true }
+	else
+		applied = applySettings(opts.settings or {})
+	end
+	return {
+		success = true,
+		applied = applied,
+		before = before,
+		after = readState(false, nil),
+	}
+end
+
+error("Unsupported device simulator operation: " .. tostring(opts.operation), 0)
+`.trim();
 }
-var SERVER_LOCAL_NAME, CLIENT_LOCAL_NAME, EVAL_WRAPPER_LINE_OFFSET, RobloxStudioTools;
+var MAX_INLINE_IMAGE_BYTES, MAX_DEVICE_MATRIX_ENTRIES, MAX_NETWORK_PACKET_LOSS_PERCENT, NETWORK_PROFILE_KEYS, NETWORK_PROFILES, ZERO_NETWORK_PROFILE, SIMULATION_PERSISTENCE_NOTES, RobloxStudioTools;
 var init_tools = __esm({
   "../core/dist/tools/index.js"() {
     "use strict";
@@ -2797,9 +2920,56 @@ var init_tools = __esm({
     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;
+    MAX_INLINE_IMAGE_BYTES = 6e6;
+    MAX_DEVICE_MATRIX_ENTRIES = 6;
+    MAX_NETWORK_PACKET_LOSS_PERCENT = 0.5;
+    NETWORK_PROFILE_KEYS = [
+      "InboundNetworkMinDelayMs",
+      "OutboundNetworkMinDelayMs",
+      "InboundNetworkJitterMs",
+      "OutboundNetworkJitterMs",
+      "InboundNetworkLossPercent",
+      "OutboundNetworkLossPercent"
+    ];
+    NETWORK_PROFILES = {
+      great: {
+        InboundNetworkMinDelayMs: 15,
+        OutboundNetworkMinDelayMs: 15,
+        InboundNetworkJitterMs: 0,
+        OutboundNetworkJitterMs: 0,
+        InboundNetworkLossPercent: 0,
+        OutboundNetworkLossPercent: 0
+      },
+      good: {
+        InboundNetworkMinDelayMs: 50,
+        OutboundNetworkMinDelayMs: 50,
+        InboundNetworkJitterMs: 10,
+        OutboundNetworkJitterMs: 10,
+        InboundNetworkLossPercent: 0,
+        OutboundNetworkLossPercent: 0
+      },
+      poor: {
+        InboundNetworkMinDelayMs: 150,
+        OutboundNetworkMinDelayMs: 150,
+        InboundNetworkJitterMs: 100,
+        OutboundNetworkJitterMs: 100,
+        InboundNetworkLossPercent: 0.5,
+        OutboundNetworkLossPercent: 0.5
+      }
+    };
+    ZERO_NETWORK_PROFILE = {
+      InboundNetworkMinDelayMs: 0,
+      OutboundNetworkMinDelayMs: 0,
+      InboundNetworkJitterMs: 0,
+      OutboundNetworkJitterMs: 0,
+      InboundNetworkLossPercent: 0,
+      OutboundNetworkLossPercent: 0
+    };
+    SIMULATION_PERSISTENCE_NOTES = [
+      "Normal Play client changes can write back to edit state.",
+      "Multiplayer clients inherit baseline at startup but are isolated afterward.",
+      "StudioTestService client device simulator state may appear stale on fresh clients, so reset after client startup is required."
+    ];
     RobloxStudioTools = class _RobloxStudioTools {
       client;
       bridge;
@@ -2899,6 +3069,160 @@ var init_tools = __esm({
       _clientRolesForInstance(instanceId) {
         return this._rolesForInstance(instanceId).filter((role) => /^client-\d+$/.test(role)).sort((a, b) => Number(a.slice("client-".length)) - Number(b.slice("client-".length)));
       }
+      _resolveDeviceSimulatorSingleTarget(target, instance_id, toolName) {
+        const selectedTarget = target ?? "edit";
+        if (selectedTarget === "server" || selectedTarget === "all" || selectedTarget === "all-clients" || selectedTarget === "edit-proxy") {
+          throw new Error(`${toolName} target must be "edit" or "client-N" (got: ${selectedTarget})`);
+        }
+        if (selectedTarget !== "edit" && !/^client-\d+$/.test(selectedTarget)) {
+          throw new Error(`${toolName} target must be "edit" or "client-N" (got: ${selectedTarget})`);
+        }
+        const resolved = this._resolveSingleTarget(selectedTarget, instance_id);
+        return { ...resolved, selectedTarget };
+      }
+      _resolveDeviceSimulatorSetTargets(target, instance_id) {
+        const selectedTarget = target ?? "edit";
+        if (selectedTarget === "all-clients") {
+          const instanceId = this._resolveInstanceIdOnly(instance_id);
+          const roles = this._clientRolesForInstance(instanceId);
+          if (roles.length === 0) {
+            throw new RoutingFailure({
+              code: "target_role_not_present_on_instance",
+              message: `instance "${instanceId}" has no connected playtest client roles. Start a playtest first.`,
+              data: {
+                instances: this.bridge.getPublicInstances(),
+                count: this.bridge.getInstances().length
+              }
+            });
+          }
+          return { instanceId, selectedTarget, roles };
+        }
+        const resolved = this._resolveDeviceSimulatorSingleTarget(selectedTarget, instance_id, "set_device_simulator");
+        return { instanceId: resolved.instanceId, selectedTarget, roles: [resolved.role] };
+      }
+      _normalizeSimulationInclude(include) {
+        const selectedInclude = include ?? "both";
+        if (selectedInclude !== "network" && selectedInclude !== "deviceSimulator" && selectedInclude !== "both") {
+          throw new Error(`get_simulation_state include must be "network", "deviceSimulator", or "both" (got: ${selectedInclude})`);
+        }
+        return selectedInclude;
+      }
+      _resolveSimulationTargets(target, instance_id, toolName) {
+        const selectedTarget = target ?? "edit-and-clients";
+        if (selectedTarget === "server" || selectedTarget === "all" || selectedTarget === "edit-proxy") {
+          throw new Error(`${toolName} target must be "edit", "client-N", "all-clients", or "edit-and-clients" (got: ${selectedTarget})`);
+        }
+        const instanceId = this._resolveInstanceIdOnly(instance_id);
+        const connectedRoles = this._rolesForInstance(instanceId);
+        const clientRoles = this._clientRolesForInstance(instanceId);
+        const warnings = [];
+        let roles;
+        if (selectedTarget === "edit") {
+          if (!connectedRoles.includes("edit")) {
+            throw new RoutingFailure({
+              code: "target_role_not_present_on_instance",
+              message: `instance "${instanceId}" has no role "edit". Available roles: ${connectedRoles.join(", ") || "none"}.`,
+              data: {
+                instances: this.bridge.getPublicInstances(),
+                count: this.bridge.getInstances().length
+              }
+            });
+          }
+          roles = ["edit"];
+        } else if (selectedTarget === "all-clients") {
+          roles = clientRoles;
+          if (roles.length === 0) {
+            warnings.push(`No connected playtest client roles found for instance "${instanceId}".`);
+          }
+        } else if (selectedTarget === "edit-and-clients") {
+          roles = [];
+          if (connectedRoles.includes("edit")) {
+            roles.push("edit");
+          } else {
+            warnings.push(`No edit role found for instance "${instanceId}".`);
+          }
+          roles.push(...clientRoles);
+        } else if (/^client-\d+$/.test(selectedTarget)) {
+          if (!clientRoles.includes(selectedTarget)) {
+            throw new RoutingFailure({
+              code: "target_role_not_present_on_instance",
+              message: `instance "${instanceId}" has no role "${selectedTarget}". Available client roles: ${clientRoles.join(", ") || "none"}.`,
+              data: {
+                instances: this.bridge.getPublicInstances(),
+                count: this.bridge.getInstances().length
+              }
+            });
+          }
+          roles = [selectedTarget];
+        } else {
+          throw new Error(`${toolName} target must be "edit", "client-N", "all-clients", or "edit-and-clients" (got: ${selectedTarget})`);
+        }
+        return { instanceId, selectedTarget, roles, warnings };
+      }
+      _parseExecuteLuauJsonResponse(response, toolName) {
+        const r = response;
+        if (r?.success === false) {
+          throw new Error(r.error || r.message || `${toolName} Luau execution failed`);
+        }
+        if (typeof r?.returnValue !== "string") {
+          return response;
+        }
+        if (r.returnValue === "") {
+          return {};
+        }
+        try {
+          return JSON.parse(r.returnValue);
+        } catch {
+          throw new Error(`${toolName} returned non-JSON data: ${r.returnValue}`);
+        }
+      }
+      async _executeNetworkStateOperation(instanceId, role, operation) {
+        const code = buildNetworkStateLuau(operation);
+        const response = await this.client.request("/api/execute-luau", { code }, instanceId, role);
+        return this._parseExecuteLuauJsonResponse(response, `network simulation ${operation}`);
+      }
+      async _executeDeviceSimulatorOperation(instanceId, role, operation, options) {
+        const code = buildDeviceSimulatorLuau(operation, options);
+        const response = await this.client.request("/api/execute-luau", { code }, instanceId, role);
+        return this._parseExecuteLuauJsonResponse(response, `device simulator ${operation}`);
+      }
+      _settingsFromDeviceSimulatorState(state) {
+        const s = state;
+        if (!s || s.isSimulating !== true || typeof s.activeDeviceId !== "string" || s.activeDeviceId === "default") {
+          return { stopSimulation: true };
+        }
+        return normalizeDeviceSimulatorSettings({
+          deviceId: s.activeDeviceId,
+          orientation: s.orientation,
+          resolution: s.resolution,
+          pixelDensity: s.pixelDensity,
+          scalingMode: s.scalingMode
+        });
+      }
+      _deviceSimulatorStateWithoutDeviceList(state) {
+        if (typeof state !== "object" || state === null || Array.isArray(state)) {
+          return state;
+        }
+        const { devices: _devices, ...rest } = state;
+        return rest;
+      }
+      _assertCanRestoreDeviceSimulatorState(state) {
+        const s = state;
+        if (!s || s.isSimulating !== true || typeof s.activeDeviceId !== "string" || s.activeDeviceId === "default") {
+          return;
+        }
+        const devices = Array.isArray(s.devices) ? s.devices : [];
+        const isBuiltIn = devices.some((entry) => {
+          if (typeof entry !== "object" || entry === null || Array.isArray(entry))
+            return false;
+          const device = entry;
+          const id = device.DeviceId ?? device.deviceId ?? device.Id ?? device.id;
+          return id === s.activeDeviceId && device.IsCustom !== true;
+        });
+        if (!isBuiltIn) {
+          throw new Error(`capture_device_matrix cannot safely restore active custom device "${s.activeDeviceId}". Switch the simulator to default or a built-in preset first, or pass restoreAfter=false only if you intentionally accept changing the simulator state.`);
+        }
+      }
       async _waitForRuntimeRoles(instanceId, opts, timeoutSec = 30) {
         const deadline = Date.now() + timeoutSec * 1e3;
         while (Date.now() < deadline) {
@@ -3476,18 +3800,12 @@ ${code}`
         if (!code) {
           throw new Error("Code is required for eval_server_runtime");
         }
-        const wrapper = buildModuleScriptInvokeWrapper({
-          service: "ServerScriptService",
-          bridgeName: SERVER_LOCAL_NAME,
-          missingError: "ServerEvalBridge not found. The bridge runs inside the play DM, so a playtest must be running. The bridge installs automatically (including for manually-started playtests); if a playtest is running and you still see this, reconnect the plugin in the edit window so the bridge reinstalls, then start the playtest again.",
-          userCode: code
-        });
-        const response = await this._callSingle("/api/execute-luau", { code: wrapper }, "server", instance_id);
+        const response = await this._callSingle("/api/eval-runtime", { code }, "server", instance_id);
         return {
           content: [
             {
               type: "text",
-              text: parseBridgeResponse(response)
+              text: JSON.stringify(response)
             }
           ]
         };
@@ -3500,22 +3818,375 @@ ${code}`
         if (!clientTarget.startsWith("client-")) {
           throw new Error(`eval_client_runtime requires target=client-N (got: ${clientTarget})`);
         }
-        const wrapper = buildModuleScriptInvokeWrapper({
-          service: "ReplicatedStorage",
-          bridgeName: CLIENT_LOCAL_NAME,
-          missingError: "ClientEvalBridge not found. The bridge runs inside the play DM, so a playtest must be running. The bridge installs automatically (including for manually-started playtests); if a playtest is running and you still see this, reconnect the plugin in the edit window so the bridge reinstalls, then start the playtest again.",
-          userCode: code
-        });
-        const response = await this._callSingle("/api/execute-luau", { code: wrapper }, clientTarget, instance_id);
+        const response = await this._callSingle("/api/eval-runtime", { code }, clientTarget, instance_id);
         return {
           content: [
             {
               type: "text",
-              text: parseBridgeResponse(response)
+              text: JSON.stringify(response)
             }
           ]
         };
       }
+      async setNetworkProfile(profile, target, overrides, instance_id) {
+        const values = normalizeNetworkProfile(profile, overrides);
+        const instanceId = this._resolveInstanceIdOnly(instance_id);
+        const clientRoles = this._clientRolesForInstance(instanceId);
+        const selectedTarget = target ?? "client-1";
+        let targetRoles;
+        if (selectedTarget === "all-clients") {
+          targetRoles = clientRoles;
+        } else if (/^client-\d+$/.test(selectedTarget)) {
+          if (!clientRoles.includes(selectedTarget)) {
+            throw new RoutingFailure({
+              code: "target_role_not_present_on_instance",
+              message: `instance "${instanceId}" has no role "${selectedTarget}". Available client roles: ${clientRoles.join(", ") || "none"}.`,
+              data: {
+                instances: this.bridge.getPublicInstances(),
+                count: this.bridge.getInstances().length
+              }
+            });
+          }
+          targetRoles = [selectedTarget];
+        } else {
+          throw new Error(`set_network_profile target must be "client-N" or "all-clients" (got: ${selectedTarget})`);
+        }
+        if (targetRoles.length === 0) {
+          throw new RoutingFailure({
+            code: "target_role_not_present_on_instance",
+            message: `instance "${instanceId}" has no connected playtest client roles. Start a playtest first.`,
+            data: {
+              instances: this.bridge.getPublicInstances(),
+              count: this.bridge.getInstances().length
+            }
+          });
+        }
+        const code = buildNetworkProfileLuau(profile, values);
+        const responses = await Promise.allSettled(targetRoles.map(async (role) => {
+          const response = await this.client.request("/api/execute-luau", { code }, instanceId, role);
+          const result = this._parseExecuteLuauJsonResponse(response, "set_network_profile");
+          return { role, result };
+        }));
+        const body = {
+          profile,
+          target: selectedTarget,
+          applied: values,
+          targets: {}
+        };
+        const targetResults = body.targets;
+        const failures = [];
+        for (let i = 0; i < responses.length; i++) {
+          const role = targetRoles[i];
+          const response = responses[i];
+          if (response.status === "fulfilled") {
+            targetResults[role] = response.value.result;
+          } else {
+            const message = errorMessage(response.reason);
+            targetResults[role] = { error: message };
+            failures.push(`${role}: ${message}`);
+          }
+        }
+        if (failures.length > 0) {
+          throw new Error(`set_network_profile failed for ${failures.join("; ")}. Partial result: ${JSON.stringify(body)}`);
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(body)
+            }
+          ]
+        };
+      }
+      async getSimulationState(include, target, instance_id) {
+        const selectedInclude = this._normalizeSimulationInclude(include);
+        const includeNetwork = selectedInclude === "network" || selectedInclude === "both";
+        const includeDeviceSimulator = selectedInclude === "deviceSimulator" || selectedInclude === "both";
+        const resolved = this._resolveSimulationTargets(target, instance_id, "get_simulation_state");
+        const roleEntries = await Promise.all(resolved.roles.map(async (role) => {
+          const state = {};
+          const errors = {};
+          if (includeNetwork) {
+            try {
+              state.network = await this._executeNetworkStateOperation(resolved.instanceId, role, "get");
+            } catch (error) {
+              errors.network = errorMessage(error);
+            }
+          }
+          if (includeDeviceSimulator) {
+            try {
+              state.deviceSimulator = await this._executeDeviceSimulatorOperation(resolved.instanceId, role, "get", { includeDeviceList: false });
+            } catch (error) {
+              errors.deviceSimulator = errorMessage(error);
+            }
+          }
+          if (Object.keys(errors).length > 0) {
+            state.errors = errors;
+          }
+          return { role, state };
+        }));
+        const roles = {};
+        for (const entry of roleEntries) {
+          roles[entry.role] = entry.state;
+        }
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              include: selectedInclude,
+              target: resolved.selectedTarget,
+              roles,
+              warnings: resolved.warnings,
+              persistenceNotes: SIMULATION_PERSISTENCE_NOTES
+            })
+          }]
+        };
+      }
+      async resetSimulationState(target, network, deviceSimulator, instance_id) {
+        const resetNetwork = network !== false;
+        const resetDeviceSimulator = deviceSimulator !== false;
+        if (!resetNetwork && !resetDeviceSimulator) {
+          throw new Error("reset_simulation_state requires network=true and/or deviceSimulator=true; both default to true");
+        }
+        const resolved = this._resolveSimulationTargets(target, instance_id, "reset_simulation_state");
+        const roleEntries = await Promise.all(resolved.roles.map(async (role) => {
+          const result = {};
+          const errors = {};
+          if (resetNetwork) {
+            try {
+              result.network = await this._executeNetworkStateOperation(resolved.instanceId, role, "reset");
+            } catch (error) {
+              errors.network = errorMessage(error);
+            }
+          }
+          if (resetDeviceSimulator) {
+            try {
+              result.deviceSimulator = await this._executeDeviceSimulatorOperation(resolved.instanceId, role, "set", { stopSimulation: true });
+            } catch (error) {
+              errors.deviceSimulator = errorMessage(error);
+            }
+          }
+          if (Object.keys(errors).length > 0) {
+            result.errors = errors;
+          }
+          return { role, result };
+        }));
+        const roles = {};
+        const failures = [];
+        for (const entry of roleEntries) {
+          roles[entry.role] = entry.result;
+          const errors = entry.result.errors;
+          if (errors) {
+            for (const [kind, message] of Object.entries(errors)) {
+              failures.push(`${entry.role}.${kind}: ${message}`);
+            }
+          }
+        }
+        const body = {
+          target: resolved.selectedTarget,
+          network: resetNetwork,
+          deviceSimulator: resetDeviceSimulator,
+          roles,
+          warnings: resolved.warnings,
+          persistenceNotes: SIMULATION_PERSISTENCE_NOTES
+        };
+        if (failures.length > 0) {
+          throw new Error(`reset_simulation_state failed for ${failures.join("; ")}. Partial result: ${JSON.stringify(body)}`);
+        }
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify(body)
+          }]
+        };
+      }
+      async getDeviceSimulatorState(target, deviceId, includeDeviceList, instance_id) {
+        if (deviceId !== void 0 && (typeof deviceId !== "string" || deviceId.trim() === "")) {
+          throw new Error("deviceId must be a non-empty string when provided");
+        }
+        const resolved = this._resolveDeviceSimulatorSingleTarget(target, instance_id, "get_device_simulator_state");
+        const state = await this._executeDeviceSimulatorOperation(resolved.instanceId, resolved.role, "get", {
+          includeDeviceList: includeDeviceList !== false,
+          deviceId
+        });
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              target: resolved.selectedTarget,
+              role: resolved.role,
+              ...state
+            })
+          }]
+        };
+      }
+      async setDeviceSimulator(target, deviceId, orientation, resolution, pixelDensity, scalingMode, stopSimulation, instance_id) {
+        const settings = normalizeDeviceSimulatorSettings({ deviceId, orientation, resolution, pixelDensity, scalingMode });
+        if (stopSimulation === true && hasDeviceSimulatorSettings(settings)) {
+          throw new Error("stopSimulation=true cannot be combined with deviceId, orientation, resolution, pixelDensity, or scalingMode");
+        }
+        if (stopSimulation !== true && !hasDeviceSimulatorSettings(settings)) {
+          throw new Error("set_device_simulator requires stopSimulation=true or at least one simulator setting");
+        }
+        const resolved = this._resolveDeviceSimulatorSetTargets(target, instance_id);
+        const responses = await Promise.allSettled(resolved.roles.map(async (role) => {
+          const result = await this._executeDeviceSimulatorOperation(resolved.instanceId, role, "set", stopSimulation === true ? { stopSimulation: true } : { settings });
+          return { role, result };
+        }));
+        const body = {
+          target: resolved.selectedTarget,
+          targets: {}
+        };
+        const targets = body.targets;
+        const failures = [];
+        for (let i = 0; i < responses.length; i++) {
+          const role = resolved.roles[i];
+          const response = responses[i];
+          if (response.status === "fulfilled") {
+            targets[role] = response.value.result;
+          } else {
+            const message = errorMessage(response.reason);
+            targets[role] = { error: message };
+            failures.push(`${role}: ${message}`);
+          }
+        }
+        if (failures.length > 0) {
+          throw new Error(`set_device_simulator failed for ${failures.join("; ")}. Partial result: ${JSON.stringify(body)}`);
+        }
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify(body)
+          }]
+        };
+      }
+      async captureDeviceMatrix(entries, target, format, quality, settleSeconds, restoreAfter, instance_id) {
+        if (!Array.isArray(entries) || entries.length === 0) {
+          throw new Error("capture_device_matrix requires a non-empty entries array");
+        }
+        if (entries.length > MAX_DEVICE_MATRIX_ENTRIES) {
+          throw new Error(`capture_device_matrix supports at most ${MAX_DEVICE_MATRIX_ENTRIES} entries per call; split larger matrices into multiple calls`);
+        }
+        const matrixEntries = entries.map((entry, index) => {
+          if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
+            throw new Error(`entries[${index}] must be an object`);
+          }
+          const raw = entry;
+          if (raw.label !== void 0 && typeof raw.label !== "string") {
+            throw new Error(`entries[${index}].label must be a string when provided`);
+          }
+          return {
+            ...normalizeDeviceSimulatorSettings({
+              deviceId: raw.deviceId,
+              orientation: raw.orientation,
+              resolution: raw.resolution,
+              pixelDensity: raw.pixelDensity,
+              scalingMode: raw.scalingMode
+            }),
+            label: raw.label
+          };
+        });
+        const resolved = this._resolveDeviceSimulatorSingleTarget(target, instance_id, "capture_device_matrix");
+        if (resolved.role.startsWith("client-") && await this._isMultiplayerTestRunning(resolved.instanceId)) {
+          throw new Error("capture_device_matrix does not support StudioTestService multiplayer client targets because Roblox scopes temporary screenshot textures per client process");
+        }
+        const settleMs = settleSeconds === void 0 ? 300 : Math.max(0, Math.floor(settleSeconds * 1e3));
+        const shouldRestore = restoreAfter !== false;
+        const before = await this._executeDeviceSimulatorOperation(resolved.instanceId, resolved.role, "get", { includeDeviceList: shouldRestore });
+        if (shouldRestore) {
+          this._assertCanRestoreDeviceSimulatorState(before);
+        }
+        const summary = {
+          target: resolved.selectedTarget,
+          role: resolved.role,
+          restoreAfter: shouldRestore,
+          before: this._deviceSimulatorStateWithoutDeviceList(before),
+          entries: []
+        };
+        const entrySummaries = summary.entries;
+        const content = [];
+        const failures = [];
+        try {
+          for (let i = 0; i < matrixEntries.length; i++) {
+            const entry = matrixEntries[i];
+            const label = entry.label ?? `entry-${i + 1}`;
+            const entrySummary = {
+              index: i,
+              label,
+              settings: entry
+            };
+            entrySummaries.push(entrySummary);
+            try {
+              const { label: _label, ...settings } = entry;
+              const applied = await this._executeDeviceSimulatorOperation(resolved.instanceId, resolved.role, "set", { settings });
+              entrySummary.applied = applied;
+              if (settleMs > 0)
+                await sleep(settleMs);
+              const capture = await this._captureViewportImage(resolved.instanceId, resolved.role, format, quality);
+              if (capture.success) {
+                entrySummary.screenshot = {
+                  width: capture.width,
+                  height: capture.height,
+                  format: capture.format,
+                  quality: capture.quality,
+                  mimeType: capture.mimeType
+                };
+                content.push({
+                  type: "text",
+                  text: `capture_device_matrix ${i + 1}/${matrixEntries.length} ${label}: ${capture.message}`
+                });
+                content.push({
+                  type: "image",
+                  data: capture.data,
+                  mimeType: capture.mimeType
+                });
+              } else {
+                entrySummary.error = capture.error;
+                failures.push(`${label}: ${capture.error}`);
+                content.push({
+                  type: "text",
+                  text: `capture_device_matrix ${i + 1}/${matrixEntries.length} ${label}: ${capture.error}`
+                });
+              }
+            } catch (error) {
+              const message = errorMessage(error);
+              entrySummary.error = message;
+              failures.push(`${label}: ${message}`);
+              content.push({
+                type: "text",
+                text: `capture_device_matrix ${i + 1}/${matrixEntries.length} ${label}: ${message}`
+              });
+            }
+          }
+        } finally {
+          if (shouldRestore) {
+            try {
+              const restoreSettings = this._settingsFromDeviceSimulatorState(before);
+              if ("stopSimulation" in restoreSettings) {
+                summary.restore = await this._executeDeviceSimulatorOperation(resolved.instanceId, resolved.role, "set", { stopSimulation: true });
+              } else {
+                summary.restore = await this._executeDeviceSimulatorOperation(resolved.instanceId, resolved.role, "set", { settings: restoreSettings });
+              }
+            } catch (error) {
+              const message = errorMessage(error);
+              summary.restoreError = message;
+              failures.push(`restore: ${message}`);
+            }
+          }
+        }
+        if (failures.length > 0) {
+          throw new Error(`capture_device_matrix failed for ${failures.join("; ")}. Partial result: ${JSON.stringify(summary)}`);
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(summary)
+            },
+            ...content
+          ]
+        };
+      }
       async getRuntimeLogs(target, since, tail, filter, instance_id) {
         const tgt = target ?? "all";
         const data = {};
@@ -3529,11 +4200,19 @@ ${code}`
         if (!resolved.ok)
           throw new RoutingFailure(resolved.error);
         if (resolved.mode === "single") {
+          const originPeerReliable2 = await this._isMultiplayerTestRunning(resolved.targetInstanceId);
           const response = await this.client.request("/api/get-runtime-logs", data, resolved.targetInstanceId, resolved.targetRole);
-          response.peer = resolved.targetRole;
+          response.capturedBy = resolved.targetRole;
+          delete response.peer;
+          response.originPeerReliable = originPeerReliable2;
+          response.peerAttribution = originPeerReliable2 ? "guaranteed_multiplayer" : "unavailable_shared_logservice";
+          if (originPeerReliable2)
+            response.peer = resolved.targetRole;
           if (Array.isArray(response.entries)) {
             for (const e of response.entries) {
-              if (e.peer !== void 0)
+              e.capturedBy = resolved.targetRole;
+              delete e.peer;
+              if (originPeerReliable2)
                 e.peer = resolved.targetRole;
             }
           }
@@ -3542,35 +4221,38 @@ ${code}`
           };
         }
         const targets = resolved.targets.filter((t) => t.targetRole !== "edit-proxy");
+        const originPeerReliable = targets.length > 0 ? await this._isMultiplayerTestRunning(targets[0].targetInstanceId) : false;
         const responses = await Promise.allSettled(targets.map(async (t) => {
           const r = await this.client.request("/api/get-runtime-logs", data, t.targetInstanceId, t.targetRole);
-          return { ...r, peer: t.targetRole };
+          return { ...r, capturedBy: t.targetRole };
         }));
         const merged = [];
-        const perPeerNextSince = {};
-        const perPeerErrors = {};
+        const perCaptureNextSince = {};
+        const perCaptureErrors = {};
         let totalDropped = 0;
         for (const r of responses) {
           if (r.status !== "fulfilled")
             continue;
           const v = r.value;
-          const peer = v.peer ?? "unknown";
+          const capturedBy = v.capturedBy ?? "unknown";
           if (v.error) {
-            perPeerErrors[peer] = v.error;
+            perCaptureErrors[capturedBy] = v.error;
             continue;
           }
           if (v.nextSince !== void 0)
-            perPeerNextSince[peer] = v.nextSince;
+            perCaptureNextSince[capturedBy] = v.nextSince;
           totalDropped += v.totalDropped ?? 0;
           for (const e of v.entries ?? []) {
-            merged.push({ ...e, peer });
+            const entry = { ...e };
+            delete entry.peer;
+            merged.push({ ...entry, capturedBy });
           }
         }
         merged.sort((a, b) => a.ts !== b.ts ? a.ts - b.ts : a.seq - b.seq);
         const DEDUP_WINDOW = 2;
         const deduped = [];
         for (const e of merged) {
-          const isDup = deduped.some((d) => d.message === e.message && d.level === e.level && Math.abs(d.ts - e.ts) <= DEDUP_WINDOW && d.peer !== e.peer);
+          const isDup = deduped.some((d) => d.message === e.message && d.level === e.level && Math.abs(d.ts - e.ts) <= DEDUP_WINDOW && d.capturedBy !== e.capturedBy);
           if (!isDup)
             deduped.push(e);
         }
@@ -3578,13 +4260,21 @@ ${code}`
         if (tail !== void 0 && deduped.length > tail) {
           final = deduped.slice(deduped.length - tail);
         }
+        const finalEntries = originPeerReliable ? final.map((e) => ({ ...e, peer: e.capturedBy })) : final;
         const body = {
-          entries: final,
+          entries: finalEntries,
           totalDropped,
-          perPeerNextSince
+          perCaptureNextSince,
+          originPeerReliable,
+          peerAttribution: originPeerReliable ? "guaranteed_multiplayer" : "unavailable_shared_logservice"
         };
-        if (Object.keys(perPeerErrors).length > 0) {
-          body.perPeerErrors = perPeerErrors;
+        if (originPeerReliable) {
+          body.perPeerNextSince = perCaptureNextSince;
+        }
+        if (Object.keys(perCaptureErrors).length > 0) {
+          body.perCaptureErrors = perCaptureErrors;
+          if (originPeerReliable)
+            body.perPeerErrors = perCaptureErrors;
         }
         return {
           content: [{ type: "text", text: JSON.stringify(body) }]
@@ -3708,15 +4398,19 @@ ${code}`
         return false;
       }
       async _isMultiplayerTestRunning(instanceId) {
-        if (!this._rolesForInstance(instanceId).includes("edit"))
-          return false;
-        try {
-          const editState = await this.client.request("/api/multiplayer-test-state", {}, instanceId, "edit");
-          const phase = editState?.session?.phase;
-          return phase === "starting" || phase === "running";
-        } catch {
-          return false;
+        const roles = this._rolesForInstance(instanceId);
+        const hasServer = roles.includes("server");
+        const clientCount = roles.filter((role) => role.startsWith("client-")).length;
+        if (roles.includes("edit")) {
+          try {
+            const editState = await this.client.request("/api/multiplayer-test-state", {}, instanceId, "edit");
+            const phase = editState?.session?.phase;
+            if (phase === "starting" || phase === "running")
+              return true;
+          } catch {
+          }
         }
+        return hasServer && clientCount >= 2;
       }
       async _waitForMultiplayerStart(instanceId, clientCount, timeoutSec = 30) {
         const deadline = Date.now() + timeoutSec * 1e3;
@@ -4833,16 +5527,15 @@ ${code}`
         }, tgt, instance_id);
         return { content: [{ type: "text", text: JSON.stringify(response) }] };
       }
-      async captureScreenshot(instance_id, format, quality) {
-        const { instanceId, clientRole } = this._resolveRuntime(instance_id);
+      async _captureViewportImage(instanceId, targetRole, format, quality) {
         let response;
-        if (clientRole) {
-          const begin = await this._callSingle("/api/capture-begin", {}, clientRole, instanceId);
+        if (targetRole.startsWith("client-")) {
+          const begin = await this._callSingle("/api/capture-begin", {}, targetRole, instanceId);
           if (begin.error) {
-            return { content: [{ type: "text", text: begin.error }] };
+            return { success: false, error: begin.error };
           }
           if (!begin.contentId) {
-            return { content: [{ type: "text", text: "Screenshot capture failed: no content id returned from client." }] };
+            return { success: false, error: "Screenshot capture failed: no content id returned from client." };
           }
           response = await this._callSingle("/api/capture-read", { contentId: begin.contentId }, "edit", instanceId);
         } else {
@@ -4850,55 +5543,66 @@ ${code}`
         }
         if (response.error) {
           let text = response.error;
-          if (clientRole && response.error.includes("Failed to load texture, unexpected format") && await this._isMultiplayerTestRunning(instanceId)) {
+          if (targetRole.startsWith("client-") && response.error.includes("Failed to load texture, unexpected format") && await this._isMultiplayerTestRunning(instanceId)) {
             text = `Screenshot capture reached the multiplayer client, but Roblox returned a temporary screenshot texture that the edit peer cannot read in StudioTestService multiplayer sessions. Regular start_playtest capture works because the temporary rbxtemp:// handle is readable from the edit process; multiplayer client handles appear to be scoped to the client process. Raw error: ${response.error}`;
           }
-          return {
-            content: [{
-              type: "text",
-              text
-            }]
-          };
+          return { success: false, error: text };
         }
         const w = response.width;
         const h = response.height;
         if (w === void 0 || h === void 0) {
-          return { content: [{ type: "text", text: "Screenshot response missing dimensions." }] };
+          return { success: false, error: "Screenshot response missing dimensions." };
         }
         const fmt = format === "png" ? "png" : "jpeg";
         const q = quality === void 0 ? 92 : Math.max(1, Math.min(100, Math.floor(quality)));
-        const MAX_IMAGE_BYTES = 6e6;
         const encoded = encodeImageFromRgbaResponse(response, fmt, q);
         let { buffer } = encoded;
         const { mimeType } = encoded;
         let usedQ = q;
         let note = "";
-        if (buffer.length > MAX_IMAGE_BYTES) {
+        if (buffer.length > MAX_INLINE_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.`
-              }]
+              success: false,
+              error: `PNG screenshot is ${mb}MB, over the ~${(MAX_INLINE_IMAGE_BYTES / 1048576).toFixed(0)}MB inline image limit. Use the default jpeg format (optionally with a "quality" value) or make the Studio window smaller for a lossless capture.`
             };
           }
-          while (buffer.length > MAX_IMAGE_BYTES && usedQ > 25) {
+          while (buffer.length > MAX_INLINE_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`;
         }
+        const message = `Screenshot ${w}x${h}px (${fmt}${fmt === "jpeg" ? ` q${usedQ}` : ""})${note}. For simulate_mouse_input, x/y are pixel coordinates in this exact image with (0,0) at the top-left; it is not downscaled, so use coordinates as you read them off the image.`;
+        return {
+          success: true,
+          width: w,
+          height: h,
+          format: fmt,
+          quality: fmt === "jpeg" ? usedQ : void 0,
+          note,
+          data: buffer.toString("base64"),
+          mimeType,
+          message
+        };
+      }
+      async captureScreenshot(instance_id, format, quality) {
+        const { instanceId, clientRole } = this._resolveRuntime(instance_id);
+        const capture = await this._captureViewportImage(instanceId, clientRole ?? "edit", format, quality);
+        if (!capture.success) {
+          return { content: [{ type: "text", text: capture.error }] };
+        }
         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.`
+              text: capture.message
             },
             {
               type: "image",
-              data: buffer.toString("base64"),
-              mimeType
+              data: capture.data,
+              mimeType: capture.mimeType
             }
           ]
         };
@@ -6060,7 +6764,7 @@ var init_definitions = __esm({
       {
         name: "eval_server_runtime",
         category: "write",
-        description: "Execute Luau on the server peer in the running game's Script VM (shares require cache with user game scripts, unlike execute_luau target=server which runs in plugin context). Requires a running playtest; the bridge is installed automatically (including for playtests started manually via the Studio Play button).",
+        description: "Execute Luau on the server peer in the running game's Script VM (shares require cache with user game scripts, unlike execute_luau target=server which runs in plugin context). Requires a running playtest; the runtime bridge is created automatically inside the play DataModel, including for playtests started manually via the Studio Play button.",
         inputSchema: {
           type: "object",
           properties: {
@@ -6079,7 +6783,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, unlike execute_luau target=client-N which runs in plugin context). Requires a running playtest; the bridge is installed automatically (including for playtests started manually via the Studio Play button).",
+        description: "Execute Luau on a client peer in the running game's LocalScript VM (shares require cache with user game scripts, unlike execute_luau target=client-N which runs in plugin context). Requires a running playtest; the runtime bridge is created automatically inside the play DataModel, including for playtests started manually via the Studio Play button.",
         inputSchema: {
           type: "object",
           properties: {
@@ -6209,6 +6913,280 @@ var init_definitions = __esm({
           }
         }
       },
+      {
+        name: "set_network_profile",
+        category: "write",
+        description: `Apply simulated network conditions to active playtest client peers via NetworkSettings in plugin context. Requires a running playtest and targets only client peers: pass target="client-1", "client-2", etc., or target="all-clients". Presets: great = 30ms total latency (15ms in / 15ms out), 0ms jitter, 0% packet loss; good = 100ms total latency (50ms in / 50ms out), 10ms jitter, 0% packet loss; poor = 300ms (150ms in / 150ms out), 100ms jitter, 0.5% packet loss. profile="custom" applies only the numeric overrides provided; packet loss values above Roblox's 0.5% engine limit are rejected.`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            profile: {
+              type: "string",
+              enum: ["great", "good", "poor", "custom"],
+              description: "Network condition preset. Presets set all six simulation fields; custom requires overrides."
+            },
+            target: {
+              type: "string",
+              description: 'Client target: "client-1" (default), "client-2", etc., or "all-clients" to apply to every connected playtest client.'
+            },
+            overrides: {
+              type: "object",
+              additionalProperties: false,
+              properties: {
+                InboundNetworkMinDelayMs: {
+                  type: "number",
+                  minimum: 0,
+                  description: "Server-to-client minimum latency in milliseconds."
+                },
+                OutboundNetworkMinDelayMs: {
+                  type: "number",
+                  minimum: 0,
+                  description: "Client-to-server minimum latency in milliseconds."
+                },
+                InboundNetworkJitterMs: {
+                  type: "number",
+                  minimum: 0,
+                  description: "Server-to-client latency jitter in milliseconds."
+                },
+                OutboundNetworkJitterMs: {
+                  type: "number",
+                  minimum: 0,
+                  description: "Client-to-server latency jitter in milliseconds."
+                },
+                InboundNetworkLossPercent: {
+                  type: "number",
+                  minimum: 0,
+                  maximum: 0.5,
+                  description: "Server-to-client packet loss percentage. Roblox engine limit is 0.5%; larger values are rejected."
+                },
+                OutboundNetworkLossPercent: {
+                  type: "number",
+                  minimum: 0,
+                  maximum: 0.5,
+                  description: "Client-to-server packet loss percentage. Roblox engine limit is 0.5%; larger values are rejected."
+                }
+              },
+              description: "Optional exact NetworkSettings property overrides. For preset profiles, overrides replace preset fields. For custom, only these properties are applied."
+            },
+            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: ["profile"]
+        }
+      },
+      {
+        name: "get_simulation_state",
+        category: "read",
+        description: 'Inspect current NetworkSettings and/or StudioDeviceSimulatorService state for edit and connected playtest clients only. Defaults to include="both" and target="edit-and-clients"; server peers are skipped. Use before diagnosing network or device-sensitive tests, especially because normal Play can write client simulator changes back to edit and StudioTestService clients can inherit stale device simulator state.',
+        inputSchema: {
+          type: "object",
+          properties: {
+            include: {
+              type: "string",
+              enum: ["network", "deviceSimulator", "both"],
+              description: 'Simulation state to inspect: "network", "deviceSimulator", or "both" (default both).'
+            },
+            target: {
+              type: "string",
+              description: 'Simulation target scope: "edit-and-clients" (default), "edit", "all-clients", or a specific "client-N". Server peers are never included.'
+            },
+            instance_id: {
+              type: "string",
+              description: "Which connected Studio place to target. Required when multiple places are connected; omit when one. Use get_connected_instances to list available IDs."
+            }
+          }
+        }
+      },
+      {
+        name: "reset_simulation_state",
+        category: "write",
+        description: 'Reset reachable simulation state to a clean baseline for deterministic tests. Defaults to target="edit-and-clients" and resets both network and device simulator state. Network reset sets all six simulated NetworkSettings fields to 0; device reset calls StopSimulationAsync(). Call before tests, after starting Play or multiplayer, before stopping, and again on edit after stopping.',
+        inputSchema: {
+          type: "object",
+          properties: {
+            target: {
+              type: "string",
+              description: 'Simulation target scope: "edit-and-clients" (default), "edit", "all-clients", or a specific "client-N". Server peers are skipped.'
+            },
+            network: {
+              type: "boolean",
+              description: "Reset simulated NetworkSettings fields to 0 (default true)."
+            },
+            deviceSimulator: {
+              type: "boolean",
+              description: "Stop Studio device simulation with StopSimulationAsync() (default true)."
+            },
+            instance_id: {
+              type: "string",
+              description: "Which connected Studio place to target. Required when multiple places are connected; omit when one. Use get_connected_instances to list available IDs."
+            }
+          }
+        }
+      },
+      {
+        name: "get_device_simulator_state",
+        category: "read",
+        description: 'Inspect StudioDeviceSimulatorService state and supported built-in device presets. Defaults to target="edit"; also supports a regular playtest client target such as "client-1". Server targets are not supported. When no simulated device is active, active-only fields are omitted and isSimulating=false.',
+        inputSchema: {
+          type: "object",
+          properties: {
+            target: {
+              type: "string",
+              description: 'Device simulator target: "edit" (default) or a regular playtest client like "client-1". Server targets are rejected.'
+            },
+            deviceId: {
+              type: "string",
+              description: "Optional built-in device preset ID to inspect with GetDeviceInfoAsync."
+            },
+            includeDeviceList: {
+              type: "boolean",
+              description: "Include the built-in device preset list from GetDeviceListAsync (default true)."
+            },
+            instance_id: {
+              type: "string",
+              description: "Which connected Studio place to target. Required when multiple places are connected; omit when one. Use get_connected_instances to list available IDs."
+            }
+          }
+        }
+      },
+      {
+        name: "set_device_simulator",
+        category: "write",
+        description: 'Set or stop StudioDeviceSimulatorService using built-in device presets only. Defaults to target="edit"; supports "client-N" and "all-clients"; rejects server targets. Applies deviceId first, then orientation, resolution, pixelDensity, and scalingMode overrides.',
+        inputSchema: {
+          type: "object",
+          properties: {
+            target: {
+              type: "string",
+              description: 'Device simulator target: "edit" (default), "client-1", "client-2", etc., or "all-clients".'
+            },
+            deviceId: {
+              type: "string",
+              description: "Built-in device preset ID from get_device_simulator_state."
+            },
+            orientation: {
+              type: "string",
+              description: 'ScreenOrientation enum name, e.g. "LandscapeRight", "LandscapeLeft", "Portrait", or a full Enum.ScreenOrientation.* string.'
+            },
+            resolution: {
+              type: "object",
+              additionalProperties: false,
+              properties: {
+                width: {
+                  type: "number",
+                  description: "Viewport width in pixels."
+                },
+                height: {
+                  type: "number",
+                  description: "Viewport height in pixels."
+                }
+              },
+              required: ["width", "height"],
+              description: "Optional resolution override applied after the device preset."
+            },
+            pixelDensity: {
+              type: "number",
+              description: "Optional positive pixel density override applied after the device preset."
+            },
+            scalingMode: {
+              type: "string",
+              description: 'DeviceSimulatorScalingMode enum name, e.g. "ScaleToPhysicalSize", or a full Enum.DeviceSimulatorScalingMode.* string.'
+            },
+            stopSimulation: {
+              type: "boolean",
+              description: "Stop device simulation. When true, do not pass other simulator setters."
+            },
+            instance_id: {
+              type: "string",
+              description: "Which connected Studio place to target. Required when multiple places are connected; omit when one. Use get_connected_instances to list available IDs."
+            }
+          }
+        }
+      },
+      {
+        name: "capture_device_matrix",
+        category: "write",
+        description: 'Apply up to 6 ordered Studio device simulator settings, capture each viewport screenshot, and restore the previous simulator state by default when the prior state is default or a built-in preset. Custom device persistence is intentionally unsupported. Defaults to target="edit"; supports regular playtest client targets but not server or all-clients targets.',
+        inputSchema: {
+          type: "object",
+          properties: {
+            entries: {
+              type: "array",
+              maxItems: 6,
+              description: "Ordered device capture entries. Each entry may set a deviceId and optional simulator overrides before capture.",
+              items: {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                  label: {
+                    type: "string",
+                    description: "Optional label included in the screenshot metadata."
+                  },
+                  deviceId: {
+                    type: "string",
+                    description: "Built-in device preset ID from get_device_simulator_state."
+                  },
+                  orientation: {
+                    type: "string",
+                    description: "ScreenOrientation enum name or full Enum.ScreenOrientation.* string."
+                  },
+                  resolution: {
+                    type: "object",
+                    additionalProperties: false,
+                    properties: {
+                      width: {
+                        type: "number",
+                        description: "Viewport width in pixels."
+                      },
+                      height: {
+                        type: "number",
+                        description: "Viewport height in pixels."
+                      }
+                    },
+                    required: ["width", "height"]
+                  },
+                  pixelDensity: {
+                    type: "number",
+                    description: "Optional positive pixel density override."
+                  },
+                  scalingMode: {
+                    type: "string",
+                    description: "DeviceSimulatorScalingMode enum name or full Enum.DeviceSimulatorScalingMode.* string."
+                  }
+                }
+              }
+            },
+            target: {
+              type: "string",
+              description: 'Device simulator target: "edit" (default) or a regular playtest client such as "client-1". all-clients and server targets are rejected.'
+            },
+            format: {
+              type: "string",
+              enum: ["jpeg", "png"],
+              description: 'Screenshot image format. "jpeg" (default) is compact; "png" is lossless but may exceed inline size limits.'
+            },
+            quality: {
+              type: "number",
+              description: "JPEG quality 1-100 (default 92). Ignored for png."
+            },
+            settleSeconds: {
+              type: "number",
+              description: "Seconds to wait after applying each simulator entry before capturing (default 0.3)."
+            },
+            restoreAfter: {
+              type: "boolean",
+              description: "Restore the previous default or built-in preset simulator state after the matrix finishes (default true). Custom active devices are not preserved."
+            },
+            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: ["entries"]
+        }
+      },
       {
         name: "multiplayer_test_start",
         category: "write",
@@ -6318,17 +7296,17 @@ var init_definitions = __esm({
       {
         name: "get_runtime_logs",
         category: "read",
-        description: "Read the in-memory log buffer captured by the plugin on each peer's LogService.MessageOut. Each peer (edit, server, client-N) captures ~64 KB of recent prints; oldest entries drop when over budget. Drop-oldest semantics preserve the recent tail, unlike get_console_output's 10 KB drop-newest cap. Caveat: peer tag reflects which peer's plugin captured the entry, not which peer's script originated it - LogService reflects prints across peers in Studio Play and origin is undetectable from inside MessageOut. target=all (default) merges all peers and dedups same-message-and-level entries captured within 2s across different peers.",
+        description: "Read the in-memory log buffers captured by Studio plugin peers. Each buffer captures ~64 KB of recent LogService.MessageOut entries; oldest entries drop when over budget. Entries include capturedBy for the plugin buffer that observed the log. In ordinary Studio play/run sessions, LogService reflects logs across edit/server/client, so script-origin peer is not reliable and entries omit peer. In StudioTestService multiplayer sessions only, peer attribution is reliable and entries also include peer. target=all (default) merges buffers and dedups same-message-and-level entries captured within 2s across different buffers.",
         inputSchema: {
           type: "object",
           properties: {
             target: {
               type: "string",
-              description: 'Peer to read from: "edit", "server", "client-N", or "all" (default). "all" merges all peers and dedups cross-peer reflections within a 2s window.'
+              description: 'Capture buffer to read from: "edit", "server", "client-N", or "all" (default). "all" merges buffers and dedups cross-buffer reflections within a 2s window.'
             },
             since: {
               type: "number",
-              description: "Return only entries with seq > since. Pass back the previous response's nextSince (single-peer) or perPeerNextSince entry (target=all) for incremental polling."
+              description: "Return only entries with seq > since. Pass back the previous response's nextSince (single target) or perCaptureNextSince entry (target=all) for incremental polling."
             },
             tail: {
               type: "number",
@@ -7351,7 +8329,7 @@ function handleVariantConflict({ pluginsFolder, otherAssetName, replace, log = c
   warn(`
 [install-plugin] WARNING: ${otherAssetName} is already present in ${pluginsFolder}.
 Only one MCP plugin variant should be present. If both variants are in the Studio Plugins folder, Studio loads both and runtime routing can become unpredictable.
-Re-run with --replace-variant to remove ${otherAssetName}, or delete it manually.
+Delete ${otherAssetName} manually or use the default CLI installer behavior to replace it.
 `);
 }
 var init_install_plugin_helpers = __esm({
@@ -7473,6 +8451,27 @@ function bundledAssetPath() {
   ];
   return candidates.find((candidate) => existsSync3(candidate)) ?? null;
 }
+function packageVersion() {
+  const currentDir = dirname2(fileURLToPath(import.meta.url));
+  const pkg = JSON.parse(readFileSync3(join3(currentDir, "..", "package.json"), "utf8"));
+  if (!pkg.version) {
+    throw new Error("Package version not found");
+  }
+  return pkg.version;
+}
+function bundledPluginVersion(source) {
+  const match = readFileSync3(source, "utf8").match(/local CURRENT_VERSION = "([^"]+)"/);
+  return match ? match[1] : null;
+}
+function assertBundledPluginVersion(source) {
+  const expected = packageVersion();
+  const actual = bundledPluginVersion(source);
+  if (actual !== expected) {
+    throw new Error(
+      `Bundled ${ASSET_NAME} version ${actual ?? "unknown"} does not match package version ${expected}. Run npm run build:plugin before starting with --auto-install-plugin.`
+    );
+  }
+}
 function filesMatch(a, b) {
   if (!existsSync3(b)) return false;
   const aBytes = readFileSync3(a);
@@ -7482,11 +8481,12 @@ function filesMatch(a, b) {
 async function installBundledPlugin(options = {}) {
   const log = options.log ?? console.log;
   const warn = options.warn ?? console.warn;
-  const replaceVariant = options.replaceVariant ?? process.argv.includes("--replace-variant");
+  const replaceVariant = options.replaceVariant ?? true;
   const source = bundledAssetPath();
   if (!source) {
     throw new Error(`Bundled ${ASSET_NAME} not found in package`);
   }
+  assertBundledPluginVersion(source);
   const pluginsFolder = prepareInstall({ replaceVariant, log, warn });
   const dest = join3(pluginsFolder, ASSET_NAME);
   if (filesMatch(source, dest)) return;
@@ -7495,10 +8495,22 @@ async function installBundledPlugin(options = {}) {
 }
 async function installPlugin(options = {}) {
   const dev = options.dev ?? process.argv.includes("--dev");
-  const replaceVariant = options.replaceVariant ?? process.argv.includes("--replace-variant");
+  const replaceVariant = options.replaceVariant ?? true;
   const log = options.log ?? console.log;
   const warn = options.warn ?? console.warn;
   const pluginsFolder = prepareInstall({ replaceVariant, log, warn });
+  const bundled = bundledAssetPath();
+  if (bundled) {
+    assertBundledPluginVersion(bundled);
+    const dest2 = join3(pluginsFolder, ASSET_NAME);
+    if (filesMatch(bundled, dest2)) {
+      log(`${ASSET_NAME} already installed.`);
+      return;
+    }
+    copyFileSync(bundled, dest2);
+    log(`Installed bundled ${ASSET_NAME} to ${dest2}`);
+    return;
+  }
   log(dev ? "Fetching latest dev prerelease..." : "Fetching latest release...");
   const release = dev ? await findDevRelease() : await fetchJson(`https://api.github.com/repos/${REPO}/releases/latest`);
   const asset = release.assets?.find((a) => a.name === ASSET_NAME);
@@ -7528,7 +8540,7 @@ init_dist();
 import { createRequire } from "module";
 if (process.argv.includes("--install-plugin")) {
   const { installPlugin: installPlugin2 } = await Promise.resolve().then(() => (init_install_plugin(), install_plugin_exports));
-  installPlugin2().catch((err) => {
+  await installPlugin2().catch((err) => {
     console.error(err instanceof Error ? err.message : String(err));
     process.exitCode = 1;
   });
@@ -7536,7 +8548,6 @@ if (process.argv.includes("--install-plugin")) {
   if (process.argv.includes("--auto-install-plugin")) {
     const { installBundledPlugin: installBundledPlugin2 } = await Promise.resolve().then(() => (init_install_plugin(), install_plugin_exports));
     await installBundledPlugin2({
-      replaceVariant: process.argv.includes("--replace-variant"),
       log: (message) => console.error(`[install-plugin] ${message}`),
       warn: (message) => console.error(message)
     }).catch((err) => {